Struct telegram_client::listener::lasync::RasyncListener

pub struct RasyncListener { /* private fields */ }

Telegram client event listener

Implementations

impl RasyncListener

pub fn new() -> Self

pub fn on_receive<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, String)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

when receive data from tdlib

pub fn on_exception<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TGError)) -> LocalBoxFuture<'static, ()> + 'static, 

when telegram client throw exception

pub fn on_test_use_update<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TestUseUpdate)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Does nothing and ensures that the Update object is used; for testing only. This is an offline method. Can be called before authorization

pub fn on_update_active_notifications<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateActiveNotifications)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains active notifications that was shown on previous application launches. This update is sent only if the message database is used. In that case it comes once before any updateNotification and updateNotificationGroup update

pub fn on_update_animated_emoji_message_clicked<F>(
    &mut self,
    fnc: F
) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateAnimatedEmojiMessageClicked)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some animated emoji message was clicked and a big animated sticker must be played if the message is visible on the screen. chatActionWatchingAnimations with the text of the message needs to be sent if the sticker is played

pub fn on_update_animation_search_parameters<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateAnimationSearchParameters)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The parameters of animation search through GetOption(“animation_search_bot_username”) bot has changed

pub fn on_update_authorization_state<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateAuthorizationState)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The user authorization state has changed

pub fn on_update_basic_group<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateBasicGroup)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some data of a basic group has changed. This update is guaranteed to come before the basic group identifier is returned to the application

pub fn on_update_basic_group_full_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateBasicGroupFullInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some data in basicGroupFullInfo has been changed

pub fn on_update_call<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateCall)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

New call was created or information about a call was updated

pub fn on_update_chat_action<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatAction)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A message sender activity in the chat has changed

pub fn on_update_chat_action_bar<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatActionBar)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The chat action bar was changed

pub fn on_update_chat_default_disable_notification<F>(
    &mut self,
    fnc: F
) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatDefaultDisableNotification)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The value of the default disable_notification parameter, used when a message is sent to the chat, was changed

pub fn on_update_chat_draft_message<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatDraftMessage)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A chat draft has changed. Be aware that the update may come in the currently opened chat but with old content of the draft. If the user has changed the content of the draft, this update mustn’t be applied

pub fn on_update_chat_filters<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatFilters)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of chat filters or a chat filter has changed

pub fn on_update_chat_has_protected_content<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatHasProtectedContent)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A chat content was allowed or restricted for saving

pub fn on_update_chat_has_scheduled_messages<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatHasScheduledMessages)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A chat’s has_scheduled_messages field has changed

pub fn on_update_chat_is_blocked<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatIsBlocked)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A chat was blocked or unblocked

pub fn on_update_chat_is_marked_as_unread<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatIsMarkedAsUnread)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A chat was marked as unread or was read

pub fn on_update_chat_last_message<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatLastMessage)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The last message of a chat was changed. If last_message is null, then the last message in the chat became unknown. Some new unknown messages might be added to the chat in this case

pub fn on_update_chat_member<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatMember)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

User rights changed in a chat; for bots only

pub fn on_update_chat_message_sender<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatMessageSender)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The message sender that is selected to send messages in a chat has changed

pub fn on_update_chat_message_ttl<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatMessageTtl)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The message Time To Live setting for a chat was changed

pub fn on_update_chat_notification_settings<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatNotificationSettings)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Notification settings for a chat were changed

pub fn on_update_chat_online_member_count<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatOnlineMemberCount)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The number of online group members has changed. This update with non-zero count is sent only for currently opened chats. There is no guarantee that it will be sent just after the count has changed

pub fn on_update_chat_pending_join_requests<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatPendingJoinRequests)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The chat pending join requests were changed

pub fn on_update_chat_permissions<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatPermissions)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Chat permissions was changed

pub fn on_update_chat_photo<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatPhoto)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A chat photo was changed

