Struct EventLoop

pub struct EventLoop { /* private fields */ }

Provides an event loop for handling Telegram updates.

With EventLoop, you can configure handlers and start listening to updates via either polling or webhook.

let mut bot = tbot::from_env!("BOT_TOKEN").event_loop();

bot.text(|_| async { println!("Got a text message") });

bot.polling().start();

tbot has many update handlers, such as text you have seen in the example. You can find all of them below on this page.

Implementations

impl EventLoop

pub fn into_stateful<S>(self, state: S) -> StatefulEventLoop<S>

where S: Send + Sync + 'static,

Turns this event loop into a stateful one. Handlers added on this event loop are kept.

pub fn username(&mut self, username: String)

Sets the bot’s username.

The username is used when checking if a command such as /command@username was directed to the bot.

pub fn polling(self) -> Polling

Starts polling configuration.

pub fn webhook(self, url: &str, port: u16) -> Webhook<'_>

Starts webhook configuration.

See our wiki to learn how to use webhook with tbot.

pub fn command<H, F>(&mut self, command: &'static str, handler: H)

where H: Fn(Arc<Command<Text>>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for a command.

Note that commands such as /command@username will be completely ignored unless you configure the event loop with your bot’s username with either username or fetch_username.

pub fn command_if<H, HF, P, PF>( &mut self, command: &'static str, predicate: P, handler: H, )

where H: Fn(Arc<Command<Text>>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Command<Text>>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for a command which is run if the predicate returns true.

Note that commands such as /command@username will be completely ignored unless you configure the event loop with your bot’s username with either username or fetch_username.

pub fn commands<Cm, H, F>(&mut self, commands: Cm, handler: H)

where Cm: IntoIterator<Item = &'static str>, F: Future<Output = ()> + Send + 'static, H: Fn(Arc<Command<Text>>) -> F + Send + Sync + 'static,

Adds a new handler for a sequence of commands.

Note that commands such as /command@username will be completely ignored unless you configure the event loop with your bot’s username with either username or fetch_username.

pub fn commands_if<Cm, H, HF, P, PF>( &mut self, commands: Cm, predicate: P, handler: H, )

where Cm: IntoIterator<Item = &'static str>, H: Fn(Arc<Command<Text>>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Command<Text>>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for a sequence of commands which is run if the predicate returns true.

Note that commands such as /command@username will be completely ignored unless you configure the event loop with your bot’s username with either username or fetch_username.

pub fn start<H, F>(&mut self, handler: H)

where H: Fn(Arc<Command<Text>>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for the /start command.

pub fn start_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Command<Text>>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Command<Text>>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for the /start command which is run if the predicate returns true.

pub fn settings<H, F>(&mut self, handler: H)

where H: Fn(Arc<Command<Text>>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for the /settings command.

pub fn settings_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Command<Text>>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Command<Text>>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for the /settings command which is run if the predicate returns true.

pub fn help<H, F>(&mut self, handler: H)

where H: Fn(Arc<Command<Text>>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for the /help command.

pub fn help_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Command<Text>>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Command<Text>>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for the /help command which is run if the predicate returns true.

pub fn edited_command<H, F>(&mut self, command: &'static str, handler: H)

where H: Fn(Arc<Command<EditedText>>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for an edited command.

pub fn edited_command_if<H, HF, P, PF>( &mut self, command: &'static str, predicate: P, handler: H, )

where H: Fn(Arc<Command<EditedText>>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Command<EditedText>>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for an edited command which is run if the predicate returns true.

pub fn edited_commands<Cm, H, F>(&mut self, commands: Cm, handler: H)

where Cm: IntoIterator<Item = &'static str>, F: Future<Output = ()> + Send + 'static, H: Fn(Arc<Command<EditedText>>) -> F + Send + Sync + 'static,

Adds a new handler for an edited command from sequence of commands.

pub fn edited_commands_if<Cm, H, HF, P, PF>( &mut self, commands: Cm, predicate: P, handler: H, )

where Cm: IntoIterator<Item = &'static str>, H: Fn(Arc<Command<EditedText>>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Command<EditedText>>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for a sequence of edited commands which is run if the predicate returns true.

pub fn after_update<H, F>(&mut self, handler: H)

where H: Fn(Arc<Update>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler which is run after handling an update.

pub fn after_update_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Update>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Update>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler which is run after handling an update and if the predicate returns true.

pub fn animation<H, F>(&mut self, handler: H)

where H: Fn(Arc<Animation>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for animations.

pub fn animation_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Animation>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Animation>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for animations which is run if the predicate returns true.

pub fn audio<H, F>(&mut self, handler: H)

where H: Fn(Arc<Audio>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for audio.

pub fn audio_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Audio>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Audio>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for audio which is run if the predicate returns true.

pub fn before_update<H, F>(&mut self, handler: H)

where H: Fn(Arc<Update>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler which is run before handling an update.

pub fn before_update_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Update>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Update>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler which is run before handling an update and if the predicate returns true.

pub fn chosen_inline<H, F>(&mut self, handler: H)

where H: Fn(Arc<ChosenInline>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for chosen inline results.

pub fn chosen_inline_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<ChosenInline>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<ChosenInline>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for chosen inline results which is run if the predicate returns true.

pub fn contact<H, F>(&mut self, handler: H)

where H: Fn(Arc<Contact>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for contacts.

pub fn contact_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Contact>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Contact>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for contacts which is run if the predicate returns true.

pub fn connected_website<H, F>(&mut self, handler: H)

where H: Fn(Arc<ConnectedWebsite>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for connected websites.

pub fn connected_website_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<ConnectedWebsite>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<ConnectedWebsite>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for connected websites which is run if the predicate returns true.

pub fn created_group<H, F>(&mut self, handler: H)

where H: Fn(Arc<CreatedGroup>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for created groups.

pub fn created_group_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<CreatedGroup>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<CreatedGroup>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for created groups which is run if the predicate returns true.

pub fn data_callback<H, F>(&mut self, handler: H)

where H: Fn(Arc<DataCallback>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for data callbacks.

pub fn data_callback_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<DataCallback>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<DataCallback>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for data callbacks which is run if the predicate returns true.

pub fn deleted_chat_photo<H, F>(&mut self, handler: H)

where H: Fn(Arc<DeletedChatPhoto>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for deleted chat photos.

pub fn deleted_chat_photo_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<DeletedChatPhoto>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<DeletedChatPhoto>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for deleted chat photos which is run if the predicate returns true.

pub fn dice<H, F>(&mut self, handler: H)

where H: Fn(Arc<Dice>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for dice.

pub fn dice_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Dice>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Dice>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for dice which is run if the predicate returns true.

pub fn document<H, F>(&mut self, handler: H)

where H: Fn(Arc<Document>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for documents.

pub fn document_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Document>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Document>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for documents which is run if the predicate returns true.

pub fn edited_animation<H, F>(&mut self, handler: H)

where H: Fn(Arc<EditedAnimation>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for edited animations.

pub fn edited_animation_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<EditedAnimation>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<EditedAnimation>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for edited animations which is run if the predicate returns true.

pub fn edited_audio<H, F>(&mut self, handler: H)

where H: Fn(Arc<EditedAudio>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for edited audio.

pub fn edited_audio_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<EditedAudio>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<EditedAudio>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for edited audio which is run if the predicate returns true.

pub fn edited_document<H, F>(&mut self, handler: H)

where H: Fn(Arc<EditedDocument>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for edited documents.

pub fn edited_document_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<EditedDocument>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<EditedDocument>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for edited documents which is run if the predicate returns true.

pub fn edited_location<H, F>(&mut self, handler: H)

where H: Fn(Arc<EditedLocation>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for edited locations.

pub fn edited_location_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<EditedLocation>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<EditedLocation>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for edited locations which is run if the predicate returns true.

pub fn edited_photo<H, F>(&mut self, handler: H)

where H: Fn(Arc<EditedPhoto>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for edited photos.

pub fn edited_photo_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<EditedPhoto>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<EditedPhoto>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for edited photos which is run if the predicate returns true.

pub fn edited_text<H, F>(&mut self, handler: H)

where H: Fn(Arc<EditedText>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for edited text messages.

pub fn edited_text_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<EditedText>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<EditedText>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for edited text messages which is run if the predicate returns true.

pub fn edited_video<H, F>(&mut self, handler: H)

where H: Fn(Arc<EditedVideo>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for edited videos.

pub fn edited_video_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<EditedVideo>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<EditedVideo>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for edited videos which is run if the predicate returns true.

pub fn game_callback<H, F>(&mut self, handler: H)

where H: Fn(Arc<GameCallback>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for game callbacks.

pub fn game_callback_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<GameCallback>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<GameCallback>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for game callbacks which is run if the predicate returns true.

pub fn game<H, F>(&mut self, handler: H)

where H: Fn(Arc<Game>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for game messages.

pub fn game_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Game>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Game>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for game messages which is run if the predicate returns true.

pub fn inline<H, F>(&mut self, handler: H)

where H: Fn(Arc<Inline>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for inline queries.

pub fn inline_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Inline>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Inline>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for inline queries which is run if the predicate returns true.

pub fn invoice<H, F>(&mut self, handler: H)

where H: Fn(Arc<Invoice>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for invoices.

pub fn invoice_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Invoice>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Invoice>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for invoices which is run if the predicate returns true.

pub fn left_member<H, F>(&mut self, handler: H)

where H: Fn(Arc<LeftMember>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for left members.

pub fn left_member_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<LeftMember>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<LeftMember>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for left members which is run if the predicate returns true.

pub fn location<H, F>(&mut self, handler: H)

where H: Fn(Arc<Location>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for locations.

pub fn location_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Location>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Location>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for locations which is run if the predicate returns true.

pub fn migration<H, F>(&mut self, handler: H)

where H: Fn(Arc<Migration>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for migrations.

pub fn migration_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Migration>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Migration>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for migrations which is run if the predicate returns true.

pub fn new_chat_photo<H, F>(&mut self, handler: H)

where H: Fn(Arc<NewChatPhoto>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for new chat photos.

pub fn new_chat_photo_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<NewChatPhoto>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<NewChatPhoto>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for new chat photos which is run if the predicate returns true.

pub fn new_chat_title<H, F>(&mut self, handler: H)

where H: Fn(Arc<NewChatTitle>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for new chat titles.

pub fn new_chat_title_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<NewChatTitle>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<NewChatTitle>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for new chat titles which is run if the predicate returns true.

pub fn new_members<H, F>(&mut self, handler: H)

where H: Fn(Arc<NewMembers>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for new members.

pub fn new_members_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<NewMembers>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<NewMembers>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for new members which is run if the predicate returns true.

pub fn passport<H, F>(&mut self, handler: H)

where H: Fn(Arc<Passport>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for passport data.

pub fn passport_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Passport>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Passport>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for passport data which is run if the predicate returns true.

pub fn payment<H, F>(&mut self, handler: H)

where H: Fn(Arc<Payment>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for successful payments.

pub fn payment_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Payment>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Payment>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for successful payments which is run if the predicate returns true.

pub fn photo<H, F>(&mut self, handler: H)

where H: Fn(Arc<Photo>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for photos.

pub fn photo_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Photo>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Photo>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for photos which is run if the predicate returns true.

pub fn pinned_message<H, F>(&mut self, handler: H)

where H: Fn(Arc<PinnedMessage>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for pinned messages.

pub fn pinned_message_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<PinnedMessage>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<PinnedMessage>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for pinned messages which is run if the predicate returns true.

pub fn poll<H, F>(&mut self, handler: H)

where H: Fn(Arc<Poll>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for poll messages.

pub fn poll_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Poll>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Poll>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for poll messages which is run if the predicate returns true.1

pub fn pre_checkout<H, F>(&mut self, handler: H)

where H: Fn(Arc<PreCheckout>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for pre-checkout queries.

pub fn pre_checkout_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<PreCheckout>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<PreCheckout>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for pre-checkout queries which is run if the predicate returns true.

pub fn shipping<H, F>(&mut self, handler: H)

where H: Fn(Arc<Shipping>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for shipping queries.

pub fn shipping_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Shipping>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Shipping>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for shipping queries which is run if the predicate returns true.

pub fn sticker<H, F>(&mut self, handler: H)

where H: Fn(Arc<Sticker>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for stickers.

pub fn sticker_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Sticker>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Sticker>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for stickers which is run if the predicate returns true.

pub fn text<H, F>(&mut self, handler: H)

where H: Fn(Arc<Text>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for text messages.

pub fn text_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Text>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Text>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for text messages which is run if the predicate returns true.

pub fn unhandled<H, F>(&mut self, handler: H)

where H: Fn(Arc<Unhandled>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for unhandled updates.

pub fn unhandled_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Unhandled>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Unhandled>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for unhandled updates which is run if the predicate returns true.

pub fn updated_poll<H, F>(&mut self, handler: H)

where H: Fn(Arc<UpdatedPoll>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for new states of polls.

pub fn updated_poll_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<UpdatedPoll>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<UpdatedPoll>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for new states of polls which is run if the predicate returns true.

pub fn poll_answer<H, F>(&mut self, handler: H)

where H: Fn(Arc<PollAnswer>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for new answers in the poll.

pub fn poll_answer_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<PollAnswer>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<PollAnswer>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for new answers in the poll which is run if the predicate returns true.

pub fn venue<H, F>(&mut self, handler: H)

where H: Fn(Arc<Venue>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for venues.

pub fn venue_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Venue>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Venue>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for venues which is run if the predicate returns true.

pub fn video<H, F>(&mut self, handler: H)

where H: Fn(Arc<Video>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for videos.

pub fn video_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Video>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Video>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for videos which is run if the predicate returns true.

pub fn video_note<H, F>(&mut self, handler: H)

where H: Fn(Arc<VideoNote>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for video notes.

pub fn video_note_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<VideoNote>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<VideoNote>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for video notes which is run if the predicate returns true.

pub fn voice<H, F>(&mut self, handler: H)

where H: Fn(Arc<Voice>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

Adds a new handler for voice messages.

pub fn voice_if<H, HF, P, PF>(&mut self, predicate: P, handler: H)

where H: Fn(Arc<Voice>) -> HF + Send + Sync + 'static, HF: Future<Output = ()> + Send + 'static, P: Fn(Arc<Voice>) -> PF + Send + Sync + 'static, PF: Future<Output = bool> + Send + 'static,

Adds a new handler for voice messages which is run if the predicate returns true.

pub async fn fetch_username(&mut self) -> Result<(), MethodCall>

Fetches the bot’s username.

The username is used when checking if a command such as /command@username was directed to the bot.