Struct teloxide_core::Bot

pub struct Bot { /* private fields */ }

A requests sender.

This is the main type of the library, it allows to send requests to the Telegram Bot API and download files.

TBA methods

All TBA methods are located in the Requester impl for Bot. This allows for opt-in behaviours using requester adaptors.

use teloxide_core::prelude::*;

let bot = Bot::new("TOKEN");
dbg!(bot.get_me().await?);

File download

In the similar way as with TBA methods, file downloading methods are located in a trait — Download<'_>. See its documentation for more.

Clone cost

Bot::clone is relatively cheap, so if you need to share Bot, it’s recommended to clone it, instead of wrapping it in Arc<_>.

Implementations

impl Bot

Constructors

pub fn new<S>(token: S) -> Self

where S: Into<String>,

Creates a new Bot with the specified token and the default http-client.

Panics

If it cannot create reqwest::Client.

pub fn with_client<S>(token: S, client: Client) -> Self

where S: Into<String>,

Creates a new Bot with the specified token and your reqwest::Client.

Caution

Your custom client might not be configured correctly to be able to work in long time durations, see issue 223.

pub fn from_env() -> Self

Creates a new Bot with the TELOXIDE_TOKEN & TELOXIDE_PROXY environmental variables (a bot’s token & a proxy) and the default reqwest::Client.

This function passes the value of TELOXIDE_PROXY into reqwest::Proxy::all, if it exists, otherwise returns the default client.

Panics

• If cannot get the TELOXIDE_TOKEN environmental variable.
• If it cannot create reqwest::Client.

Examples found in repository

examples/self_info.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    pretty_env_logger::init();

    let chat_id =
        ChatId(std::env::var("CHAT_ID").expect("Expected CHAT_ID env var").parse::<i64>()?);

    let bot = Bot::from_env().parse_mode(ParseMode::MarkdownV2);

    let Me { user: me, .. } = bot.get_me().await?;

    bot.send_dice(chat_id).emoji(DiceEmoji::Dice).await?;
    bot.send_message(chat_id, format!("Hi, my name is **{}** 👋", me.first_name)).await?;

    Ok(())
}

examples/erased.rs (line 32)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    pretty_env_logger::init();

    let chat_id =
        ChatId(std::env::var("CHAT_ID").expect("Expected CHAT_ID env var").parse::<i64>()?);

    let trace_settings = match std::env::var("TRACE").as_deref() {
        Ok("EVERYTHING_VERBOSE") => trace::Settings::TRACE_EVERYTHING_VERBOSE,
        Ok("EVERYTHING") => trace::Settings::TRACE_EVERYTHING,
        Ok("REQUESTS_VERBOSE") => trace::Settings::TRACE_REQUESTS_VERBOSE,
        Ok("REQUESTS") => trace::Settings::TRACE_REQUESTS,
        Ok("RESPONSES_VERBOSE") => trace::Settings::TRACE_RESPONSES_VERBOSE,
        Ok("RESPONSES") => trace::Settings::TRACE_RESPONSES,
        Ok("EMPTY") | Ok("") | Err(VarError::NotPresent) => trace::Settings::empty(),
        Ok(_) | Err(VarError::NotUnicode(_)) => {
            panic!(
                "Expected `TRACE` environment variable to be equal to any of the following: \
                 `EVERYTHING_VERBOSE`, `EVERYTHING`, `REQUESTS_VERBOSE`, `REQUESTS`, \
                 `RESPONSES_VERBOSE`, `RESPONSES`, `EMPTY`, `` (empty string)"
            )
        }
    };

    log::info!("Trace settings: {:?}", trace_settings);

    let bot = if trace_settings.is_empty() {
        Bot::from_env().erase()
    } else {
        Bot::from_env().trace(trace_settings).erase()
    };

    bot.send_chat_action(chat_id, ChatAction::Typing).await?;
    tokio::time::sleep(Duration::from_secs(1)).await;
    bot.send_message(chat_id, "Hey hey hey").await?;

    Ok(())
}

pub fn from_env_with_client(client: Client) -> Self

Creates a new Bot with the TELOXIDE_TOKEN environmental variable (a bot’s token) and your reqwest::Client.

Panics

If cannot get the TELOXIDE_TOKEN environmental variable.

Caution

Your custom client might not be configured correctly to be able to work in long time durations, see issue 223.

pub fn set_api_url(self, url: Url) -> Self

Sets a custom API URL.

For example, you can run your own Telegram bot API server and set its URL using this method.

Examples

use teloxide_core::{
    requests::{Request, Requester},
    Bot,
};

let url = reqwest::Url::parse("https://localhost/tbas").unwrap();
let bot = Bot::new("TOKEN").set_api_url(url);
// From now all methods will use "https://localhost/tbas" as an API URL.
bot.get_me().await

Multi-instance behaviour

This method only sets the url for one bot instace, older clones are unaffected.

use teloxide_core::Bot;

let bot = Bot::new("TOKEN");
let bot2 = bot.clone();
let bot = bot.set_api_url(reqwest::Url::parse("https://example.com/").unwrap());