pub fn on_update_chat_position<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatPosition)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The position of a chat in a chat list has changed. Instead of this update updateChatLastMessage or updateChatDraftMessage might be sent

pub fn on_update_chat_read_inbox<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatReadInbox)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Incoming messages were read or the number of unread messages has been changed

pub fn on_update_chat_read_outbox<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatReadOutbox)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Outgoing messages were read

pub fn on_update_chat_reply_markup<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatReplyMarkup)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The default chat reply markup was changed. Can occur because new messages with reply markup were received or because an old reply markup was hidden by the user

pub fn on_update_chat_theme<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatTheme)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The chat theme was changed

pub fn on_update_chat_themes<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatThemes)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of available chat themes has changed

pub fn on_update_chat_title<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatTitle)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The title of a chat was changed

pub fn on_update_chat_unread_mention_count<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatUnreadMentionCount)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The chat unread_mention_count has changed

pub fn on_update_chat_video_chat<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateChatVideoChat)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A chat video chat state has changed

pub fn on_update_connection_state<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateConnectionState)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The connection state has changed. This update must be used only to show a human-readable description of the connection state

pub fn on_update_delete_messages<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateDeleteMessages)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some messages were deleted

pub fn on_update_dice_emojis<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateDiceEmojis)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of supported dice emojis has changed

pub fn on_update_favorite_stickers<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateFavoriteStickers)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of favorite stickers was updated

pub fn on_update_file<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateFile)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Information about a file was updated

pub fn on_update_file_generation_start<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateFileGenerationStart)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The file generation process needs to be started by the application

pub fn on_update_file_generation_stop<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateFileGenerationStop)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

File generation is no longer needed

pub fn on_update_group_call<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateGroupCall)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Information about a group call was updated

pub fn on_update_group_call_participant<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateGroupCallParticipant)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Information about a group call participant was changed. The updates are sent only after the group call is received through getGroupCall and only if the call is joined or being joined

pub fn on_update_have_pending_notifications<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateHavePendingNotifications)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes whether there are some pending notification updates. Can be used to prevent application from killing, while there are some pending notifications

pub fn on_update_installed_sticker_sets<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateInstalledStickerSets)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of installed sticker sets was updated

pub fn on_update_language_pack_strings<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateLanguagePackStrings)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some language pack strings have been updated

pub fn on_update_message_content<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageContent)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The message content has changed

pub fn on_update_message_content_opened<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageContentOpened)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The message content was opened. Updates voice note messages to “listened”, video note messages to “viewed” and starts the TTL timer for self-destructing messages

pub fn on_update_message_edited<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageEdited)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A message was edited. Changes in the message content will come in a separate updateMessageContent

pub fn on_update_message_interaction_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageInteractionInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The information about interactions with a message has changed

pub fn on_update_message_is_pinned<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageIsPinned)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The message pinned state was changed

pub fn on_update_message_live_location_viewed<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageLiveLocationViewed)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A message with a live location was viewed. When the update is received, the application is supposed to update the live location

pub fn on_update_message_mention_read<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageMentionRead)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A message with an unread mention was read

pub fn on_update_message_send_acknowledged<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageSendAcknowledged)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A request to send a message has reached the Telegram server. This doesn’t mean that the message will be sent successfully or even that the send message request will be processed. This update will be sent only if the option “use_quick_ack” is set to true. This update may be sent multiple times for the same message

pub fn on_update_message_send_failed<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageSendFailed)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A message failed to send. Be aware that some messages being sent can be irrecoverably deleted, in which case updateDeleteMessages will be received instead of this update

pub fn on_update_message_send_succeeded<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateMessageSendSucceeded)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A message has been successfully sent

pub fn on_update_new_call_signaling_data<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewCallSignalingData)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

New call signaling data arrived

pub fn on_update_new_callback_query<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewCallbackQuery)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A new incoming callback query; for bots only

