react-native-gifted-chat

  • Version 0.16.3
  • Published
  • 287 kB
  • 9 dependencies
  • MIT license

Install

npm i react-native-gifted-chat
yarn add react-native-gifted-chat
pnpm add react-native-gifted-chat

Overview

The most complete chat UI for React Native

Index

Classes

Interfaces

Type Aliases

Namespaces

Classes

class Actions

class Actions extends React.Component<ActionsProps> {}

    property contextTypes

    static contextTypes: { actionSheet: any };

      property defaultProps

      static defaultProps: ActionsProps;

        property onActionsPress

        onActionsPress: () => void;

          property propTypes

          static propTypes: {
          onSend: any;
          options: any;
          optionTintColor: any;
          icon: any;
          onPressActionButton: any;
          wrapperStyle: any;
          containerStyle: any;
          };

            method render

            render: () => any;

              method renderIcon

              renderIcon: () => {} | null | undefined;

                class Avatar

                class Avatar<TMessage extends IMessage = IMessage> extends React.Component<
                AvatarProps<TMessage>
                > {}

                  property defaultProps

                  static defaultProps: {
                  renderAvatarOnTop: boolean;
                  showAvatarForEveryMessage: boolean;
                  position: string;
                  currentMessage: { user: null };
                  previousMessage: {};
                  nextMessage: {};
                  containerStyle: {};
                  imageStyle: {};
                  onPressAvatar: () => void;
                  onLongPressAvatar: () => void;
                  };

                    property propTypes

                    static propTypes: {
                    renderAvatarOnTop: any;
                    showAvatarForEveryMessage: any;
                    position: any;
                    currentMessage: any;
                    previousMessage: any;
                    nextMessage: any;
                    onPressAvatar: any;
                    onLongPressAvatar: any;
                    renderAvatar: any;
                    containerStyle: any;
                    imageStyle: any;
                    };

                      method render

                      render: () => JSX.Element | null;

                        method renderAvatar

                        renderAvatar: () => {} | null | undefined;

                          class Bubble

                          class Bubble<TMessage extends IMessage = IMessage> extends React.Component<
                          BubbleProps<TMessage>
                          > {}

                            property contextTypes

                            static contextTypes: { actionSheet: any };

                              property defaultProps

                              static defaultProps: {
                              touchableProps: {};
                              onLongPress: null;
                              renderMessageImage: null;
                              renderMessageVideo: null;
                              renderMessageAudio: null;
                              renderMessageText: null;
                              renderCustomView: null;
                              renderUsername: null;
                              renderTicks: null;
                              renderTime: null;
                              renderQuickReplies: null;
                              onQuickReply: null;
                              position: string;
                              optionTitles: string[];
                              currentMessage: { text: null; createdAt: null; image: null };
                              nextMessage: {};
                              previousMessage: {};
                              containerStyle: {};
                              wrapperStyle: {};
                              bottomContainerStyle: {};
                              tickStyle: {};
                              usernameStyle: {};
                              containerToNextStyle: {};
                              containerToPreviousStyle: {};
                              };

                                property onLongPress

                                onLongPress: () => void;

                                  property propTypes

                                  static propTypes: {
                                  user: any;
                                  touchableProps: any;
                                  onLongPress: any;
                                  renderMessageImage: any;
                                  renderMessageVideo: any;
                                  renderMessageAudio: any;
                                  renderMessageText: any;
                                  renderCustomView: any;
                                  isCustomViewBottom: any;
                                  renderUsernameOnMessage: any;
                                  renderUsername: any;
                                  renderTime: any;
                                  renderTicks: any;
                                  renderQuickReplies: any;
                                  onQuickReply: any;
                                  position: any;
                                  optionTitles: any;
                                  currentMessage: any;
                                  nextMessage: any;
                                  previousMessage: any;
                                  containerStyle: any;
                                  wrapperStyle: any;
                                  bottomContainerStyle: any;
                                  tickStyle: any;
                                  usernameStyle: any;
                                  containerToNextStyle: any;
                                  containerToPreviousStyle: any;
                                  };

                                    method render

                                    render: () => any;

                                      method renderBubbleContent

                                      renderBubbleContent: () => any;

                                        method renderCustomView

                                        renderCustomView: () => {} | null | undefined;

                                          method renderMessageAudio

                                          renderMessageAudio: () => {} | null | undefined;

                                            method renderMessageImage

                                            renderMessageImage: () => {} | null | undefined;

                                              method renderMessageText

                                              renderMessageText: () => {} | null | undefined;

                                                method renderMessageVideo

                                                renderMessageVideo: () => {} | null | undefined;

                                                  method renderQuickReplies

                                                  renderQuickReplies: () => {} | null | undefined;

                                                    method renderTicks

                                                    renderTicks: () => {} | null | undefined;

                                                      method renderTime

                                                      renderTime: () => {} | null | undefined;

                                                        method renderUsername

                                                        renderUsername: () => JSX.Element | null;

                                                          method styledBubbleToNext

                                                          styledBubbleToNext: () =>
                                                          | (
                                                          | false
                                                          | ViewStyle
                                                          | import('react-native').RegisteredStyle<ViewStyle>
                                                          | import('react-native').RecursiveArray<
                                                          | false
                                                          | ViewStyle
                                                          | import('react-native').RegisteredStyle<ViewStyle>
                                                          | null
                                                          | undefined
                                                          >
                                                          | { borderBottomLeftRadius: number }
                                                          | { borderBottomRightRadius: number }
                                                          | null
                                                          | undefined
                                                          )[]
                                                          | null;

                                                            method styledBubbleToPrevious

                                                            styledBubbleToPrevious: () =>
                                                            | (
                                                            | false
                                                            | ViewStyle
                                                            | import('react-native').RegisteredStyle<ViewStyle>
                                                            | import('react-native').RecursiveArray<
                                                            | false
                                                            | ViewStyle
                                                            | import('react-native').RegisteredStyle<ViewStyle>
                                                            | null
                                                            | undefined
                                                            >
                                                            | { borderTopLeftRadius: number }
                                                            | { borderTopRightRadius: number }
                                                            | null
                                                            | undefined
                                                            )[]
                                                            | null;

                                                              class Composer

                                                              class Composer extends React.Component<ComposerProps> {}

                                                                property contentSize

                                                                contentSize?: { width: number; height: number };

                                                                  property defaultProps

                                                                  static defaultProps: {
                                                                  composerHeight: number | undefined;
                                                                  text: string;
                                                                  placeholderTextColor: string;
                                                                  placeholder: string;
                                                                  textInputProps: null;
                                                                  multiline: boolean;
                                                                  disableComposer: boolean;
                                                                  textInputStyle: {};
                                                                  textInputAutoFocus: boolean;
                                                                  keyboardAppearance: string;
                                                                  onTextChanged: () => void;
                                                                  onInputSizeChanged: () => void;
                                                                  };

                                                                    property onChangeText

                                                                    onChangeText: (text: string) => void;

                                                                      property onContentSizeChange

                                                                      onContentSizeChange: (e: any) => void;

                                                                        property propTypes

                                                                        static propTypes: {
                                                                        composerHeight: any;
                                                                        text: any;
                                                                        placeholder: any;
                                                                        placeholderTextColor: any;
                                                                        textInputProps: any;
                                                                        onTextChanged: any;
                                                                        onInputSizeChanged: any;
                                                                        multiline: any;
                                                                        disableComposer: any;
                                                                        textInputStyle: any;
                                                                        textInputAutoFocus: any;
                                                                        keyboardAppearance: any;
                                                                        };

                                                                          method render

                                                                          render: () => any;

                                                                            class Day

                                                                            class Day<TMessage extends IMessage = IMessage> extends PureComponent<
                                                                            DayProps<TMessage>
                                                                            > {}

                                                                              property contextTypes

                                                                              static contextTypes: { getLocale: any };

                                                                                property defaultProps

                                                                                static defaultProps: {
                                                                                currentMessage: { createdAt: null };
                                                                                previousMessage: {};
                                                                                nextMessage: {};
                                                                                containerStyle: {};
                                                                                wrapperStyle: {};
                                                                                textStyle: {};
                                                                                dateFormat: string;
                                                                                };

                                                                                  property propTypes

                                                                                  static propTypes: {
                                                                                  currentMessage: any;
                                                                                  previousMessage: any;
                                                                                  nextMessage: any;
                                                                                  inverted: any;
                                                                                  containerStyle: any;
                                                                                  wrapperStyle: any;
                                                                                  textStyle: any;
                                                                                  dateFormat: any;
                                                                                  };

                                                                                    method render

                                                                                    render: () => JSX.Element | null;

                                                                                      class GiftedAvatar

                                                                                      class GiftedAvatar extends React.Component<GiftedAvatarProps> {}

                                                                                        property avatarColor

                                                                                        avatarColor?: string;

                                                                                          property avatarName

                                                                                          avatarName?: string;

                                                                                            property defaultProps

                                                                                            static defaultProps: {
                                                                                            user: { name: null; avatar: null };
                                                                                            onPress: undefined;
                                                                                            onLongPress: undefined;
                                                                                            avatarStyle: {};
                                                                                            textStyle: {};
                                                                                            };

                                                                                              property handleOnLongPress

                                                                                              handleOnLongPress: () => void;

                                                                                                property handleOnPress

                                                                                                handleOnPress: () => void;

                                                                                                  property propTypes

                                                                                                  static propTypes: {
                                                                                                  user: any;
                                                                                                  onPress: any;
                                                                                                  onLongPress: any;
                                                                                                  avatarStyle: any;
                                                                                                  textStyle: any;
                                                                                                  };

                                                                                                    method render

                                                                                                    render: () => any;

                                                                                                      method renderAvatar

                                                                                                      renderAvatar: () => JSX.Element | null;

                                                                                                        method renderInitials

                                                                                                        renderInitials: () => any;

                                                                                                          method setAvatarColor

                                                                                                          setAvatarColor: () => void;

                                                                                                            class GiftedChat

                                                                                                            class GiftedChat<TMessage extends IMessage = IMessage> extends React.Component<
                                                                                                            GiftedChatProps<TMessage>,
                                                                                                            GiftedChatState
                                                                                                            > {}

                                                                                                              constructor

                                                                                                              constructor(props: GiftedChatProps<TMessage>);

                                                                                                                property childContextTypes

                                                                                                                static childContextTypes: { actionSheet: any; getLocale: any };

                                                                                                                  property defaultProps

                                                                                                                  static defaultProps: {
                                                                                                                  messages: never[];
                                                                                                                  messagesContainerStyle: undefined;
                                                                                                                  text: undefined;
                                                                                                                  placeholder: string;
                                                                                                                  disableComposer: boolean;
                                                                                                                  messageIdGenerator: () => string;
                                                                                                                  user: {};
                                                                                                                  onSend: () => void;
                                                                                                                  locale: null;
                                                                                                                  timeFormat: string;
                                                                                                                  dateFormat: string;
                                                                                                                  loadEarlier: boolean;
                                                                                                                  onLoadEarlier: () => void;
                                                                                                                  isLoadingEarlier: boolean;
                                                                                                                  renderLoading: null;
                                                                                                                  renderLoadEarlier: null;
                                                                                                                  renderAvatar: undefined;
                                                                                                                  showUserAvatar: boolean;
                                                                                                                  actionSheet: null;
                                                                                                                  onPressAvatar: null;
                                                                                                                  onLongPressAvatar: null;
                                                                                                                  renderUsernameOnMessage: boolean;
                                                                                                                  renderAvatarOnTop: boolean;
                                                                                                                  renderBubble: null;
                                                                                                                  renderSystemMessage: null;
                                                                                                                  onLongPress: null;
                                                                                                                  renderMessage: null;
                                                                                                                  renderMessageText: null;
                                                                                                                  renderMessageImage: null;
                                                                                                                  imageProps: {};
                                                                                                                  videoProps: {};
                                                                                                                  audioProps: {};
                                                                                                                  lightboxProps: {};
                                                                                                                  textInputProps: {};
                                                                                                                  listViewProps: {};
                                                                                                                  renderCustomView: null;
                                                                                                                  isCustomViewBottom: boolean;
                                                                                                                  renderDay: null;
                                                                                                                  renderTime: null;
                                                                                                                  renderFooter: null;
                                                                                                                  renderChatEmpty: null;
                                                                                                                  renderChatFooter: null;
                                                                                                                  renderInputToolbar: null;
                                                                                                                  renderComposer: null;
                                                                                                                  renderActions: null;
                                                                                                                  renderSend: null;
                                                                                                                  renderAccessory: null;
                                                                                                                  isKeyboardInternallyHandled: boolean;
                                                                                                                  onPressActionButton: null;
                                                                                                                  bottomOffset: number;
                                                                                                                  minInputToolbarHeight: number;
                                                                                                                  keyboardShouldPersistTaps: string;
                                                                                                                  onInputTextChanged: null;
                                                                                                                  maxInputLength: null;
                                                                                                                  forceGetKeyboardHeight: boolean;
                                                                                                                  inverted: boolean;
                                                                                                                  extraData: null;
                                                                                                                  minComposerHeight: number | undefined;
                                                                                                                  maxComposerHeight: number;
                                                                                                                  wrapInSafeArea: boolean;
                                                                                                                  };

                                                                                                                    property getLocale

                                                                                                                    getLocale: () => string;

                                                                                                                      property invertibleScrollViewProps

                                                                                                                      invertibleScrollViewProps: any;

                                                                                                                        property onInitialLayoutViewLayout

                                                                                                                        onInitialLayoutViewLayout: (e: any) => void;

                                                                                                                          property onInputSizeChanged

                                                                                                                          onInputSizeChanged: (size: { height: number }) => void;

                                                                                                                            property onInputTextChanged

                                                                                                                            onInputTextChanged: (text: string) => void;

                                                                                                                              property onKeyboardDidHide

                                                                                                                              onKeyboardDidHide: (e: any) => void;

                                                                                                                                property onKeyboardDidShow

                                                                                                                                onKeyboardDidShow: (e: any) => void;

                                                                                                                                  property onKeyboardWillHide

                                                                                                                                  onKeyboardWillHide: (_e: any) => void;

                                                                                                                                    property onKeyboardWillShow

                                                                                                                                    onKeyboardWillShow: (e: any) => void;

                                                                                                                                      property onMainViewLayout

                                                                                                                                      onMainViewLayout: (e: any) => void;

                                                                                                                                        property onSend

                                                                                                                                        onSend: (messages?: TMessage[], shouldResetInputToolbar?: boolean) => void;

                                                                                                                                          property propTypes

                                                                                                                                          static propTypes: {
                                                                                                                                          messages: any;
                                                                                                                                          messagesContainerStyle: any;
                                                                                                                                          text: any;
                                                                                                                                          initialText: any;
                                                                                                                                          placeholder: any;
                                                                                                                                          disableComposer: any;
                                                                                                                                          messageIdGenerator: any;
                                                                                                                                          user: any;
                                                                                                                                          onSend: any;
                                                                                                                                          locale: any;
                                                                                                                                          timeFormat: any;
                                                                                                                                          dateFormat: any;
                                                                                                                                          isKeyboardInternallyHandled: any;
                                                                                                                                          loadEarlier: any;
                                                                                                                                          onLoadEarlier: any;
                                                                                                                                          isLoadingEarlier: any;
                                                                                                                                          renderLoading: any;
                                                                                                                                          renderLoadEarlier: any;
                                                                                                                                          renderAvatar: any;
                                                                                                                                          showUserAvatar: any;
                                                                                                                                          actionSheet: any;
                                                                                                                                          onPressAvatar: any;
                                                                                                                                          onLongPressAvatar: any;
                                                                                                                                          renderUsernameOnMessage: any;
                                                                                                                                          renderAvatarOnTop: any;
                                                                                                                                          isCustomViewBottom: any;
                                                                                                                                          renderBubble: any;
                                                                                                                                          renderSystemMessage: any;
                                                                                                                                          onLongPress: any;
                                                                                                                                          renderMessage: any;
                                                                                                                                          renderMessageText: any;
                                                                                                                                          renderMessageImage: any;
                                                                                                                                          imageProps: any;
                                                                                                                                          videoProps: any;
                                                                                                                                          audioProps: any;
                                                                                                                                          lightboxProps: any;
                                                                                                                                          renderCustomView: any;
                                                                                                                                          renderDay: any;
                                                                                                                                          renderTime: any;
                                                                                                                                          renderFooter: any;
                                                                                                                                          renderChatEmpty: any;
                                                                                                                                          renderChatFooter: any;
                                                                                                                                          renderInputToolbar: any;
                                                                                                                                          renderComposer: any;
                                                                                                                                          renderActions: any;
                                                                                                                                          renderSend: any;
                                                                                                                                          renderAccessory: any;
                                                                                                                                          onPressActionButton: any;
                                                                                                                                          bottomOffset: any;
                                                                                                                                          minInputToolbarHeight: any;
                                                                                                                                          listViewProps: any;
                                                                                                                                          keyboardShouldPersistTaps: any;
                                                                                                                                          onInputTextChanged: any;
                                                                                                                                          maxInputLength: any;
                                                                                                                                          forceGetKeyboardHeight: any;
                                                                                                                                          inverted: any;
                                                                                                                                          textInputProps: any;
                                                                                                                                          extraData: any;
                                                                                                                                          minComposerHeight: any;
                                                                                                                                          maxComposerHeight: any;
                                                                                                                                          alignTop: any;
                                                                                                                                          wrapInSafeArea: any;
                                                                                                                                          };

                                                                                                                                            property safeAreaSupport

                                                                                                                                            safeAreaSupport: (bottomOffset: number) => number;

                                                                                                                                              property state

                                                                                                                                              state: {
                                                                                                                                              isInitialized: boolean;
                                                                                                                                              composerHeight: number | undefined;
                                                                                                                                              messagesContainerHeight: undefined;
                                                                                                                                              typingDisabled: boolean;
                                                                                                                                              text: undefined;
                                                                                                                                              messages: undefined;
                                                                                                                                              };

                                                                                                                                                property textInput

                                                                                                                                                textInput?: any;

                                                                                                                                                  method append

                                                                                                                                                  static append: <TMessage extends IMessage>(
                                                                                                                                                  currentMessages: TMessage[] | undefined,
                                                                                                                                                  messages: TMessage[],
                                                                                                                                                  inverted?: boolean
                                                                                                                                                  ) => TMessage[];

                                                                                                                                                    method calculateInputToolbarHeight

                                                                                                                                                    calculateInputToolbarHeight: (composerHeight: number) => number;

                                                                                                                                                      method componentDidMount

                                                                                                                                                      componentDidMount: () => void;

                                                                                                                                                        method componentDidUpdate

                                                                                                                                                        componentDidUpdate: (prevProps?: GiftedChatProps<TMessage>) => void;

                                                                                                                                                          method componentWillUnmount

                                                                                                                                                          componentWillUnmount: () => void;

                                                                                                                                                            method focusTextInput

                                                                                                                                                            focusTextInput: () => void;

                                                                                                                                                              method getBasicMessagesContainerHeight

                                                                                                                                                              getBasicMessagesContainerHeight: (composerHeight?: number | undefined) => number;
                                                                                                                                                              • Returns the height, based on current window size, without taking the keyboard into account.

                                                                                                                                                              method getBottomOffset

                                                                                                                                                              getBottomOffset: () => number;

                                                                                                                                                                method getChildContext

                                                                                                                                                                getChildContext: () => { actionSheet: () => any; getLocale: () => string };

                                                                                                                                                                  method getIsFirstLayout

                                                                                                                                                                  getIsFirstLayout: () => boolean;

                                                                                                                                                                    method getIsMounted

                                                                                                                                                                    getIsMounted: () => boolean;

                                                                                                                                                                      method getIsTypingDisabled

                                                                                                                                                                      getIsTypingDisabled: () => boolean;

                                                                                                                                                                        method getKeyboardHeight

                                                                                                                                                                        getKeyboardHeight: () => number;

                                                                                                                                                                          method getMaxHeight

                                                                                                                                                                          getMaxHeight: () => number | undefined;

                                                                                                                                                                            method getMessages

                                                                                                                                                                            getMessages: () => undefined;

                                                                                                                                                                              method getMessagesContainerHeightWithKeyboard

                                                                                                                                                                              getMessagesContainerHeightWithKeyboard: (
                                                                                                                                                                              composerHeight?: number | undefined
                                                                                                                                                                              ) => number;
                                                                                                                                                                              • Returns the height, based on current window size, taking the keyboard into account.

                                                                                                                                                                              method getMinInputToolbarHeight

                                                                                                                                                                              getMinInputToolbarHeight: () => number | undefined;

                                                                                                                                                                                method getTextFromProp

                                                                                                                                                                                getTextFromProp: (fallback: string) => string;

                                                                                                                                                                                  method initLocale

                                                                                                                                                                                  initLocale: () => void;

                                                                                                                                                                                    method notifyInputTextReset

                                                                                                                                                                                    notifyInputTextReset: () => void;

                                                                                                                                                                                      method prepend

                                                                                                                                                                                      static prepend: <TMessage extends IMessage>(
                                                                                                                                                                                      currentMessages: TMessage[] | undefined,
                                                                                                                                                                                      messages: TMessage[],
                                                                                                                                                                                      inverted?: boolean
                                                                                                                                                                                      ) => TMessage[];

                                                                                                                                                                                        method render

                                                                                                                                                                                        render: () => any;

                                                                                                                                                                                          method renderChatFooter

                                                                                                                                                                                          renderChatFooter: () => {} | null | undefined;

                                                                                                                                                                                            method renderInputToolbar

                                                                                                                                                                                            renderInputToolbar: () => {} | null | undefined;

                                                                                                                                                                                              method renderLoading

                                                                                                                                                                                              renderLoading: () => {} | null | undefined;

                                                                                                                                                                                                method renderMessages

                                                                                                                                                                                                renderMessages: () => any;

                                                                                                                                                                                                  method resetInputToolbar

                                                                                                                                                                                                  resetInputToolbar: () => void;

                                                                                                                                                                                                    method scrollToBottom

                                                                                                                                                                                                    scrollToBottom: (animated?: boolean) => void;

                                                                                                                                                                                                      method setBottomOffset

                                                                                                                                                                                                      setBottomOffset: (value: number) => void;

                                                                                                                                                                                                        method setIsFirstLayout

                                                                                                                                                                                                        setIsFirstLayout: (value: boolean) => void;

                                                                                                                                                                                                          method setIsMounted

                                                                                                                                                                                                          setIsMounted: (value: boolean) => void;

                                                                                                                                                                                                            method setIsTypingDisabled

                                                                                                                                                                                                            setIsTypingDisabled: (value: boolean) => void;

                                                                                                                                                                                                              method setKeyboardHeight

                                                                                                                                                                                                              setKeyboardHeight: (height: number) => void;

                                                                                                                                                                                                                method setLocale

                                                                                                                                                                                                                setLocale: (locale: string) => void;

                                                                                                                                                                                                                  method setMaxHeight

                                                                                                                                                                                                                  setMaxHeight: (height: number) => void;

                                                                                                                                                                                                                    method setMessages

                                                                                                                                                                                                                    setMessages: (messages: TMessage[]) => void;

                                                                                                                                                                                                                      method setTextFromProp

                                                                                                                                                                                                                      setTextFromProp: (textProp?: string) => void;

                                                                                                                                                                                                                        class InputToolbar

                                                                                                                                                                                                                        class InputToolbar extends React.Component<
                                                                                                                                                                                                                        InputToolbarProps,
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                        position: string;
                                                                                                                                                                                                                        }
                                                                                                                                                                                                                        > {}

                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                          static defaultProps: {
                                                                                                                                                                                                                          renderAccessory: null;
                                                                                                                                                                                                                          renderActions: null;
                                                                                                                                                                                                                          renderSend: null;
                                                                                                                                                                                                                          renderComposer: null;
                                                                                                                                                                                                                          containerStyle: {};
                                                                                                                                                                                                                          primaryStyle: {};
                                                                                                                                                                                                                          accessoryStyle: {};
                                                                                                                                                                                                                          onPressActionButton: () => void;
                                                                                                                                                                                                                          };

                                                                                                                                                                                                                            property keyboardWillHide

                                                                                                                                                                                                                            keyboardWillHide: () => void;

                                                                                                                                                                                                                              property keyboardWillHideListener

                                                                                                                                                                                                                              keyboardWillHideListener?: any;

                                                                                                                                                                                                                                property keyboardWillShow

                                                                                                                                                                                                                                keyboardWillShow: () => void;

                                                                                                                                                                                                                                  property keyboardWillShowListener

                                                                                                                                                                                                                                  keyboardWillShowListener?: any;

                                                                                                                                                                                                                                    property propTypes

                                                                                                                                                                                                                                    static propTypes: {
                                                                                                                                                                                                                                    renderAccessory: any;
                                                                                                                                                                                                                                    renderActions: any;
                                                                                                                                                                                                                                    renderSend: any;
                                                                                                                                                                                                                                    renderComposer: any;
                                                                                                                                                                                                                                    onPressActionButton: any;
                                                                                                                                                                                                                                    containerStyle: any;
                                                                                                                                                                                                                                    primaryStyle: any;
                                                                                                                                                                                                                                    accessoryStyle: any;
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      property state

                                                                                                                                                                                                                                      state: { position: string };

                                                                                                                                                                                                                                        method componentDidMount

                                                                                                                                                                                                                                        componentDidMount: () => void;

                                                                                                                                                                                                                                          method componentWillUnmount

                                                                                                                                                                                                                                          componentWillUnmount: () => void;

                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                                              method renderAccessory

                                                                                                                                                                                                                                              renderAccessory: () => JSX.Element | null;

                                                                                                                                                                                                                                                method renderActions

                                                                                                                                                                                                                                                renderActions: () => {} | null | undefined;

                                                                                                                                                                                                                                                  method renderComposer

                                                                                                                                                                                                                                                  renderComposer: () => {} | null | undefined;

                                                                                                                                                                                                                                                    method renderSend

                                                                                                                                                                                                                                                    renderSend: () => {} | null | undefined;

                                                                                                                                                                                                                                                      class LoadEarlier

                                                                                                                                                                                                                                                      class LoadEarlier extends React.Component<LoadEarlierProps> {}

                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                        static defaultProps: {
                                                                                                                                                                                                                                                        onLoadEarlier: () => void;
                                                                                                                                                                                                                                                        isLoadingEarlier: boolean;
                                                                                                                                                                                                                                                        label: string;
                                                                                                                                                                                                                                                        containerStyle: {};
                                                                                                                                                                                                                                                        wrapperStyle: {};
                                                                                                                                                                                                                                                        textStyle: {};
                                                                                                                                                                                                                                                        activityIndicatorStyle: {};
                                                                                                                                                                                                                                                        activityIndicatorColor: string;
                                                                                                                                                                                                                                                        activityIndicatorSize: string;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          property propTypes

                                                                                                                                                                                                                                                          static propTypes: {
                                                                                                                                                                                                                                                          onLoadEarlier: any;
                                                                                                                                                                                                                                                          isLoadingEarlier: any;
                                                                                                                                                                                                                                                          label: any;
                                                                                                                                                                                                                                                          containerStyle: any;
                                                                                                                                                                                                                                                          wrapperStyle: any;
                                                                                                                                                                                                                                                          textStyle: any;
                                                                                                                                                                                                                                                          activityIndicatorStyle: any;
                                                                                                                                                                                                                                                          activityIndicatorColor: any;
                                                                                                                                                                                                                                                          activityIndicatorSize: any;
                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                                                              method renderLoading

                                                                                                                                                                                                                                                              renderLoading: () => any;

                                                                                                                                                                                                                                                                class Message

                                                                                                                                                                                                                                                                class Message<TMessage extends IMessage = IMessage> extends React.Component<
                                                                                                                                                                                                                                                                MessageProps<TMessage>
                                                                                                                                                                                                                                                                > {}

                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                  static defaultProps: {
                                                                                                                                                                                                                                                                  renderAvatar: undefined;
                                                                                                                                                                                                                                                                  renderBubble: null;
                                                                                                                                                                                                                                                                  renderDay: null;
                                                                                                                                                                                                                                                                  renderSystemMessage: null;
                                                                                                                                                                                                                                                                  position: string;
                                                                                                                                                                                                                                                                  currentMessage: {};
                                                                                                                                                                                                                                                                  nextMessage: {};
                                                                                                                                                                                                                                                                  previousMessage: {};
                                                                                                                                                                                                                                                                  user: {};
                                                                                                                                                                                                                                                                  containerStyle: {};
                                                                                                                                                                                                                                                                  showUserAvatar: boolean;
                                                                                                                                                                                                                                                                  inverted: boolean;
                                                                                                                                                                                                                                                                  shouldUpdateMessage: undefined;
                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                    property propTypes

                                                                                                                                                                                                                                                                    static propTypes: {
                                                                                                                                                                                                                                                                    renderAvatar: any;
                                                                                                                                                                                                                                                                    showUserAvatar: any;
                                                                                                                                                                                                                                                                    renderBubble: any;
                                                                                                                                                                                                                                                                    renderDay: any;
                                                                                                                                                                                                                                                                    renderSystemMessage: any;
                                                                                                                                                                                                                                                                    position: any;
                                                                                                                                                                                                                                                                    currentMessage: any;
                                                                                                                                                                                                                                                                    nextMessage: any;
                                                                                                                                                                                                                                                                    previousMessage: any;
                                                                                                                                                                                                                                                                    user: any;
                                                                                                                                                                                                                                                                    inverted: any;
                                                                                                                                                                                                                                                                    containerStyle: any;
                                                                                                                                                                                                                                                                    shouldUpdateMessage: any;
                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                      render: () => JSX.Element | null;

                                                                                                                                                                                                                                                                        method renderAvatar

                                                                                                                                                                                                                                                                        renderAvatar: () => JSX.Element | null;

                                                                                                                                                                                                                                                                          method renderBubble

                                                                                                                                                                                                                                                                          renderBubble: () => {} | null | undefined;

                                                                                                                                                                                                                                                                            method renderDay

                                                                                                                                                                                                                                                                            renderDay: () => {} | null | undefined;

                                                                                                                                                                                                                                                                              method renderSystemMessage

                                                                                                                                                                                                                                                                              renderSystemMessage: () => {} | null | undefined;

                                                                                                                                                                                                                                                                                method shouldComponentUpdate

                                                                                                                                                                                                                                                                                shouldComponentUpdate: (nextProps: MessageProps<TMessage>) => boolean;

                                                                                                                                                                                                                                                                                  class MessageContainer

                                                                                                                                                                                                                                                                                  class MessageContainer<
                                                                                                                                                                                                                                                                                  TMessage extends IMessage = IMessage
                                                                                                                                                                                                                                                                                  > extends React.PureComponent<MessageContainerProps<TMessage>, State> {}

                                                                                                                                                                                                                                                                                    property attachKeyboardListeners

                                                                                                                                                                                                                                                                                    attachKeyboardListeners: () => void;

                                                                                                                                                                                                                                                                                      property defaultProps

                                                                                                                                                                                                                                                                                      static defaultProps: {
                                                                                                                                                                                                                                                                                      messages: never[];
                                                                                                                                                                                                                                                                                      user: {};
                                                                                                                                                                                                                                                                                      isTyping: boolean;
                                                                                                                                                                                                                                                                                      renderChatEmpty: null;
                                                                                                                                                                                                                                                                                      renderFooter: null;
                                                                                                                                                                                                                                                                                      renderMessage: null;
                                                                                                                                                                                                                                                                                      onLoadEarlier: () => void;
                                                                                                                                                                                                                                                                                      onQuickReply: () => void;
                                                                                                                                                                                                                                                                                      inverted: boolean;
                                                                                                                                                                                                                                                                                      loadEarlier: boolean;
                                                                                                                                                                                                                                                                                      listViewProps: {};
                                                                                                                                                                                                                                                                                      invertibleScrollViewProps: {};
                                                                                                                                                                                                                                                                                      extraData: null;
                                                                                                                                                                                                                                                                                      scrollToBottom: boolean;
                                                                                                                                                                                                                                                                                      scrollToBottomOffset: number;
                                                                                                                                                                                                                                                                                      alignTop: boolean;
                                                                                                                                                                                                                                                                                      scrollToBottomStyle: {};
                                                                                                                                                                                                                                                                                      infiniteScroll: boolean;
                                                                                                                                                                                                                                                                                      isLoadingEarlier: boolean;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                        property detachKeyboardListeners

                                                                                                                                                                                                                                                                                        detachKeyboardListeners: () => void;

                                                                                                                                                                                                                                                                                          property handleOnScroll

                                                                                                                                                                                                                                                                                          handleOnScroll: (event: any) => void;

                                                                                                                                                                                                                                                                                            property keyExtractor

                                                                                                                                                                                                                                                                                            keyExtractor: (item: TMessage) => string;

                                                                                                                                                                                                                                                                                              property onEndReached

                                                                                                                                                                                                                                                                                              onEndReached: ({ distanceFromEnd }: { distanceFromEnd: number }) => void;

                                                                                                                                                                                                                                                                                                property onLayoutList

                                                                                                                                                                                                                                                                                                onLayoutList: () => void;

                                                                                                                                                                                                                                                                                                  property propTypes

                                                                                                                                                                                                                                                                                                  static propTypes: {
                                                                                                                                                                                                                                                                                                  messages: any;
                                                                                                                                                                                                                                                                                                  isTyping: any;
                                                                                                                                                                                                                                                                                                  user: any;
                                                                                                                                                                                                                                                                                                  renderChatEmpty: any;
                                                                                                                                                                                                                                                                                                  renderFooter: any;
                                                                                                                                                                                                                                                                                                  renderMessage: any;
                                                                                                                                                                                                                                                                                                  renderLoadEarlier: any;
                                                                                                                                                                                                                                                                                                  onLoadEarlier: any;
                                                                                                                                                                                                                                                                                                  listViewProps: any;
                                                                                                                                                                                                                                                                                                  inverted: any;
                                                                                                                                                                                                                                                                                                  loadEarlier: any;
                                                                                                                                                                                                                                                                                                  invertibleScrollViewProps: any;
                                                                                                                                                                                                                                                                                                  extraData: any;
                                                                                                                                                                                                                                                                                                  scrollToBottom: any;
                                                                                                                                                                                                                                                                                                  scrollToBottomOffset: any;
                                                                                                                                                                                                                                                                                                  scrollToBottomComponent: any;
                                                                                                                                                                                                                                                                                                  alignTop: any;
                                                                                                                                                                                                                                                                                                  scrollToBottomStyle: any;
                                                                                                                                                                                                                                                                                                  infiniteScroll: any;
                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                    property renderChatEmpty

                                                                                                                                                                                                                                                                                                    renderChatEmpty: () => {} | null | undefined;

                                                                                                                                                                                                                                                                                                      property renderFooter

                                                                                                                                                                                                                                                                                                      renderFooter: () => {} | null | undefined;

                                                                                                                                                                                                                                                                                                        property renderHeaderWrapper

                                                                                                                                                                                                                                                                                                        renderHeaderWrapper: () => any;

                                                                                                                                                                                                                                                                                                          property renderLoadEarlier

                                                                                                                                                                                                                                                                                                          renderLoadEarlier: () => {} | null | undefined;

                                                                                                                                                                                                                                                                                                            property renderRow

                                                                                                                                                                                                                                                                                                            renderRow: ({ item, index }: any) => {} | null | undefined;

                                                                                                                                                                                                                                                                                                              property renderTypingIndicator

                                                                                                                                                                                                                                                                                                              renderTypingIndicator: () => JSX.Element | null;

                                                                                                                                                                                                                                                                                                                property scrollToBottom

                                                                                                                                                                                                                                                                                                                scrollToBottom: (animated?: boolean) => void;

                                                                                                                                                                                                                                                                                                                  property state

                                                                                                                                                                                                                                                                                                                  state: { showScrollBottom: boolean };

                                                                                                                                                                                                                                                                                                                    method componentDidMount

                                                                                                                                                                                                                                                                                                                    componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                      method componentDidUpdate

                                                                                                                                                                                                                                                                                                                      componentDidUpdate: (prevProps: MessageContainerProps<TMessage>) => void;

                                                                                                                                                                                                                                                                                                                        method componentWillUnmount

                                                                                                                                                                                                                                                                                                                        componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                          render: () => any;

                                                                                                                                                                                                                                                                                                                            method renderScrollBottomComponent

                                                                                                                                                                                                                                                                                                                            renderScrollBottomComponent: () => {} | null | undefined;

                                                                                                                                                                                                                                                                                                                              method renderScrollToBottomWrapper

                                                                                                                                                                                                                                                                                                                              renderScrollToBottomWrapper: () => any;

                                                                                                                                                                                                                                                                                                                                method scrollTo

                                                                                                                                                                                                                                                                                                                                scrollTo: (options: { animated?: boolean; offset: number }) => void;

                                                                                                                                                                                                                                                                                                                                  class MessageImage

                                                                                                                                                                                                                                                                                                                                  class MessageImage<TMessage extends IMessage = IMessage> extends Component<
                                                                                                                                                                                                                                                                                                                                  MessageImageProps<TMessage>
                                                                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                                                                    property defaultProps

                                                                                                                                                                                                                                                                                                                                    static defaultProps: {
                                                                                                                                                                                                                                                                                                                                    currentMessage: { image: null };
                                                                                                                                                                                                                                                                                                                                    containerStyle: {};
                                                                                                                                                                                                                                                                                                                                    imageStyle: {};
                                                                                                                                                                                                                                                                                                                                    imageProps: {};
                                                                                                                                                                                                                                                                                                                                    lightboxProps: {};
                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                      property propTypes

                                                                                                                                                                                                                                                                                                                                      static propTypes: {
                                                                                                                                                                                                                                                                                                                                      currentMessage: any;
                                                                                                                                                                                                                                                                                                                                      containerStyle: any;
                                                                                                                                                                                                                                                                                                                                      imageStyle: any;
                                                                                                                                                                                                                                                                                                                                      imageProps: any;
                                                                                                                                                                                                                                                                                                                                      lightboxProps: any;
                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                        render: () => JSX.Element | null;

                                                                                                                                                                                                                                                                                                                                          class MessageText

                                                                                                                                                                                                                                                                                                                                          class MessageText<TMessage extends IMessage = IMessage> extends React.Component<
                                                                                                                                                                                                                                                                                                                                          MessageTextProps<TMessage>
                                                                                                                                                                                                                                                                                                                                          > {}

                                                                                                                                                                                                                                                                                                                                            property contextTypes

                                                                                                                                                                                                                                                                                                                                            static contextTypes: { actionSheet: any };

                                                                                                                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                                                                                                                              static defaultProps: {
                                                                                                                                                                                                                                                                                                                                              position: string;
                                                                                                                                                                                                                                                                                                                                              optionTitles: string[];
                                                                                                                                                                                                                                                                                                                                              currentMessage: { text: string };
                                                                                                                                                                                                                                                                                                                                              containerStyle: {};
                                                                                                                                                                                                                                                                                                                                              textStyle: {};
                                                                                                                                                                                                                                                                                                                                              linkStyle: {};
                                                                                                                                                                                                                                                                                                                                              customTextStyle: {};
                                                                                                                                                                                                                                                                                                                                              textProps: {};
                                                                                                                                                                                                                                                                                                                                              parsePatterns: () => never[];
                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                property onEmailPress

                                                                                                                                                                                                                                                                                                                                                onEmailPress: (email: string) => void;

                                                                                                                                                                                                                                                                                                                                                  property onPhonePress

                                                                                                                                                                                                                                                                                                                                                  onPhonePress: (phone: string) => void;

                                                                                                                                                                                                                                                                                                                                                    property onUrlPress

                                                                                                                                                                                                                                                                                                                                                    onUrlPress: (url: string) => void;

                                                                                                                                                                                                                                                                                                                                                      property propTypes

                                                                                                                                                                                                                                                                                                                                                      static propTypes: {
                                                                                                                                                                                                                                                                                                                                                      position: any;
                                                                                                                                                                                                                                                                                                                                                      optionTitles: any;
                                                                                                                                                                                                                                                                                                                                                      currentMessage: any;
                                                                                                                                                                                                                                                                                                                                                      containerStyle: any;
                                                                                                                                                                                                                                                                                                                                                      textStyle: any;
                                                                                                                                                                                                                                                                                                                                                      linkStyle: any;
                                                                                                                                                                                                                                                                                                                                                      parsePatterns: any;
                                                                                                                                                                                                                                                                                                                                                      textProps: any;
                                                                                                                                                                                                                                                                                                                                                      customTextStyle: any;
                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                        render: () => any;

                                                                                                                                                                                                                                                                                                                                                          method shouldComponentUpdate

                                                                                                                                                                                                                                                                                                                                                          shouldComponentUpdate: (nextProps: MessageTextProps<TMessage>) => boolean;

                                                                                                                                                                                                                                                                                                                                                            class Send

                                                                                                                                                                                                                                                                                                                                                            class Send<TMessage extends IMessage = IMessage> extends Component<
                                                                                                                                                                                                                                                                                                                                                            SendProps<TMessage>
                                                                                                                                                                                                                                                                                                                                                            > {}

                                                                                                                                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                                                                                                                                              static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                              text: string;
                                                                                                                                                                                                                                                                                                                                                              onSend: () => void;
                                                                                                                                                                                                                                                                                                                                                              label: string;
                                                                                                                                                                                                                                                                                                                                                              containerStyle: {};
                                                                                                                                                                                                                                                                                                                                                              textStyle: {};
                                                                                                                                                                                                                                                                                                                                                              children: null;
                                                                                                                                                                                                                                                                                                                                                              alwaysShowSend: boolean;
                                                                                                                                                                                                                                                                                                                                                              disabled: boolean;
                                                                                                                                                                                                                                                                                                                                                              sendButtonProps: null;
                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                property handleOnPress

                                                                                                                                                                                                                                                                                                                                                                handleOnPress: () => void;

                                                                                                                                                                                                                                                                                                                                                                  property propTypes

                                                                                                                                                                                                                                                                                                                                                                  static propTypes: {
                                                                                                                                                                                                                                                                                                                                                                  text: any;
                                                                                                                                                                                                                                                                                                                                                                  onSend: any;
                                                                                                                                                                                                                                                                                                                                                                  label: any;
                                                                                                                                                                                                                                                                                                                                                                  containerStyle: any;
                                                                                                                                                                                                                                                                                                                                                                  textStyle: any;
                                                                                                                                                                                                                                                                                                                                                                  children: any;
                                                                                                                                                                                                                                                                                                                                                                  alwaysShowSend: any;
                                                                                                                                                                                                                                                                                                                                                                  disabled: any;
                                                                                                                                                                                                                                                                                                                                                                  sendButtonProps: any;
                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                                                                      class SystemMessage

                                                                                                                                                                                                                                                                                                                                                                      class SystemMessage<TMessage extends IMessage = IMessage> extends Component<
                                                                                                                                                                                                                                                                                                                                                                      SystemMessageProps<TMessage>
                                                                                                                                                                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                        currentMessage: { system: boolean };
                                                                                                                                                                                                                                                                                                                                                                        containerStyle: {};
                                                                                                                                                                                                                                                                                                                                                                        wrapperStyle: {};
                                                                                                                                                                                                                                                                                                                                                                        textStyle: {};
                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                          property propTypes

                                                                                                                                                                                                                                                                                                                                                                          static propTypes: {
                                                                                                                                                                                                                                                                                                                                                                          currentMessage: any;
                                                                                                                                                                                                                                                                                                                                                                          containerStyle: any;
                                                                                                                                                                                                                                                                                                                                                                          wrapperStyle: any;
                                                                                                                                                                                                                                                                                                                                                                          textStyle: any;
                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                            render: () => JSX.Element | null;

                                                                                                                                                                                                                                                                                                                                                                              class Time

                                                                                                                                                                                                                                                                                                                                                                              class Time<TMessage extends IMessage = IMessage> extends Component<
                                                                                                                                                                                                                                                                                                                                                                              TimeProps<TMessage>
                                                                                                                                                                                                                                                                                                                                                                              > {}

                                                                                                                                                                                                                                                                                                                                                                                property contextTypes

                                                                                                                                                                                                                                                                                                                                                                                static contextTypes: { getLocale: any };

                                                                                                                                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                  static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                                  position: string;
                                                                                                                                                                                                                                                                                                                                                                                  currentMessage: { createdAt: null };
                                                                                                                                                                                                                                                                                                                                                                                  containerStyle: {};
                                                                                                                                                                                                                                                                                                                                                                                  timeFormat: string;
                                                                                                                                                                                                                                                                                                                                                                                  timeTextStyle: {};
                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                    property propTypes

                                                                                                                                                                                                                                                                                                                                                                                    static propTypes: {
                                                                                                                                                                                                                                                                                                                                                                                    position: any;
                                                                                                                                                                                                                                                                                                                                                                                    currentMessage: any;
                                                                                                                                                                                                                                                                                                                                                                                    containerStyle: any;
                                                                                                                                                                                                                                                                                                                                                                                    timeFormat: any;
                                                                                                                                                                                                                                                                                                                                                                                    timeTextStyle: any;
                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                      render: () => JSX.Element | null;

                                                                                                                                                                                                                                                                                                                                                                                        Interfaces

                                                                                                                                                                                                                                                                                                                                                                                        interface ActionsProps

                                                                                                                                                                                                                                                                                                                                                                                        interface ActionsProps {}

                                                                                                                                                                                                                                                                                                                                                                                          property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                          containerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                            property icon

                                                                                                                                                                                                                                                                                                                                                                                            icon?: () => ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                              property iconTextStyle

                                                                                                                                                                                                                                                                                                                                                                                              iconTextStyle?: StyleProp<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                                                                                                                                                                options?: {
                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                  property optionTintColor

                                                                                                                                                                                                                                                                                                                                                                                                  optionTintColor?: string;

                                                                                                                                                                                                                                                                                                                                                                                                    property wrapperStyle

                                                                                                                                                                                                                                                                                                                                                                                                    wrapperStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                      method onPressActionButton

                                                                                                                                                                                                                                                                                                                                                                                                      onPressActionButton: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                        interface AvatarProps

                                                                                                                                                                                                                                                                                                                                                                                                        interface AvatarProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                          property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                          containerStyle?: LeftRightStyle<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                            property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                            currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                              property imageStyle

                                                                                                                                                                                                                                                                                                                                                                                                              imageStyle?: LeftRightStyle<ImageStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                property nextMessage

                                                                                                                                                                                                                                                                                                                                                                                                                nextMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                  property position

                                                                                                                                                                                                                                                                                                                                                                                                                  position: 'left' | 'right';

                                                                                                                                                                                                                                                                                                                                                                                                                    property previousMessage

                                                                                                                                                                                                                                                                                                                                                                                                                    previousMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                      property renderAvatarOnTop

                                                                                                                                                                                                                                                                                                                                                                                                                      renderAvatarOnTop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        property showAvatarForEveryMessage

                                                                                                                                                                                                                                                                                                                                                                                                                        showAvatarForEveryMessage?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                          property textStyle

                                                                                                                                                                                                                                                                                                                                                                                                                          textStyle?: TextStyle;

                                                                                                                                                                                                                                                                                                                                                                                                                            method onLongPressAvatar

                                                                                                                                                                                                                                                                                                                                                                                                                            onLongPressAvatar: (user: User) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              method onPressAvatar

                                                                                                                                                                                                                                                                                                                                                                                                                              onPressAvatar: (user: User) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                method renderAvatar

                                                                                                                                                                                                                                                                                                                                                                                                                                renderAvatar: (props: Omit<AvatarProps<TMessage>, 'renderAvatar'>) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BubbleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BubbleProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property bottomContainerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                    bottomContainerStyle?: LeftRightStyle<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                      containerStyle?: LeftRightStyle<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property containerToNextStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                        containerToNextStyle?: LeftRightStyle<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property containerToPreviousStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                          containerToPreviousStyle?: LeftRightStyle<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                            currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property inverted

                                                                                                                                                                                                                                                                                                                                                                                                                                              inverted?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property isCustomViewBottom

                                                                                                                                                                                                                                                                                                                                                                                                                                                isCustomViewBottom?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property nextMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                  nextMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property optionTitles

                                                                                                                                                                                                                                                                                                                                                                                                                                                    optionTitles?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                      position: 'left' | 'right';

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property previousMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                        previousMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property quickReplyStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                          quickReplyStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property renderUsernameOnMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                            renderUsernameOnMessage?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property textStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                              textStyle?: LeftRightStyle<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tickStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                tickStyle?: StyleProp<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property touchableProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  touchableProps?: object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    user?: User;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property usernameStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      usernameStyle?: TextStyle;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property wrapperStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        wrapperStyle?: LeftRightStyle<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onLongPress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onLongPress: (context?: any, message?: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method onQuickReply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onQuickReply: (replies: Reply[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method renderCustomView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderCustomView: (bubbleProps: BubbleProps<TMessage>) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method renderMessageAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                renderMessageAudio: (props: RenderMessageAudioProps<TMessage>) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method renderMessageImage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  renderMessageImage: (props: RenderMessageImageProps<TMessage>) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method renderMessageText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    renderMessageText: (props: RenderMessageTextProps<TMessage>) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method renderMessageVideo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      renderMessageVideo: (props: RenderMessageVideoProps<TMessage>) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method renderQuickReplies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        renderQuickReplies: (quickReplies: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method renderQuickReplySend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderQuickReplySend: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method renderTicks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            renderTicks: (currentMessage: TMessage) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method renderTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderTime: (timeProps: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method renderUsername

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                renderUsername: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ComposerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ComposerProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property composerHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    composerHeight?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property disableComposer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disableComposer?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property keyboardAppearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keyboardAppearance?: TextInputProps['keyboardAppearance'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property multiline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          multiline?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property placeholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            placeholder?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property placeholderTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              placeholderTextColor?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                text?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property textInputAutoFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  textInputAutoFocus?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property textInputProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    textInputProps?: Partial<TextInputProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property textInputStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      textInputStyle?: TextInputProps['style'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onInputSizeChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onInputSizeChanged: (contentSize: { width: number; height: number }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onTextChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onTextChanged: (text: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DayProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DayProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              containerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dateFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dateFormat?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property inverted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    inverted?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property nextMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nextMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property previousMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        previousMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property textStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          textStyle?: StyleProp<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property wrapperStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            wrapperStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GiftedAvatarProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GiftedAvatarProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property avatarStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                avatarStyle?: StyleProp<ImageStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property textStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  textStyle?: StyleProp<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    user?: User;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onLongPress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLongPress: (props: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onPress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onPress: (props: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GiftedChatProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GiftedChatProps<TMessage extends IMessage = IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property alignTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            alignTop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property alwaysShowSend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              alwaysShowSend?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bottomOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bottomOffset?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dateFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dateFormat?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property disableComposer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disableComposer?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property extraData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extraData?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property forceGetKeyboardHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        forceGetKeyboardHeight?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property imageProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          imageProps?: Message<TMessage>['props'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property imageStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            imageStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property infiniteScroll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              infiniteScroll?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property initialText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                initialText?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property inverted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  inverted?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isCustomViewBottom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isCustomViewBottom?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isKeyboardInternallyHandled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isKeyboardInternallyHandled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isLoadingEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isLoadingEarlier?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isTyping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTyping?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property keyboardShouldPersistTaps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keyboardShouldPersistTaps?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property lightboxProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lightboxProps?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property listViewProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listViewProps?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property loadEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  loadEarlier?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property locale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    locale?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property maxComposerHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxComposerHeight?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property maxInputLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        maxInputLength?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          messages?: TMessage[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property messagesContainerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            messagesContainerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property minComposerHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              minComposerHeight?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property minInputToolbarHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                minInputToolbarHeight?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property optionTintColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    optionTintColor?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property placeholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      placeholder?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property quickReplyStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        quickReplyStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property renderAvatarOnTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderAvatarOnTop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scrollToBottom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scrollToBottom?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property scrollToBottomStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scrollToBottomStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property showAvatarForEveryMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showAvatarForEveryMessage?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property showUserAvatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  showUserAvatar?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property textInputProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      textInputProps?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        timeFormat?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property timeTextStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          timeTextStyle?: LeftRightStyle<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            user?: User;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property wrapInSafeArea

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              wrapInSafeArea?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method actionSheet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                actionSheet: () => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showActionSheetWithOptions: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (i: number) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method messageIdGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  messageIdGenerator: (message?: TMessage) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method onInputTextChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onInputTextChanged: (text: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onLoadEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoadEarlier: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onLongPress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onLongPress: (context: any, message: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onLongPressAvatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onLongPressAvatar: (user: User) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method onPressActionButton

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onPressActionButton: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method onPressAvatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onPressAvatar: (user: User) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method onQuickReply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onQuickReply: (replies: Reply[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method onSend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onSend: (messages: TMessage[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method parsePatterns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parsePatterns: (linkStyle: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method renderAccessory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      renderAccessory: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method renderActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        renderActions: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method renderAvatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderAvatar: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method renderBubble

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            renderBubble: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method renderChatEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderChatEmpty: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method renderChatFooter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                renderChatFooter: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method renderComposer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  renderComposer: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method renderCustomView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    renderCustomView: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method renderDay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      renderDay: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method renderFooter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        renderFooter: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method renderInputToolbar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderInputToolbar: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method renderLoadEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            renderLoadEarlier: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method renderLoading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderLoading: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method renderMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                renderMessage: (message: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method renderMessageImage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  renderMessageImage: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method renderMessageText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    renderMessageText: (messageText: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method renderQuickReplies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      renderQuickReplies: (quickReplies: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method renderQuickReplySend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        renderQuickReplySend: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method renderSend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderSend: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method renderSystemMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            renderSystemMessage: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method renderTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderTime: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method scrollToBottomComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scrollToBottomComponent: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method shouldUpdateMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  shouldUpdateMessage: (props: any, nextProps: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GiftedChatState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GiftedChatState<TMessage extends IMessage = IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property composerHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      composerHeight?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isInitialized

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isInitialized: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          messages?: TMessage[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property messagesContainerHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            messagesContainerHeight?: number | Animated.Value;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              text?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property typingDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typingDisabled: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property audio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    audio?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property createdAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createdAt: Date | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        image?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pending?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property quickReplies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            quickReplies?: QuickReplies;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property received

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              received?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sent?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property system

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  system?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      user: User;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property video

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        video?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface InputToolbarProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface InputToolbarProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property accessoryStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            accessoryStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              containerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property optionTintColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  optionTintColor?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property primaryStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    primaryStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onPressActionButton

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPressActionButton: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method renderAccessory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        renderAccessory: (props: InputToolbarProps) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method renderActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderActions: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method renderComposer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            renderComposer: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method renderSend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderSend: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LeftRightStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LeftRightStyle<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property left

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  left: StyleProp<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property right

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    right: StyleProp<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LoadEarlierProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LoadEarlierProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property activityIndicatorColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        activityIndicatorColor?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property activityIndicatorSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          activityIndicatorSize?: number | 'small' | 'large';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property activityIndicatorStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            activityIndicatorStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              containerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isLoadingEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isLoadingEarlier?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property textStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    textStyle?: StyleProp<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property wrapperStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      wrapperStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onLoadEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onLoadEarlier: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MessageAudioProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MessageAudioProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property audioProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            audioProps?: object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property audioStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              audioStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                containerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MessageContainerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MessageContainerProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property alignTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alignTop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property extraData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extraData?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property forwardRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          forwardRef?: RefObject<FlatList<IMessage>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property infiniteScroll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            infiniteScroll?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property inverted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              inverted?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property invertibleScrollViewProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                invertibleScrollViewProps?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isLoadingEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isLoadingEarlier?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isTyping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTyping?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property listViewProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      listViewProps: Partial<ListViewProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loadEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        loadEarlier?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          messages?: TMessage[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scrollToBottom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scrollToBottom?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property scrollToBottomOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scrollToBottomOffset?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scrollToBottomStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scrollToBottomStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  user?: User;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method onLoadEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onLoadEarlier: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onQuickReply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onQuickReply: (replies: Reply[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method renderChatEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        renderChatEmpty: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method renderFooter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderFooter: (props: MessageContainerProps<TMessage>) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method renderLoadEarlier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            renderLoadEarlier: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method renderMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderMessage: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method scrollToBottomComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scrollToBottomComponent: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MessageImageProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MessageImageProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    containerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property imageProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imageProps?: Partial<ImageProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property imageStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          imageStyle?: StyleProp<ImageStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property lightboxProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lightboxProps?: object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MessageProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MessageProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                containerStyle?: LeftRightStyle<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property inverted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    inverted?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property nextMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        nextMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          position: 'left' | 'right';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property previousMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            previousMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property showUserAvatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              showUserAvatar?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                user: User;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method renderAvatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  renderAvatar: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method renderBubble

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    renderBubble: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method renderDay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      renderDay: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method renderSystemMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        renderSystemMessage: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method shouldUpdateMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          shouldUpdateMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          props: MessageProps<IMessage>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nextProps: MessageProps<IMessage>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MessageTextProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MessageTextProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              containerStyle?: LeftRightStyle<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property customTextStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  customTextStyle?: StyleProp<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property linkStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    linkStyle?: LeftRightStyle<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property optionTitles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      optionTitles?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        position: 'left' | 'right';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property textProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          textProps?: TextProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property textStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            textStyle?: LeftRightStyle<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method parsePatterns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parsePatterns: (linkStyle: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MessageVideoProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MessageVideoProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  containerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property lightboxProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lightboxProps?: object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property videoProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        videoProps?: object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property videoStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          videoStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface QuickReplies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface QuickReplies {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property keepIt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keepIt?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'radio' | 'checkbox';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  values: Reply[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface QuickRepliesProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface QuickRepliesProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      color?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        currentMessage?: IMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property nextMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nextMessage?: IMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property quickReplyStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            quickReplyStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sendText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sendText?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method onQuickReply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onQuickReply: (reply: Reply[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method renderQuickReplySend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  renderQuickReplySend: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Reply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Reply {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property messageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      messageId?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        title: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SendProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SendProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property alwaysShowSend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              alwaysShowSend?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                children?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  containerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sendButtonProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sendButtonProps?: Partial<TouchableOpacityProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          text?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property textStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            textStyle?: StyleProp<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method onSend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onSend: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              messages: Partial<TMessage> | Partial<TMessage>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              shouldResetInputToolbar: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SystemMessageProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SystemMessageProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  containerStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property textStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      textStyle?: StyleProp<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property wrapperStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        wrapperStyle?: StyleProp<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TimeProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TimeProps<TMessage extends IMessage> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property containerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            containerStyle?: LeftRightStyle<ViewStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property currentMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentMessage?: TMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                position: 'left' | 'right';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property timeFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timeFormat?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property timeTextStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeTextStyle?: LeftRightStyle<TextStyle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface User {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property avatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        avatar?: string | renderFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IChatMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IChatMessage = IMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Omit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RenderMessageAudioProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RenderMessageAudioProps<TMessage extends IMessage> = Omit<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BubbleProps<TMessage>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'containerStyle' | 'wrapperStyle'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MessageAudioProps<TMessage>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RenderMessageImageProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RenderMessageImageProps<TMessage extends IMessage> = Omit<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BubbleProps<TMessage>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'containerStyle' | 'wrapperStyle'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MessageImage['props'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RenderMessageTextProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RenderMessageTextProps<TMessage extends IMessage> = Omit<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BubbleProps<TMessage>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'containerStyle' | 'wrapperStyle'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MessageText['props'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RenderMessageVideoProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RenderMessageVideoProps<TMessage extends IMessage> = Omit<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BubbleProps<TMessage>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'containerStyle' | 'wrapperStyle'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MessageVideoProps<TMessage>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace utils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        module 'lib/utils.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable StylePropType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const StylePropType: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            error: (...args: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isSameDay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isSameDay: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentMessage: IMessage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diffMessage: IMessage | null | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function isSameUser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isSameUser: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                currentMessage: IMessage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diffMessage: IMessage | null | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function warning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  warning: (...args: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package Files (20)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (9)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dev Dependencies (32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Peer Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/react-native-gifted-chat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/react-native-gifted-chat)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <a href="https://www.jsdocs.io/package/react-native-gifted-chat"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>