assert_eq!(bot.api_url().as_str(), "https://example.com/");
assert_eq!(bot.clone().api_url().as_str(), "https://example.com/");
assert_ne!(bot2.api_url().as_str(), "https://example.com/");

impl Bot

Getters

pub fn token(&self) -> &str

Returns currently used token.

pub fn client(&self) -> &Client

Returns currently used http-client.

pub fn api_url(&self) -> Url

Returns currently used token API url.

Trait Implementations

impl Clone for Bot

fn clone(&self) -> Bot

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Bot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Download for Bot

type Err<'dst> = DownloadError

An error returned from download_file.

type Fut<'dst> = Pin<Box<dyn Future<Output = Result<(), DownloadError>> + Send + 'dst>>

A future returned from download_file.

fn download_file<'dst>( &self, path: &str, destination: &'dst mut (dyn AsyncWrite + Unpin + Send), ) -> Self::Fut<'dst>

Download a file from Telegram into destination.

type StreamErr = Error

An error returned from download_file_stream.

type Stream = Pin<Box<dyn Stream<Item = Result<Bytes, Error>> + Send>>

A stream returned from download_file_stream.

fn download_file_stream(&self, path: &str) -> Self::Stream

Download a file from Telegram as Stream.

impl Requester for Bot

type Err = RequestError

Error type returned by all requests.

type GetUpdates = JsonRequest<GetUpdates>

fn get_updates(&self) -> Self::GetUpdates

For Telegram documentation see GetUpdates.

type SetWebhook = MultipartRequest<SetWebhook>

fn set_webhook(&self, url: Url) -> Self::SetWebhook

For Telegram documentation see SetWebhook.

type DeleteWebhook = JsonRequest<DeleteWebhook>

fn delete_webhook(&self) -> Self::DeleteWebhook

For Telegram documentation see DeleteWebhook.

type GetWebhookInfo = JsonRequest<GetWebhookInfo>

fn get_webhook_info(&self) -> Self::GetWebhookInfo

For Telegram documentation see GetWebhookInfo.

type GetMe = JsonRequest<GetMe>

fn get_me(&self) -> Self::GetMe

For Telegram documentation see GetMe.

type SendMessage = JsonRequest<SendMessage>

fn send_message<C, T>(&self, chat_id: C, text: T) -> Self::SendMessage

where C: Into<Recipient>, T: Into<String>,

For Telegram documentation see SendMessage.

type ForwardMessage = JsonRequest<ForwardMessage>

fn forward_message<C, F>( &self, chat_id: C, from_chat_id: F, message_id: MessageId, ) -> Self::ForwardMessage

where C: Into<Recipient>, F: Into<Recipient>,

For Telegram documentation see ForwardMessage.

type ForwardMessages = JsonRequest<ForwardMessages>

fn forward_messages<C, F, M>( &self, chat_id: C, from_chat_id: F, message_ids: M, ) -> Self::ForwardMessages

where C: Into<Recipient>, F: Into<Recipient>, M: IntoIterator<Item = MessageId>,

For Telegram documentation see ForwardMessages.

type SendPhoto = MultipartRequest<SendPhoto>

fn send_photo<C>(&self, chat_id: C, photo: InputFile) -> Self::SendPhoto

where C: Into<Recipient>,

For Telegram documentation see SendPhoto.

type SendAudio = MultipartRequest<SendAudio>

fn send_audio<C>(&self, chat_id: C, audio: InputFile) -> Self::SendAudio

where C: Into<Recipient>,

For Telegram documentation see SendAudio.

type SendDocument = MultipartRequest<SendDocument>

fn send_document<C>( &self, chat_id: C, document: InputFile, ) -> Self::SendDocument

where C: Into<Recipient>,

For Telegram documentation see SendDocument.

type SendVideo = MultipartRequest<SendVideo>

fn send_video<C>(&self, chat_id: C, video: InputFile) -> Self::SendVideo

where C: Into<Recipient>,

For Telegram documentation see SendVideo.

type SendAnimation = MultipartRequest<SendAnimation>

fn send_animation<C>( &self, chat_id: C, animation: InputFile, ) -> Self::SendAnimation

where C: Into<Recipient>,

For Telegram documentation see SendAnimation.

type SendVoice = MultipartRequest<SendVoice>

fn send_voice<C>(&self, chat_id: C, voice: InputFile) -> Self::SendVoice

where C: Into<Recipient>,

For Telegram documentation see SendVoice.

type SendVideoNote = MultipartRequest<SendVideoNote>

fn send_video_note<C>( &self, chat_id: C, video_note: InputFile, ) -> Self::SendVideoNote

where C: Into<Recipient>,

For Telegram documentation see SendVideoNote.

type SendMediaGroup = MultipartRequest<SendMediaGroup>

fn send_media_group<C, M>(&self, chat_id: C, media: M) -> Self::SendMediaGroup

where C: Into<Recipient>, M: IntoIterator<Item = InputMedia>,

For Telegram documentation see SendMediaGroup.

type SendLocation = JsonRequest<SendLocation>

fn send_location<C>( &self, chat_id: C, latitude: f64, longitude: f64, ) -> Self::SendLocation