pub fn on_update_new_chat<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewChat)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A new chat has been loaded/created. This update is guaranteed to come before the chat identifier is returned to the application. The chat field changes will be reported through separate updates

pub fn on_update_new_chat_join_request<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewChatJoinRequest)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A user sent a join request to a chat; for bots only

pub fn on_update_new_chosen_inline_result<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewChosenInlineResult)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The user has chosen a result of an inline query; for bots only

pub fn on_update_new_custom_event<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewCustomEvent)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A new incoming event; for bots only

pub fn on_update_new_custom_query<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewCustomQuery)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A new incoming query; for bots only

pub fn on_update_new_inline_callback_query<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewInlineCallbackQuery)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A new incoming callback query from a message sent via a bot; for bots only

pub fn on_update_new_inline_query<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewInlineQuery)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A new incoming inline query; for bots only

pub fn on_update_new_message<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewMessage)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A new message was received; can also be an outgoing message

pub fn on_update_new_pre_checkout_query<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewPreCheckoutQuery)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A new incoming pre-checkout query; for bots only. Contains full information about a checkout

pub fn on_update_new_shipping_query<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNewShippingQuery)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A new incoming shipping query; for bots only. Only for invoices with flexible price

pub fn on_update_notification<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNotification)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A notification was changed

pub fn on_update_notification_group<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateNotificationGroup)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A list of active notifications in a notification group has changed

pub fn on_update_option<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateOption)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

An option changed its value

pub fn on_update_poll<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdatePoll)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A poll was updated; for bots only

pub fn on_update_poll_answer<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdatePollAnswer)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A user changed the answer to a poll; for bots only

pub fn on_update_recent_stickers<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateRecentStickers)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of recently used stickers was updated

pub fn on_update_saved_animations<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateSavedAnimations)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of saved animations was updated

pub fn on_update_scope_notification_settings<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateScopeNotificationSettings)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Notification settings for some type of chats were updated

pub fn on_update_secret_chat<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateSecretChat)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some data of a secret chat has changed. This update is guaranteed to come before the secret chat identifier is returned to the application

pub fn on_update_selected_background<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateSelectedBackground)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The selected background has changed

pub fn on_update_service_notification<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateServiceNotification)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A service notification from the server was received. Upon receiving this the application must show a popup with the content of the notification

pub fn on_update_sticker_set<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateStickerSet)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A sticker set has changed

pub fn on_update_suggested_actions<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateSuggestedActions)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of suggested to the user actions has changed

pub fn on_update_supergroup<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateSupergroup)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some data of a supergroup or a channel has changed. This update is guaranteed to come before the supergroup identifier is returned to the application

pub fn on_update_supergroup_full_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateSupergroupFullInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some data in supergroupFullInfo has been changed

pub fn on_update_terms_of_service<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateTermsOfService)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

New terms of service must be accepted by the user. If the terms of service are declined, then the deleteAccount method must be called with the reason “Decline ToS update”

pub fn on_update_trending_sticker_sets<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateTrendingStickerSets)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of trending sticker sets was updated or some of them were viewed

pub fn on_update_unread_chat_count<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateUnreadChatCount)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Number of unread chats, i.e. with unread messages or marked as unread, has changed. This update is sent only if the message database is used

pub fn on_update_unread_message_count<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateUnreadMessageCount)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Number of unread messages in a chat list has changed. This update is sent only if the message database is used

pub fn on_update_user<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateUser)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some data of a user has changed. This update is guaranteed to come before the user identifier is returned to the application

pub fn on_update_user_full_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateUserFullInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some data in userFullInfo has been changed

pub fn on_update_user_privacy_setting_rules<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateUserPrivacySettingRules)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Some privacy setting rules have been changed

pub fn on_update_user_status<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateUserStatus)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The user went online or offline

pub fn on_update_users_nearby<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UpdateUsersNearby)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