where C: Into<Recipient>,

For Telegram documentation see SendLocation.

type EditMessageLiveLocation = JsonRequest<EditMessageLiveLocation>

fn edit_message_live_location<C>( &self, chat_id: C, message_id: MessageId, latitude: f64, longitude: f64, ) -> Self::EditMessageLiveLocation

where C: Into<Recipient>,

For Telegram documentation see EditMessageLiveLocation.

type EditMessageLiveLocationInline = JsonRequest<EditMessageLiveLocationInline>

fn edit_message_live_location_inline<I>( &self, inline_message_id: I, latitude: f64, longitude: f64, ) -> Self::EditMessageLiveLocationInline

where I: Into<String>,

For Telegram documentation see EditMessageLiveLocationInline.

type StopMessageLiveLocation = JsonRequest<StopMessageLiveLocation>

fn stop_message_live_location<C>( &self, chat_id: C, message_id: MessageId, ) -> Self::StopMessageLiveLocation

where C: Into<Recipient>,

For Telegram documentation see StopMessageLiveLocation.

type StopMessageLiveLocationInline = JsonRequest<StopMessageLiveLocationInline>

fn stop_message_live_location_inline<I>( &self, inline_message_id: I, ) -> Self::StopMessageLiveLocationInline

where I: Into<String>,

For Telegram documentation see StopMessageLiveLocationInline.

type SendVenue = JsonRequest<SendVenue>

fn send_venue<C, T, A>( &self, chat_id: C, latitude: f64, longitude: f64, title: T, address: A, ) -> Self::SendVenue

where C: Into<Recipient>, T: Into<String>, A: Into<String>,

For Telegram documentation see SendVenue.

type SendContact = JsonRequest<SendContact>

fn send_contact<C, P, F>( &self, chat_id: C, phone_number: P, first_name: F, ) -> Self::SendContact

where C: Into<Recipient>, P: Into<String>, F: Into<String>,

For Telegram documentation see SendContact.

type SendPoll = JsonRequest<SendPoll>

fn send_poll<C, Q, O>( &self, chat_id: C, question: Q, options: O, ) -> Self::SendPoll

where C: Into<Recipient>, Q: Into<String>, O: IntoIterator<Item = String>,

For Telegram documentation see SendPoll.

type SendDice = JsonRequest<SendDice>

fn send_dice<C>(&self, chat_id: C) -> Self::SendDice

where C: Into<Recipient>,

For Telegram documentation see SendDice.

type SendChatAction = JsonRequest<SendChatAction>

fn send_chat_action<C>( &self, chat_id: C, action: ChatAction, ) -> Self::SendChatAction

where C: Into<Recipient>,

For Telegram documentation see SendChatAction.

type SetMessageReaction = JsonRequest<SetMessageReaction>

fn set_message_reaction<C>( &self, chat_id: C, message_id: MessageId, ) -> Self::SetMessageReaction

where C: Into<Recipient>,

For Telegram documentation see SetMessageReaction.

type GetUserProfilePhotos = JsonRequest<GetUserProfilePhotos>

fn get_user_profile_photos(&self, user_id: UserId) -> Self::GetUserProfilePhotos

For Telegram documentation see GetUserProfilePhotos.

type GetFile = JsonRequest<GetFile>

fn get_file<F>(&self, file_id: F) -> Self::GetFile

where F: Into<String>,

For Telegram documentation see GetFile.

type KickChatMember = JsonRequest<KickChatMember>

fn kick_chat_member<C>( &self, chat_id: C, user_id: UserId, ) -> Self::KickChatMember

where C: Into<Recipient>,

For Telegram documentation see KickChatMember.

type BanChatMember = JsonRequest<BanChatMember>

fn ban_chat_member<C>(&self, chat_id: C, user_id: UserId) -> Self::BanChatMember

where C: Into<Recipient>,

For Telegram documentation see BanChatMember.

type UnbanChatMember = JsonRequest<UnbanChatMember>

fn unban_chat_member<C>( &self, chat_id: C, user_id: UserId, ) -> Self::UnbanChatMember

where C: Into<Recipient>,

For Telegram documentation see UnbanChatMember.

type RestrictChatMember = JsonRequest<RestrictChatMember>

fn restrict_chat_member<C>( &self, chat_id: C, user_id: UserId, permissions: ChatPermissions, ) -> Self::RestrictChatMember

where C: Into<Recipient>,

For Telegram documentation see RestrictChatMember.

type PromoteChatMember = JsonRequest<PromoteChatMember>

fn promote_chat_member<C>( &self, chat_id: C, user_id: UserId, ) -> Self::PromoteChatMember

where C: Into<Recipient>,

For Telegram documentation see PromoteChatMember.

type SetChatAdministratorCustomTitle = JsonRequest<SetChatAdministratorCustomTitle>

fn set_chat_administrator_custom_title<Ch, Cu>( &self, chat_id: Ch, user_id: UserId, custom_title: Cu, ) -> Self::SetChatAdministratorCustomTitle

where Ch: Into<Recipient>, Cu: Into<String>,

For Telegram documentation see SetChatAdministratorCustomTitle.

type BanChatSenderChat = JsonRequest<BanChatSenderChat>

fn ban_chat_sender_chat<C, S>( &self, chat_id: C, sender_chat_id: S, ) -> Self::BanChatSenderChat

where C: Into<Recipient>, S: Into<ChatId>,

For Telegram documentation see BanChatSenderChat.

type UnbanChatSenderChat = JsonRequest<UnbanChatSenderChat>

fn unban_chat_sender_chat<C, S>( &self, chat_id: C, sender_chat_id: S, ) -> Self::UnbanChatSenderChat

where C: Into<Recipient>, S: Into<ChatId>,

For Telegram documentation see UnbanChatSenderChat.

type SetChatPermissions = JsonRequest<SetChatPermissions>

fn set_chat_permissions<C>( &self, chat_id: C, permissions: ChatPermissions, ) -> Self::SetChatPermissions

where C: Into<Recipient>,

For Telegram documentation see SetChatPermissions.

type ExportChatInviteLink = JsonRequest<ExportChatInviteLink>

fn export_chat_invite_link<C>(&self, chat_id: C) -> Self::ExportChatInviteLink

where C: Into<Recipient>,

For Telegram documentation see ExportChatInviteLink.

type CreateChatInviteLink = JsonRequest<CreateChatInviteLink>

fn create_chat_invite_link<C>(&self, chat_id: C) -> Self::CreateChatInviteLink

where C: Into<Recipient>,

For Telegram documentation see CreateChatInviteLink.

type EditChatInviteLink = JsonRequest<EditChatInviteLink>

fn edit_chat_invite_link<C, I>( &self, chat_id: C, invite_link: I, ) -> Self::EditChatInviteLink

where C: Into<Recipient>, I: Into<String>,

For Telegram documentation see EditChatInviteLink.

type RevokeChatInviteLink = JsonRequest<RevokeChatInviteLink>

fn revoke_chat_invite_link<C, I>( &self, chat_id: C, invite_link: I, ) -> Self::RevokeChatInviteLink

where C: Into<Recipient>, I: Into<String>,

For Telegram documentation see RevokeChatInviteLink.

type ApproveChatJoinRequest = JsonRequest<ApproveChatJoinRequest>

fn approve_chat_join_request<C>( &self, chat_id: C, user_id: UserId, ) -> Self::ApproveChatJoinRequest

where C: Into<Recipient>,

For Telegram documentation see ApproveChatJoinRequest.

type DeclineChatJoinRequest = JsonRequest<DeclineChatJoinRequest>

fn decline_chat_join_request<C>( &self, chat_id: C, user_id: UserId, ) -> Self::DeclineChatJoinRequest

where C: Into<Recipient>,

For Telegram documentation see DeclineChatJoinRequest.

type SetChatPhoto = MultipartRequest<SetChatPhoto>

fn set_chat_photo<C>(&self, chat_id: C, photo: InputFile) -> Self::SetChatPhoto

where C: Into<Recipient>,

For Telegram documentation see SetChatPhoto.

type DeleteChatPhoto = JsonRequest<DeleteChatPhoto>

fn delete_chat_photo<C>(&self, chat_id: C) -> Self::DeleteChatPhoto

where C: Into<Recipient>,

For Telegram documentation see DeleteChatPhoto.

type SetChatTitle = JsonRequest<SetChatTitle>

fn set_chat_title<C, T>(&self, chat_id: C, title: T) -> Self::SetChatTitle

where C: Into<Recipient>, T: Into<String>,

For Telegram documentation see SetChatTitle.

type SetChatDescription = JsonRequest<SetChatDescription>

fn set_chat_description<C>(&self, chat_id: C) -> Self::SetChatDescription

where C: Into<Recipient>,

For Telegram documentation see SetChatDescription.

type PinChatMessage = JsonRequest<PinChatMessage>

fn pin_chat_message<C>( &self, chat_id: C, message_id: MessageId, ) -> Self::PinChatMessage

where C: Into<Recipient>,

For Telegram documentation see PinChatMessage.

type UnpinChatMessage = JsonRequest<UnpinChatMessage>

fn unpin_chat_message<C>(&self, chat_id: C) -> Self::UnpinChatMessage

where C: Into<Recipient>,

For Telegram documentation see UnpinChatMessage.

type LeaveChat = JsonRequest<LeaveChat>

fn leave_chat<C>(&self, chat_id: C) -> Self::LeaveChat

where C: Into<Recipient>,

For Telegram documentation see LeaveChat.

type GetChat = JsonRequest<GetChat>

fn get_chat<C>(&self, chat_id: C) -> Self::GetChat

where C: Into<Recipient>,

For Telegram documentation see GetChat.

type GetChatAdministrators = JsonRequest<GetChatAdministrators>

fn get_chat_administrators<C>(&self, chat_id: C) -> Self::GetChatAdministrators

where C: Into<Recipient>,

For Telegram documentation see GetChatAdministrators.

type GetChatMembersCount = JsonRequest<GetChatMembersCount>

fn get_chat_members_count<C>(&self, chat_id: C) -> Self::GetChatMembersCount

where C: Into<Recipient>,