The list of users nearby has changed. The update is guaranteed to be sent only 60 seconds after a successful searchChatsNearby request

pub fn on_authorization_state<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, AuthorizationState)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents the current authorization state of the TDLib client

pub fn on_can_transfer_ownership_result<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, CanTransferOwnershipResult)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents result of checking whether the current session can be used to transfer a chat ownership to another user

pub fn on_chat_statistics<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatStatistics)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a detailed statistics about a chat

pub fn on_check_chat_username_result<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, CheckChatUsernameResult)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents result of checking whether a username can be set for a chat

pub fn on_check_sticker_set_name_result<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, CheckStickerSetNameResult)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents result of checking whether a name can be used for a new sticker set

pub fn on_internal_link_type<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, InternalLinkType)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes an internal https://t.me or tg: link, which must be processed by the app in a special way

pub fn on_json_value<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, JsonValue)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a JSON value

pub fn on_language_pack_string_value<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, LanguagePackStringValue)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents the value of a string in a language pack

pub fn on_log_stream<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, LogStream)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes a stream to which TDLib internal log is written

pub fn on_login_url_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, LoginUrlInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about an inline button of type inlineKeyboardButtonTypeLoginUrl

pub fn on_message_file_type<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, MessageFileType)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a file with messages exported from another app

pub fn on_option_value<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, OptionValue)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents the value of an option

pub fn on_passport_element<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PassportElement)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a Telegram Passport element

pub fn on_reset_password_result<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ResetPasswordResult)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents result of 2-step verification password reset

pub fn on_statistical_graph<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, StatisticalGraph)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes a statistical graph

pub fn on_update<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Update)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains notifications about data changes

pub fn on_account_ttl<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, AccountTtl)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about the period of inactivity after which the current user’s account will automatically be deleted

pub fn on_animated_emoji<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, AnimatedEmoji)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes an animated representation of an emoji

pub fn on_animations<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Animations)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of animations

pub fn on_authentication_code_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, AuthenticationCodeInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Information about the authentication code that was sent

pub fn on_auto_download_settings_presets<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, AutoDownloadSettingsPresets)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains auto-download settings presets for the current user

pub fn on_background<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Background)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes a chat background

pub fn on_backgrounds<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Backgrounds)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of backgrounds

pub fn on_bank_card_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, BankCardInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Information about a bank card

pub fn on_basic_group<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, BasicGroup)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a basic group of 0-200 users (must be upgraded to a supergroup to accommodate more than 200 users)

pub fn on_basic_group_full_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, BasicGroupFullInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains full information about a basic group

pub fn on_bot_commands<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, BotCommands)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of bot commands

pub fn on_call_id<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, CallId)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains the call identifier

pub fn on_callback_query_answer<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, CallbackQueryAnswer)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a bot’s answer to a callback query

pub fn on_chat<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Chat)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A chat. (Can be a private chat, basic group, supergroup, or secret chat)

pub fn on_chat_administrators<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatAdministrators)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of chat administrators

pub fn on_chat_events<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatEvents)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of chat events

pub fn on_chat_filter<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatFilter)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a filter of user chats

pub fn on_chat_filter_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatFilterInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains basic information about a chat filter

pub fn on_chat_invite_link<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatInviteLink)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a chat invite link

pub fn on_chat_invite_link_counts<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatInviteLinkCounts)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of chat invite link counts

pub fn on_chat_invite_link_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatInviteLinkInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a chat invite link

pub fn on_chat_invite_link_members<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatInviteLinkMembers)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of chat members joined a chat via an invite link

pub fn on_chat_invite_links<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatInviteLinks)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of chat invite links

pub fn on_chat_join_requests<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatJoinRequests)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of requests to join a chat

pub fn on_chat_lists<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatLists)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of chat lists

pub fn on_chat_member<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatMember)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes a user or a chat as a member of another chat

pub fn on_chat_members<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatMembers)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of chat members