For Telegram documentation see GetChatMembersCount.

type GetChatMemberCount = JsonRequest<GetChatMemberCount>

fn get_chat_member_count<C>(&self, chat_id: C) -> Self::GetChatMemberCount

where C: Into<Recipient>,

For Telegram documentation see GetChatMemberCount.

type GetChatMember = JsonRequest<GetChatMember>

fn get_chat_member<C>(&self, chat_id: C, user_id: UserId) -> Self::GetChatMember

where C: Into<Recipient>,

For Telegram documentation see GetChatMember.

type SetChatStickerSet = JsonRequest<SetChatStickerSet>

fn set_chat_sticker_set<C, S>( &self, chat_id: C, sticker_set_name: S, ) -> Self::SetChatStickerSet

where C: Into<Recipient>, S: Into<String>,

For Telegram documentation see SetChatStickerSet.

type DeleteChatStickerSet = JsonRequest<DeleteChatStickerSet>

fn delete_chat_sticker_set<C>(&self, chat_id: C) -> Self::DeleteChatStickerSet

where C: Into<Recipient>,

For Telegram documentation see DeleteChatStickerSet.

type GetForumTopicIconStickers = JsonRequest<GetForumTopicIconStickers>

fn get_forum_topic_icon_stickers(&self) -> Self::GetForumTopicIconStickers

For Telegram documentation see GetForumTopicIconStickers.

type CreateForumTopic = JsonRequest<CreateForumTopic>

fn create_forum_topic<C, N, I>( &self, chat_id: C, name: N, icon_color: u32, icon_custom_emoji_id: I, ) -> Self::CreateForumTopic

where C: Into<Recipient>, N: Into<String>, I: Into<String>,

For Telegram documentation see CreateForumTopic.

type EditForumTopic = JsonRequest<EditForumTopic>

fn edit_forum_topic<C>( &self, chat_id: C, message_thread_id: ThreadId, ) -> Self::EditForumTopic

where C: Into<Recipient>,

For Telegram documentation see EditForumTopic.

type CloseForumTopic = JsonRequest<CloseForumTopic>

fn close_forum_topic<C>( &self, chat_id: C, message_thread_id: ThreadId, ) -> Self::CloseForumTopic

where C: Into<Recipient>,

For Telegram documentation see CloseForumTopic.

type ReopenForumTopic = JsonRequest<ReopenForumTopic>

fn reopen_forum_topic<C>( &self, chat_id: C, message_thread_id: ThreadId, ) -> Self::ReopenForumTopic

where C: Into<Recipient>,

For Telegram documentation see ReopenForumTopic.

type DeleteForumTopic = JsonRequest<DeleteForumTopic>

fn delete_forum_topic<C>( &self, chat_id: C, message_thread_id: ThreadId, ) -> Self::DeleteForumTopic

where C: Into<Recipient>,

For Telegram documentation see DeleteForumTopic.

type UnpinAllForumTopicMessages = JsonRequest<UnpinAllForumTopicMessages>

fn unpin_all_forum_topic_messages<C>( &self, chat_id: C, message_thread_id: ThreadId, ) -> Self::UnpinAllForumTopicMessages

where C: Into<Recipient>,

For Telegram documentation see UnpinAllForumTopicMessages.

type EditGeneralForumTopic = JsonRequest<EditGeneralForumTopic>

fn edit_general_forum_topic<C, N>( &self, chat_id: C, name: N, ) -> Self::EditGeneralForumTopic

where C: Into<Recipient>, N: Into<String>,

For Telegram documentation see EditGeneralForumTopic.

type CloseGeneralForumTopic = JsonRequest<CloseGeneralForumTopic>

fn close_general_forum_topic<C>( &self, chat_id: C, ) -> Self::CloseGeneralForumTopic

where C: Into<Recipient>,

For Telegram documentation see CloseGeneralForumTopic.

type ReopenGeneralForumTopic = JsonRequest<ReopenGeneralForumTopic>

fn reopen_general_forum_topic<C>( &self, chat_id: C, ) -> Self::ReopenGeneralForumTopic

where C: Into<Recipient>,

For Telegram documentation see ReopenGeneralForumTopic.

type HideGeneralForumTopic = JsonRequest<HideGeneralForumTopic>

fn hide_general_forum_topic<C>(&self, chat_id: C) -> Self::HideGeneralForumTopic

where C: Into<Recipient>,

For Telegram documentation see HideGeneralForumTopic.

type UnhideGeneralForumTopic = JsonRequest<UnhideGeneralForumTopic>

fn unhide_general_forum_topic<C>( &self, chat_id: C, ) -> Self::UnhideGeneralForumTopic

where C: Into<Recipient>,

For Telegram documentation see UnhideGeneralForumTopic.

type UnpinAllGeneralForumTopicMessages = JsonRequest<UnpinAllGeneralForumTopicMessages>

fn unpin_all_general_forum_topic_messages<C>( &self, chat_id: C, ) -> Self::UnpinAllGeneralForumTopicMessages

where C: Into<Recipient>,

For Telegram documentation see UnpinAllGeneralForumTopicMessages.

type AnswerCallbackQuery = JsonRequest<AnswerCallbackQuery>

fn answer_callback_query<C>( &self, callback_query_id: C, ) -> Self::AnswerCallbackQuery

where C: Into<String>,

For Telegram documentation see AnswerCallbackQuery.

type GetUserChatBoosts = JsonRequest<GetUserChatBoosts>

fn get_user_chat_boosts<C>( &self, chat_id: C, user_id: UserId, ) -> Self::GetUserChatBoosts

where C: Into<Recipient>,

For Telegram documentation see GetUserChatBoosts.

type SetMyCommands = JsonRequest<SetMyCommands>

fn set_my_commands<C>(&self, commands: C) -> Self::SetMyCommands

where C: IntoIterator<Item = BotCommand>,

For Telegram documentation see SetMyCommands.

type GetMyCommands = JsonRequest<GetMyCommands>

fn get_my_commands(&self) -> Self::GetMyCommands

For Telegram documentation see GetMyCommands.

type SetMyName = JsonRequest<SetMyName>

fn set_my_name(&self) -> Self::SetMyName

For Telegram documentation see SetMyName.

type GetMyName = JsonRequest<GetMyName>

fn get_my_name(&self) -> Self::GetMyName

For Telegram documentation see GetMyName.

type SetMyDescription = JsonRequest<SetMyDescription>

fn set_my_description(&self) -> Self::SetMyDescription

For Telegram documentation see SetMyDescription.

type GetMyDescription = JsonRequest<GetMyDescription>

fn get_my_description(&self) -> Self::GetMyDescription

For Telegram documentation see GetMyDescription.

type SetMyShortDescription = JsonRequest<SetMyShortDescription>

fn set_my_short_description(&self) -> Self::SetMyShortDescription

For Telegram documentation see SetMyShortDescription.

type GetMyShortDescription = JsonRequest<GetMyShortDescription>

fn get_my_short_description(&self) -> Self::GetMyShortDescription

For Telegram documentation see GetMyShortDescription.

type SetChatMenuButton = JsonRequest<SetChatMenuButton>

fn set_chat_menu_button(&self) -> Self::SetChatMenuButton

For Telegram documentation see SetChatMenuButton.

type GetChatMenuButton = JsonRequest<GetChatMenuButton>

fn get_chat_menu_button(&self) -> Self::GetChatMenuButton

For Telegram documentation see GetChatMenuButton.

type SetMyDefaultAdministratorRights = JsonRequest<SetMyDefaultAdministratorRights>

fn set_my_default_administrator_rights( &self, ) -> Self::SetMyDefaultAdministratorRights

For Telegram documentation see SetMyDefaultAdministratorRights.

type GetMyDefaultAdministratorRights = JsonRequest<GetMyDefaultAdministratorRights>

fn get_my_default_administrator_rights( &self, ) -> Self::GetMyDefaultAdministratorRights

For Telegram documentation see GetMyDefaultAdministratorRights.

type DeleteMyCommands = JsonRequest<DeleteMyCommands>

fn delete_my_commands(&self) -> Self::DeleteMyCommands

For Telegram documentation see DeleteMyCommands.

type AnswerInlineQuery = JsonRequest<AnswerInlineQuery>

fn answer_inline_query<I, R>( &self, inline_query_id: I, results: R, ) -> Self::AnswerInlineQuery

where I: Into<String>, R: IntoIterator<Item = InlineQueryResult>,

For Telegram documentation see AnswerInlineQuery.

type AnswerWebAppQuery = JsonRequest<AnswerWebAppQuery>

fn answer_web_app_query<W>( &self, web_app_query_id: W, result: InlineQueryResult, ) -> Self::AnswerWebAppQuery

where W: Into<String>,

For Telegram documentation see AnswerWebAppQuery.

type EditMessageText = JsonRequest<EditMessageText>

fn edit_message_text<C, T>( &self, chat_id: C, message_id: MessageId, text: T, ) -> Self::EditMessageText

where C: Into<Recipient>, T: Into<String>,

For Telegram documentation see EditMessageText.

type EditMessageTextInline = JsonRequest<EditMessageTextInline>

fn edit_message_text_inline<I, T>( &self, inline_message_id: I, text: T, ) -> Self::EditMessageTextInline

where I: Into<String>, T: Into<String>,

For Telegram documentation see EditMessageTextInline.

type EditMessageCaption = JsonRequest<EditMessageCaption>

fn edit_message_caption<C>( &self, chat_id: C, message_id: MessageId, ) -> Self::EditMessageCaption

where C: Into<Recipient>,

For Telegram documentation see EditMessageCaption.

type EditMessageCaptionInline = JsonRequest<EditMessageCaptionInline>

fn edit_message_caption_inline<I>( &self, inline_message_id: I, ) -> Self::EditMessageCaptionInline

where I: Into<String>,

For Telegram documentation see EditMessageCaptionInline.

type EditMessageMedia = MultipartRequest<EditMessageMedia>

fn edit_message_media<C>( &self, chat_id: C, message_id: MessageId, media: InputMedia, ) -> Self::EditMessageMedia

where C: Into<Recipient>,