pub fn on_chat_photos<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatPhotos)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of chat or user profile photos

pub fn on_chats<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Chats)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of chats

pub fn on_chats_nearby<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ChatsNearby)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of chats located nearby

pub fn on_connected_websites<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ConnectedWebsites)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of websites the current user is logged in with Telegram

pub fn on_count<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Count)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a counter

pub fn on_countries<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Countries)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about countries

pub fn on_custom_request_result<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, CustomRequestResult)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains the result of a custom request

pub fn on_database_statistics<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, DatabaseStatistics)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains database statistics

pub fn on_deep_link_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, DeepLinkInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a tg: deep link

pub fn on_email_address_authentication_code_info<F>(
    &mut self,
    fnc: F
) -> &mut Self where
    F: Send + Sync + Fn((Api, EmailAddressAuthenticationCodeInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Information about the email address authentication code that was sent

pub fn on_emojis<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Emojis)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of emoji

pub fn on_error<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Error)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

An object of this type can be returned on every function call, in case of an error

pub fn on_file<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, File)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a file

pub fn on_file_part<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, FilePart)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a part of a file

pub fn on_formatted_text<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, FormattedText)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A text with some entities

pub fn on_found_messages<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, FoundMessages)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of messages found by a search

pub fn on_game_high_scores<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, GameHighScores)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of game high scores

pub fn on_group_call<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, GroupCall)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes a group call

pub fn on_group_call_id<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, GroupCallId)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains the group call identifier

pub fn on_hashtags<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Hashtags)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of hashtags

pub fn on_http_url<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, HttpUrl)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains an HTTP URL

pub fn on_imported_contacts<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ImportedContacts)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents the result of an ImportContacts request

pub fn on_inline_query_results<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, InlineQueryResults)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents the results of the inline query. Use sendInlineQueryResultMessage to send the result of the query

pub fn on_language_pack_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, LanguagePackInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a language pack

pub fn on_language_pack_strings<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, LanguagePackStrings)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of language pack strings

pub fn on_localization_target_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, LocalizationTargetInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about the current localization target

pub fn on_log_tags<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, LogTags)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of available TDLib internal log tags

pub fn on_log_verbosity_level<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, LogVerbosityLevel)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a TDLib internal log verbosity level

pub fn on_message<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Message)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes a message

pub fn on_message_calendar<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, MessageCalendar)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about found messages, split by days according to the option “utc_time_offset”

pub fn on_message_link<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, MessageLink)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains an HTTPS link to a message in a supergroup or channel

pub fn on_message_link_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, MessageLinkInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a link to a message in a chat

pub fn on_message_positions<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, MessagePositions)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of message positions

pub fn on_message_senders<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, MessageSenders)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of message senders

pub fn on_message_statistics<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, MessageStatistics)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A detailed statistics about a message

pub fn on_message_thread_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, MessageThreadInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a message thread

pub fn on_messages<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Messages)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of messages

pub fn on_network_statistics<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, NetworkStatistics)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A full list of available network statistic entries

pub fn on_ok<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Ok)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

An object of this type is returned on a successful function call for certain functions

pub fn on_order_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, OrderInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Order information

pub fn on_passport_authorization_form<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PassportAuthorizationForm)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a Telegram Passport authorization form that was requested

pub fn on_passport_elements<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PassportElements)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about saved Telegram Passport elements

pub fn on_passport_elements_with_errors<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PassportElementsWithErrors)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a Telegram Passport elements and corresponding errors

pub fn on_password_state<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PasswordState)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents the current state of 2-step verification

pub fn on_payment_form<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PaymentForm)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about an invoice payment form

pub fn on_payment_receipt<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PaymentReceipt)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a successful payment

pub fn on_payment_result<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PaymentResult)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains the result of a payment request

pub fn on_phone_number_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PhoneNumberInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a phone number

pub fn on_proxies<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Proxies)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of proxy servers

pub fn on_proxy<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Proxy)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about a proxy server