For Telegram documentation see EditMessageMedia.

type EditMessageMediaInline = MultipartRequest<EditMessageMediaInline>

fn edit_message_media_inline<I>( &self, inline_message_id: I, media: InputMedia, ) -> Self::EditMessageMediaInline

where I: Into<String>,

For Telegram documentation see EditMessageMediaInline.

type EditMessageReplyMarkup = JsonRequest<EditMessageReplyMarkup>

fn edit_message_reply_markup<C>( &self, chat_id: C, message_id: MessageId, ) -> Self::EditMessageReplyMarkup

where C: Into<Recipient>,

For Telegram documentation see EditMessageReplyMarkup.

type EditMessageReplyMarkupInline = JsonRequest<EditMessageReplyMarkupInline>

fn edit_message_reply_markup_inline<I>( &self, inline_message_id: I, ) -> Self::EditMessageReplyMarkupInline

where I: Into<String>,

For Telegram documentation see EditMessageReplyMarkupInline.

type StopPoll = JsonRequest<StopPoll>

fn stop_poll<C>(&self, chat_id: C, message_id: MessageId) -> Self::StopPoll

where C: Into<Recipient>,

For Telegram documentation see StopPoll.

type DeleteMessage = JsonRequest<DeleteMessage>

fn delete_message<C>( &self, chat_id: C, message_id: MessageId, ) -> Self::DeleteMessage

where C: Into<Recipient>,

For Telegram documentation see DeleteMessage.

type DeleteMessages = JsonRequest<DeleteMessages>

fn delete_messages<C, M>( &self, chat_id: C, message_ids: M, ) -> Self::DeleteMessages

where C: Into<Recipient>, M: IntoIterator<Item = MessageId>,

For Telegram documentation see DeleteMessages.

type SendSticker = MultipartRequest<SendSticker>

fn send_sticker<C>(&self, chat_id: C, sticker: InputFile) -> Self::SendSticker

where C: Into<Recipient>,

For Telegram documentation see SendSticker.

type GetStickerSet = JsonRequest<GetStickerSet>

fn get_sticker_set<N>(&self, name: N) -> Self::GetStickerSet

where N: Into<String>,

For Telegram documentation see GetStickerSet.

type GetCustomEmojiStickers = JsonRequest<GetCustomEmojiStickers>

fn get_custom_emoji_stickers<C>( &self, custom_emoji_ids: C, ) -> Self::GetCustomEmojiStickers

where C: IntoIterator<Item = String>,

For Telegram documentation see GetCustomEmojiStickers.

type UploadStickerFile = MultipartRequest<UploadStickerFile>

fn upload_sticker_file( &self, user_id: UserId, sticker: InputFile, sticker_format: StickerFormat, ) -> Self::UploadStickerFile

For Telegram documentation see UploadStickerFile.

type CreateNewStickerSet = MultipartRequest<CreateNewStickerSet>

fn create_new_sticker_set<N, T, S>( &self, user_id: UserId, name: N, title: T, stickers: S, sticker_format: StickerFormat, ) -> Self::CreateNewStickerSet

where N: Into<String>, T: Into<String>, S: IntoIterator<Item = InputSticker>,

For Telegram documentation see CreateNewStickerSet.

type AddStickerToSet = MultipartRequest<AddStickerToSet>

fn add_sticker_to_set<N>( &self, user_id: UserId, name: N, sticker: InputSticker, ) -> Self::AddStickerToSet

where N: Into<String>,

For Telegram documentation see AddStickerToSet.

type SetStickerPositionInSet = JsonRequest<SetStickerPositionInSet>

fn set_sticker_position_in_set<S>( &self, sticker: S, position: u32, ) -> Self::SetStickerPositionInSet

where S: Into<String>,

For Telegram documentation see SetStickerPositionInSet.

type DeleteStickerFromSet = JsonRequest<DeleteStickerFromSet>

fn delete_sticker_from_set<S>(&self, sticker: S) -> Self::DeleteStickerFromSet

where S: Into<String>,

For Telegram documentation see DeleteStickerFromSet.

type SetStickerSetThumbnail = MultipartRequest<SetStickerSetThumbnail>

fn set_sticker_set_thumbnail<N>( &self, name: N, user_id: UserId, ) -> Self::SetStickerSetThumbnail

where N: Into<String>,

For Telegram documentation see SetStickerSetThumbnail.

type SetCustomEmojiStickerSetThumbnail = JsonRequest<SetCustomEmojiStickerSetThumbnail>

fn set_custom_emoji_sticker_set_thumbnail<N>( &self, name: N, ) -> Self::SetCustomEmojiStickerSetThumbnail

where N: Into<String>,

For Telegram documentation see SetCustomEmojiStickerSetThumbnail.

type SetStickerSetTitle = JsonRequest<SetStickerSetTitle>

fn set_sticker_set_title<N, T>( &self, name: N, title: T, ) -> Self::SetStickerSetTitle

where N: Into<String>, T: Into<String>,

For Telegram documentation see SetStickerSetTitle.

type DeleteStickerSet = JsonRequest<DeleteStickerSet>

fn delete_sticker_set<N>(&self, name: N) -> Self::DeleteStickerSet

where N: Into<String>,

For Telegram documentation see DeleteStickerSet.

type SetStickerEmojiList = JsonRequest<SetStickerEmojiList>

fn set_sticker_emoji_list<S, E>( &self, sticker: S, emoji_list: E, ) -> Self::SetStickerEmojiList

where S: Into<String>, E: IntoIterator<Item = String>,

For Telegram documentation see SetStickerEmojiList.

type SetStickerKeywords = JsonRequest<SetStickerKeywords>

fn set_sticker_keywords<S>(&self, sticker: S) -> Self::SetStickerKeywords

where S: Into<String>,

For Telegram documentation see SetStickerKeywords.

type SetStickerMaskPosition = JsonRequest<SetStickerMaskPosition>

fn set_sticker_mask_position<S>( &self, sticker: S, ) -> Self::SetStickerMaskPosition

where S: Into<String>,

For Telegram documentation see SetStickerMaskPosition.

type SendInvoice = JsonRequest<SendInvoice>

fn send_invoice<Ch, T, D, Pa, P, C, Pri>( &self, chat_id: Ch, title: T, description: D, payload: Pa, provider_token: P, currency: C, prices: Pri, ) -> Self::SendInvoice

where Ch: Into<Recipient>, T: Into<String>, D: Into<String>, Pa: Into<String>, P: Into<String>, C: Into<String>, Pri: IntoIterator<Item = LabeledPrice>,

For Telegram documentation see SendInvoice.

type CreateInvoiceLink = JsonRequest<CreateInvoiceLink>

fn create_invoice_link<T, D, Pa, P, C, Pri>( &self, title: T, description: D, payload: Pa, provider_token: P, currency: C, prices: Pri, ) -> Self::CreateInvoiceLink

where T: Into<String>, D: Into<String>, Pa: Into<String>, P: Into<String>, C: Into<String>, Pri: IntoIterator<Item = LabeledPrice>,

For Telegram documentation see CreateInvoiceLink.

type AnswerShippingQuery = JsonRequest<AnswerShippingQuery>

fn answer_shipping_query<S>( &self, shipping_query_id: S, ok: bool, ) -> Self::AnswerShippingQuery

where S: Into<String>,

For Telegram documentation see AnswerShippingQuery.

type AnswerPreCheckoutQuery = JsonRequest<AnswerPreCheckoutQuery>

fn answer_pre_checkout_query<P>( &self, pre_checkout_query_id: P, ok: bool, ) -> Self::AnswerPreCheckoutQuery

where P: Into<String>,

For Telegram documentation see AnswerPreCheckoutQuery.

type SetPassportDataErrors = JsonRequest<SetPassportDataErrors>

fn set_passport_data_errors<E>( &self, user_id: UserId, errors: E, ) -> Self::SetPassportDataErrors

where E: IntoIterator<Item = PassportElementError>,

For Telegram documentation see SetPassportDataErrors.

type SendGame = JsonRequest<SendGame>

fn send_game<C, G>(&self, chat_id: C, game_short_name: G) -> Self::SendGame

where C: Into<ChatId>, G: Into<String>,

For Telegram documentation see SendGame.

type SetGameScore = JsonRequest<SetGameScore>

fn set_game_score( &self, user_id: UserId, score: u64, chat_id: u32, message_id: MessageId, ) -> Self::SetGameScore

For Telegram documentation see SetGameScore.

type SetGameScoreInline = JsonRequest<SetGameScoreInline>

fn set_game_score_inline<I>( &self, user_id: UserId, score: u64, inline_message_id: I, ) -> Self::SetGameScoreInline

where I: Into<String>,

For Telegram documentation see SetGameScoreInline.

type GetGameHighScores = JsonRequest<GetGameHighScores>

fn get_game_high_scores<T>( &self, user_id: UserId, target: T, ) -> Self::GetGameHighScores

where T: Into<TargetMessage>,

For Telegram documentation see GetGameHighScores.

type LogOut = JsonRequest<LogOut>

fn log_out(&self) -> Self::LogOut

For Telegram documentation see LogOut.

type Close = JsonRequest<Close>

fn close(&self) -> Self::Close

For Telegram documentation see Close.

type CopyMessage = JsonRequest<CopyMessage>

fn copy_message<C, F>( &self, chat_id: C, from_chat_id: F, message_id: MessageId, ) -> Self::CopyMessage

where C: Into<Recipient>, F: Into<Recipient>,

For Telegram documentation see CopyMessage.

type CopyMessages = JsonRequest<CopyMessages>

fn copy_messages<C, F, M>( &self, chat_id: C, from_chat_id: F, message_ids: M, ) -> Self::CopyMessages

where C: Into<Recipient>, F: Into<Recipient>, M: IntoIterator<Item = MessageId>,

For Telegram documentation see CopyMessages.

type UnpinAllChatMessages = JsonRequest<UnpinAllChatMessages>

fn unpin_all_chat_messages<C>(&self, chat_id: C) -> Self::UnpinAllChatMessages

where C: Into<Recipient>,

For Telegram documentation see UnpinAllChatMessages.