pub fn on_push_receiver_id<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, PushReceiverId)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a globally unique push receiver identifier, which can be used to identify which account has received a push notification

pub fn on_recommended_chat_filters<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, RecommendedChatFilters)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of recommended chat filters

pub fn on_recovery_email_address<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, RecoveryEmailAddress)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about the current recovery email address

pub fn on_scope_notification_settings<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ScopeNotificationSettings)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about notification settings for several chats

pub fn on_seconds<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Seconds)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a value representing a number of seconds

pub fn on_secret_chat<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, SecretChat)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a secret chat

pub fn on_session<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Session)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains information about one session in a Telegram application used by the current user. Sessions must be shown to the user in the returned order

pub fn on_sessions<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Sessions)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of sessions

pub fn on_sponsored_message<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, SponsoredMessage)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes a sponsored message

pub fn on_sticker<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Sticker)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes a sticker

pub fn on_sticker_set<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, StickerSet)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a sticker set

pub fn on_sticker_sets<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, StickerSets)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of sticker sets

pub fn on_stickers<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Stickers)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of stickers

pub fn on_storage_statistics<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, StorageStatistics)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains the exact storage usage statistics split by chats and file type

pub fn on_storage_statistics_fast<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, StorageStatisticsFast)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains approximate storage usage statistics, excluding files of unknown file type

pub fn on_supergroup<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Supergroup)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a supergroup or channel with zero or more members (subscribers in the case of channels). From the point of view of the system, a channel is a special kind of a supergroup: only administrators can post and see the list of members, and posts from all administrators use the name and photo of the channel instead of individual names and profile photos. Unlike supergroups, channels can have an unlimited number of subscribers

pub fn on_supergroup_full_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, SupergroupFullInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains full information about a supergroup or channel

pub fn on_t_me_urls<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TMeUrls)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of t.me URLs

pub fn on_temporary_password_state<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TemporaryPasswordState)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Returns information about the availability of a temporary password, which can be used for payments

pub fn on_test_bytes<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TestBytes)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A simple object containing a sequence of bytes; for testing only

pub fn on_test_int<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TestInt)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A simple object containing a number; for testing only

pub fn on_test_string<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TestString)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A simple object containing a string; for testing only

pub fn on_test_vector_int<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TestVectorInt)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A simple object containing a vector of numbers; for testing only

pub fn on_test_vector_int_object<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TestVectorIntObject)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A simple object containing a vector of objects that hold a number; for testing only

pub fn on_test_vector_string<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TestVectorString)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A simple object containing a vector of strings; for testing only

pub fn on_test_vector_string_object<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TestVectorStringObject)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A simple object containing a vector of objects that hold a string; for testing only

pub fn on_text<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Text)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains some text

pub fn on_text_entities<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, TextEntities)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of text entities

pub fn on_updates<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Updates)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a list of updates

pub fn on_user<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, User)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a user

pub fn on_user_full_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UserFullInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains full information about a user

pub fn on_user_privacy_setting_rules<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, UserPrivacySettingRules)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

A list of privacy rules. Rules are matched in the specified order. The first matched rule defines the privacy setting for a given user. If no rule matches, the action is not allowed

pub fn on_users<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, Users)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Represents a list of users

pub fn on_validated_order_info<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, ValidatedOrderInfo)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Contains a temporary identifier of validated order information, which is stored for one hour. Also contains the available shipping options

pub fn on_web_page<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, WebPage)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes a web page preview

pub fn on_web_page_instant_view<F>(&mut self, fnc: F) -> &mut Self where
    F: Send + Sync + Fn((Api, WebPageInstantView)) -> LocalBoxFuture<'static, TGResult<()>> + 'static, 

Describes an instant view page for a web page

Trait Implementations

impl Clone for RasyncListener

fn clone(&self) -> RasyncListener

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for RasyncListener

fn default() -> RasyncListener

Returns the “default value” for a type.