#![allow(
clippy::too_many_arguments,
unused_mut,
rustdoc::bare_urls,
rustdoc::invalid_html_tags
)]
use std::fmt;
use std::str::FromStr;
use serde::{Deserialize, Serialize};
pub const API_ENUM_COUNT: usize = 38;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParseTelegramEnumError {
pub enum_name: &'static str,
pub value: String,
}
impl fmt::Display for ParseTelegramEnumError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
formatter,
"unknown {} value: {}",
self.enum_name, self.value
)
}
}
impl std::error::Error for ParseTelegramEnumError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BotCommandScopeType {
#[serde(rename = "default")]
Default,
#[serde(rename = "all_private_chats")]
AllPrivateChats,
#[serde(rename = "all_group_chats")]
AllGroupChats,
#[serde(rename = "all_chat_administrators")]
AllChatAdministrators,
#[serde(rename = "chat")]
Chat,
#[serde(rename = "chat_administrators")]
ChatAdministrators,
#[serde(rename = "chat_member")]
ChatMember,
}
impl BotCommandScopeType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Default => "default",
Self::AllPrivateChats => "all_private_chats",
Self::AllGroupChats => "all_group_chats",
Self::AllChatAdministrators => "all_chat_administrators",
Self::Chat => "chat",
Self::ChatAdministrators => "chat_administrators",
Self::ChatMember => "chat_member",
}
}
}
impl fmt::Display for BotCommandScopeType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for BotCommandScopeType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<BotCommandScopeType> for String {
fn from(value: BotCommandScopeType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for BotCommandScopeType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"default" => Ok(Self::Default),
"all_private_chats" => Ok(Self::AllPrivateChats),
"all_group_chats" => Ok(Self::AllGroupChats),
"all_chat_administrators" => Ok(Self::AllChatAdministrators),
"chat" => Ok(Self::Chat),
"chat_administrators" => Ok(Self::ChatAdministrators),
"chat_member" => Ok(Self::ChatMember),
_ => Err(ParseTelegramEnumError {
enum_name: "BotCommandScopeType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BotSubscriptionUpdatedState {
#[serde(rename = "canceled")]
Canceled,
#[serde(rename = "active")]
Active,
#[serde(rename = "failed")]
Failed,
}
impl BotSubscriptionUpdatedState {
pub const fn as_str(self) -> &'static str {
match self {
Self::Canceled => "canceled",
Self::Active => "active",
Self::Failed => "failed",
}
}
}
impl fmt::Display for BotSubscriptionUpdatedState {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for BotSubscriptionUpdatedState {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<BotSubscriptionUpdatedState> for String {
fn from(value: BotSubscriptionUpdatedState) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for BotSubscriptionUpdatedState {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"canceled" => Ok(Self::Canceled),
"active" => Ok(Self::Active),
"failed" => Ok(Self::Failed),
_ => Err(ParseTelegramEnumError {
enum_name: "BotSubscriptionUpdatedState",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ButtonStyle {
#[serde(rename = "danger")]
Danger,
#[serde(rename = "success")]
Success,
#[serde(rename = "primary")]
Primary,
}
impl ButtonStyle {
pub const fn as_str(self) -> &'static str {
match self {
Self::Danger => "danger",
Self::Success => "success",
Self::Primary => "primary",
}
}
}
impl fmt::Display for ButtonStyle {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for ButtonStyle {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<ButtonStyle> for String {
fn from(value: ButtonStyle) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for ButtonStyle {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"danger" => Ok(Self::Danger),
"success" => Ok(Self::Success),
"primary" => Ok(Self::Primary),
_ => Err(ParseTelegramEnumError {
enum_name: "ButtonStyle",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChatAction {
#[serde(rename = "typing")]
Typing,
#[serde(rename = "upload_photo")]
UploadPhoto,
#[serde(rename = "record_video")]
RecordVideo,
#[serde(rename = "upload_video")]
UploadVideo,
#[serde(rename = "record_voice")]
RecordVoice,
#[serde(rename = "upload_voice")]
UploadVoice,
#[serde(rename = "upload_document")]
UploadDocument,
#[serde(rename = "choose_sticker")]
ChooseSticker,
#[serde(rename = "find_location")]
FindLocation,
#[serde(rename = "record_video_note")]
RecordVideoNote,
#[serde(rename = "upload_video_note")]
UploadVideoNote,
}
impl ChatAction {
pub const fn as_str(self) -> &'static str {
match self {
Self::Typing => "typing",
Self::UploadPhoto => "upload_photo",
Self::RecordVideo => "record_video",
Self::UploadVideo => "upload_video",
Self::RecordVoice => "record_voice",
Self::UploadVoice => "upload_voice",
Self::UploadDocument => "upload_document",
Self::ChooseSticker => "choose_sticker",
Self::FindLocation => "find_location",
Self::RecordVideoNote => "record_video_note",
Self::UploadVideoNote => "upload_video_note",
}
}
}
impl fmt::Display for ChatAction {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for ChatAction {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<ChatAction> for String {
fn from(value: ChatAction) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for ChatAction {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"typing" => Ok(Self::Typing),
"upload_photo" => Ok(Self::UploadPhoto),
"record_video" => Ok(Self::RecordVideo),
"upload_video" => Ok(Self::UploadVideo),
"record_voice" => Ok(Self::RecordVoice),
"upload_voice" => Ok(Self::UploadVoice),
"upload_document" => Ok(Self::UploadDocument),
"choose_sticker" => Ok(Self::ChooseSticker),
"find_location" => Ok(Self::FindLocation),
"record_video_note" => Ok(Self::RecordVideoNote),
"upload_video_note" => Ok(Self::UploadVideoNote),
_ => Err(ParseTelegramEnumError {
enum_name: "ChatAction",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChatBoostSourceType {
#[serde(rename = "premium")]
Premium,
#[serde(rename = "gift_code")]
GiftCode,
#[serde(rename = "giveaway")]
Giveaway,
}
impl ChatBoostSourceType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Premium => "premium",
Self::GiftCode => "gift_code",
Self::Giveaway => "giveaway",
}
}
}
impl fmt::Display for ChatBoostSourceType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for ChatBoostSourceType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<ChatBoostSourceType> for String {
fn from(value: ChatBoostSourceType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for ChatBoostSourceType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"premium" => Ok(Self::Premium),
"gift_code" => Ok(Self::GiftCode),
"giveaway" => Ok(Self::Giveaway),
_ => Err(ParseTelegramEnumError {
enum_name: "ChatBoostSourceType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChatMemberStatus {
#[serde(rename = "creator")]
Creator,
#[serde(rename = "administrator")]
Administrator,
#[serde(rename = "member")]
Member,
#[serde(rename = "restricted")]
Restricted,
#[serde(rename = "left")]
Left,
#[serde(rename = "kicked")]
Kicked,
}
impl ChatMemberStatus {
pub const fn as_str(self) -> &'static str {
match self {
Self::Creator => "creator",
Self::Administrator => "administrator",
Self::Member => "member",
Self::Restricted => "restricted",
Self::Left => "left",
Self::Kicked => "kicked",
}
}
}
impl fmt::Display for ChatMemberStatus {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for ChatMemberStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<ChatMemberStatus> for String {
fn from(value: ChatMemberStatus) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for ChatMemberStatus {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"creator" => Ok(Self::Creator),
"administrator" => Ok(Self::Administrator),
"member" => Ok(Self::Member),
"restricted" => Ok(Self::Restricted),
"left" => Ok(Self::Left),
"kicked" => Ok(Self::Kicked),
_ => Err(ParseTelegramEnumError {
enum_name: "ChatMemberStatus",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChatType {
#[serde(rename = "sender")]
Sender,
#[serde(rename = "private")]
Private,
#[serde(rename = "group")]
Group,
#[serde(rename = "supergroup")]
Supergroup,
#[serde(rename = "channel")]
Channel,
}
impl ChatType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Sender => "sender",
Self::Private => "private",
Self::Group => "group",
Self::Supergroup => "supergroup",
Self::Channel => "channel",
}
}
}
impl fmt::Display for ChatType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for ChatType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<ChatType> for String {
fn from(value: ChatType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for ChatType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"sender" => Ok(Self::Sender),
"private" => Ok(Self::Private),
"group" => Ok(Self::Group),
"supergroup" => Ok(Self::Supergroup),
"channel" => Ok(Self::Channel),
_ => Err(ParseTelegramEnumError {
enum_name: "ChatType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ContentType {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "any")]
Any,
#[serde(rename = "text")]
Text,
#[serde(rename = "animation")]
Animation,
#[serde(rename = "audio")]
Audio,
#[serde(rename = "document")]
Document,
#[serde(rename = "live_photo")]
LivePhoto,
#[serde(rename = "paid_media")]
PaidMedia,
#[serde(rename = "photo")]
Photo,
#[serde(rename = "sticker")]
Sticker,
#[serde(rename = "story")]
Story,
#[serde(rename = "video")]
Video,
#[serde(rename = "video_note")]
VideoNote,
#[serde(rename = "voice")]
Voice,
#[serde(rename = "checklist")]
Checklist,
#[serde(rename = "contact")]
Contact,
#[serde(rename = "dice")]
Dice,
#[serde(rename = "game")]
Game,
#[serde(rename = "poll")]
Poll,
#[serde(rename = "venue")]
Venue,
#[serde(rename = "location")]
Location,
#[serde(rename = "new_chat_members")]
NewChatMembers,
#[serde(rename = "left_chat_member")]
LeftChatMember,
#[serde(rename = "chat_owner_left")]
ChatOwnerLeft,
#[serde(rename = "chat_owner_changed")]
ChatOwnerChanged,
#[serde(rename = "new_chat_title")]
NewChatTitle,
#[serde(rename = "new_chat_photo")]
NewChatPhoto,
#[serde(rename = "delete_chat_photo")]
DeleteChatPhoto,
#[serde(rename = "group_chat_created")]
GroupChatCreated,
#[serde(rename = "supergroup_chat_created")]
SupergroupChatCreated,
#[serde(rename = "channel_chat_created")]
ChannelChatCreated,
#[serde(rename = "message_auto_delete_timer_changed")]
MessageAutoDeleteTimerChanged,
#[serde(rename = "migrate_to_chat_id")]
MigrateToChatId,
#[serde(rename = "migrate_from_chat_id")]
MigrateFromChatId,
#[serde(rename = "pinned_message")]
PinnedMessage,
#[serde(rename = "invoice")]
Invoice,
#[serde(rename = "successful_payment")]
SuccessfulPayment,
#[serde(rename = "refunded_payment")]
RefundedPayment,
#[serde(rename = "users_shared")]
UsersShared,
#[serde(rename = "chat_shared")]
ChatShared,
#[serde(rename = "gift")]
Gift,
#[serde(rename = "unique_gift")]
UniqueGift,
#[serde(rename = "gift_upgrade_sent")]
GiftUpgradeSent,
#[serde(rename = "connected_website")]
ConnectedWebsite,
#[serde(rename = "write_access_allowed")]
WriteAccessAllowed,
#[serde(rename = "passport_data")]
PassportData,
#[serde(rename = "proximity_alert_triggered")]
ProximityAlertTriggered,
#[serde(rename = "boost_added")]
BoostAdded,
#[serde(rename = "chat_background_set")]
ChatBackgroundSet,
#[serde(rename = "checklist_tasks_done")]
ChecklistTasksDone,
#[serde(rename = "checklist_tasks_added")]
ChecklistTasksAdded,
#[serde(rename = "direct_message_price_changed")]
DirectMessagePriceChanged,
#[serde(rename = "forum_topic_created")]
ForumTopicCreated,
#[serde(rename = "forum_topic_edited")]
ForumTopicEdited,
#[serde(rename = "forum_topic_closed")]
ForumTopicClosed,
#[serde(rename = "forum_topic_reopened")]
ForumTopicReopened,
#[serde(rename = "general_forum_topic_hidden")]
GeneralForumTopicHidden,
#[serde(rename = "general_forum_topic_unhidden")]
GeneralForumTopicUnhidden,
#[serde(rename = "giveaway_created")]
GiveawayCreated,
#[serde(rename = "giveaway")]
Giveaway,
#[serde(rename = "giveaway_winners")]
GiveawayWinners,
#[serde(rename = "giveaway_completed")]
GiveawayCompleted,
#[serde(rename = "managed_bot_created")]
ManagedBotCreated,
#[serde(rename = "paid_message_price_changed")]
PaidMessagePriceChanged,
#[serde(rename = "poll_option_added")]
PollOptionAdded,
#[serde(rename = "poll_option_deleted")]
PollOptionDeleted,
#[serde(rename = "suggested_post_approved")]
SuggestedPostApproved,
#[serde(rename = "suggested_post_approval_failed")]
SuggestedPostApprovalFailed,
#[serde(rename = "suggested_post_declined")]
SuggestedPostDeclined,
#[serde(rename = "suggested_post_paid")]
SuggestedPostPaid,
#[serde(rename = "suggested_post_refunded")]
SuggestedPostRefunded,
#[serde(rename = "video_chat_scheduled")]
VideoChatScheduled,
#[serde(rename = "video_chat_started")]
VideoChatStarted,
#[serde(rename = "video_chat_ended")]
VideoChatEnded,
#[serde(rename = "video_chat_participants_invited")]
VideoChatParticipantsInvited,
#[serde(rename = "web_app_data")]
WebAppData,
#[serde(rename = "rich_message")]
RichMessage,
#[serde(rename = "community_chat_added")]
CommunityChatAdded,
#[serde(rename = "community_chat_removed")]
CommunityChatRemoved,
#[serde(rename = "user_shared")]
UserShared,
}
impl ContentType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Unknown => "unknown",
Self::Any => "any",
Self::Text => "text",
Self::Animation => "animation",
Self::Audio => "audio",
Self::Document => "document",
Self::LivePhoto => "live_photo",
Self::PaidMedia => "paid_media",
Self::Photo => "photo",
Self::Sticker => "sticker",
Self::Story => "story",
Self::Video => "video",
Self::VideoNote => "video_note",
Self::Voice => "voice",
Self::Checklist => "checklist",
Self::Contact => "contact",
Self::Dice => "dice",
Self::Game => "game",
Self::Poll => "poll",
Self::Venue => "venue",
Self::Location => "location",
Self::NewChatMembers => "new_chat_members",
Self::LeftChatMember => "left_chat_member",
Self::ChatOwnerLeft => "chat_owner_left",
Self::ChatOwnerChanged => "chat_owner_changed",
Self::NewChatTitle => "new_chat_title",
Self::NewChatPhoto => "new_chat_photo",
Self::DeleteChatPhoto => "delete_chat_photo",
Self::GroupChatCreated => "group_chat_created",
Self::SupergroupChatCreated => "supergroup_chat_created",
Self::ChannelChatCreated => "channel_chat_created",
Self::MessageAutoDeleteTimerChanged => "message_auto_delete_timer_changed",
Self::MigrateToChatId => "migrate_to_chat_id",
Self::MigrateFromChatId => "migrate_from_chat_id",
Self::PinnedMessage => "pinned_message",
Self::Invoice => "invoice",
Self::SuccessfulPayment => "successful_payment",
Self::RefundedPayment => "refunded_payment",
Self::UsersShared => "users_shared",
Self::ChatShared => "chat_shared",
Self::Gift => "gift",
Self::UniqueGift => "unique_gift",
Self::GiftUpgradeSent => "gift_upgrade_sent",
Self::ConnectedWebsite => "connected_website",
Self::WriteAccessAllowed => "write_access_allowed",
Self::PassportData => "passport_data",
Self::ProximityAlertTriggered => "proximity_alert_triggered",
Self::BoostAdded => "boost_added",
Self::ChatBackgroundSet => "chat_background_set",
Self::ChecklistTasksDone => "checklist_tasks_done",
Self::ChecklistTasksAdded => "checklist_tasks_added",
Self::DirectMessagePriceChanged => "direct_message_price_changed",
Self::ForumTopicCreated => "forum_topic_created",
Self::ForumTopicEdited => "forum_topic_edited",
Self::ForumTopicClosed => "forum_topic_closed",
Self::ForumTopicReopened => "forum_topic_reopened",
Self::GeneralForumTopicHidden => "general_forum_topic_hidden",
Self::GeneralForumTopicUnhidden => "general_forum_topic_unhidden",
Self::GiveawayCreated => "giveaway_created",
Self::Giveaway => "giveaway",
Self::GiveawayWinners => "giveaway_winners",
Self::GiveawayCompleted => "giveaway_completed",
Self::ManagedBotCreated => "managed_bot_created",
Self::PaidMessagePriceChanged => "paid_message_price_changed",
Self::PollOptionAdded => "poll_option_added",
Self::PollOptionDeleted => "poll_option_deleted",
Self::SuggestedPostApproved => "suggested_post_approved",
Self::SuggestedPostApprovalFailed => "suggested_post_approval_failed",
Self::SuggestedPostDeclined => "suggested_post_declined",
Self::SuggestedPostPaid => "suggested_post_paid",
Self::SuggestedPostRefunded => "suggested_post_refunded",
Self::VideoChatScheduled => "video_chat_scheduled",
Self::VideoChatStarted => "video_chat_started",
Self::VideoChatEnded => "video_chat_ended",
Self::VideoChatParticipantsInvited => "video_chat_participants_invited",
Self::WebAppData => "web_app_data",
Self::RichMessage => "rich_message",
Self::CommunityChatAdded => "community_chat_added",
Self::CommunityChatRemoved => "community_chat_removed",
Self::UserShared => "user_shared",
}
}
}
impl fmt::Display for ContentType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for ContentType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<ContentType> for String {
fn from(value: ContentType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for ContentType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"unknown" => Ok(Self::Unknown),
"any" => Ok(Self::Any),
"text" => Ok(Self::Text),
"animation" => Ok(Self::Animation),
"audio" => Ok(Self::Audio),
"document" => Ok(Self::Document),
"live_photo" => Ok(Self::LivePhoto),
"paid_media" => Ok(Self::PaidMedia),
"photo" => Ok(Self::Photo),
"sticker" => Ok(Self::Sticker),
"story" => Ok(Self::Story),
"video" => Ok(Self::Video),
"video_note" => Ok(Self::VideoNote),
"voice" => Ok(Self::Voice),
"checklist" => Ok(Self::Checklist),
"contact" => Ok(Self::Contact),
"dice" => Ok(Self::Dice),
"game" => Ok(Self::Game),
"poll" => Ok(Self::Poll),
"venue" => Ok(Self::Venue),
"location" => Ok(Self::Location),
"new_chat_members" => Ok(Self::NewChatMembers),
"left_chat_member" => Ok(Self::LeftChatMember),
"chat_owner_left" => Ok(Self::ChatOwnerLeft),
"chat_owner_changed" => Ok(Self::ChatOwnerChanged),
"new_chat_title" => Ok(Self::NewChatTitle),
"new_chat_photo" => Ok(Self::NewChatPhoto),
"delete_chat_photo" => Ok(Self::DeleteChatPhoto),
"group_chat_created" => Ok(Self::GroupChatCreated),
"supergroup_chat_created" => Ok(Self::SupergroupChatCreated),
"channel_chat_created" => Ok(Self::ChannelChatCreated),
"message_auto_delete_timer_changed" => Ok(Self::MessageAutoDeleteTimerChanged),
"migrate_to_chat_id" => Ok(Self::MigrateToChatId),
"migrate_from_chat_id" => Ok(Self::MigrateFromChatId),
"pinned_message" => Ok(Self::PinnedMessage),
"invoice" => Ok(Self::Invoice),
"successful_payment" => Ok(Self::SuccessfulPayment),
"refunded_payment" => Ok(Self::RefundedPayment),
"users_shared" => Ok(Self::UsersShared),
"chat_shared" => Ok(Self::ChatShared),
"gift" => Ok(Self::Gift),
"unique_gift" => Ok(Self::UniqueGift),
"gift_upgrade_sent" => Ok(Self::GiftUpgradeSent),
"connected_website" => Ok(Self::ConnectedWebsite),
"write_access_allowed" => Ok(Self::WriteAccessAllowed),
"passport_data" => Ok(Self::PassportData),
"proximity_alert_triggered" => Ok(Self::ProximityAlertTriggered),
"boost_added" => Ok(Self::BoostAdded),
"chat_background_set" => Ok(Self::ChatBackgroundSet),
"checklist_tasks_done" => Ok(Self::ChecklistTasksDone),
"checklist_tasks_added" => Ok(Self::ChecklistTasksAdded),
"direct_message_price_changed" => Ok(Self::DirectMessagePriceChanged),
"forum_topic_created" => Ok(Self::ForumTopicCreated),
"forum_topic_edited" => Ok(Self::ForumTopicEdited),
"forum_topic_closed" => Ok(Self::ForumTopicClosed),
"forum_topic_reopened" => Ok(Self::ForumTopicReopened),
"general_forum_topic_hidden" => Ok(Self::GeneralForumTopicHidden),
"general_forum_topic_unhidden" => Ok(Self::GeneralForumTopicUnhidden),
"giveaway_created" => Ok(Self::GiveawayCreated),
"giveaway" => Ok(Self::Giveaway),
"giveaway_winners" => Ok(Self::GiveawayWinners),
"giveaway_completed" => Ok(Self::GiveawayCompleted),
"managed_bot_created" => Ok(Self::ManagedBotCreated),
"paid_message_price_changed" => Ok(Self::PaidMessagePriceChanged),
"poll_option_added" => Ok(Self::PollOptionAdded),
"poll_option_deleted" => Ok(Self::PollOptionDeleted),
"suggested_post_approved" => Ok(Self::SuggestedPostApproved),
"suggested_post_approval_failed" => Ok(Self::SuggestedPostApprovalFailed),
"suggested_post_declined" => Ok(Self::SuggestedPostDeclined),
"suggested_post_paid" => Ok(Self::SuggestedPostPaid),
"suggested_post_refunded" => Ok(Self::SuggestedPostRefunded),
"video_chat_scheduled" => Ok(Self::VideoChatScheduled),
"video_chat_started" => Ok(Self::VideoChatStarted),
"video_chat_ended" => Ok(Self::VideoChatEnded),
"video_chat_participants_invited" => Ok(Self::VideoChatParticipantsInvited),
"web_app_data" => Ok(Self::WebAppData),
"rich_message" => Ok(Self::RichMessage),
"community_chat_added" => Ok(Self::CommunityChatAdded),
"community_chat_removed" => Ok(Self::CommunityChatRemoved),
"user_shared" => Ok(Self::UserShared),
_ => Err(ParseTelegramEnumError {
enum_name: "ContentType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Currency {
#[serde(rename = "AED")]
Aed,
#[serde(rename = "AFN")]
Afn,
#[serde(rename = "ALL")]
All,
#[serde(rename = "AMD")]
Amd,
#[serde(rename = "ARS")]
Ars,
#[serde(rename = "AUD")]
Aud,
#[serde(rename = "AZN")]
Azn,
#[serde(rename = "BAM")]
Bam,
#[serde(rename = "BDT")]
Bdt,
#[serde(rename = "BGN")]
Bgn,
#[serde(rename = "BND")]
Bnd,
#[serde(rename = "BOB")]
Bob,
#[serde(rename = "BRL")]
Brl,
#[serde(rename = "BYN")]
Byn,
#[serde(rename = "CAD")]
Cad,
#[serde(rename = "CHF")]
Chf,
#[serde(rename = "CLP")]
Clp,
#[serde(rename = "CNY")]
Cny,
#[serde(rename = "COP")]
Cop,
#[serde(rename = "CRC")]
Crc,
#[serde(rename = "CZK")]
Czk,
#[serde(rename = "DKK")]
Dkk,
#[serde(rename = "DOP")]
Dop,
#[serde(rename = "DZD")]
Dzd,
#[serde(rename = "EGP")]
Egp,
#[serde(rename = "ETB")]
Etb,
#[serde(rename = "EUR")]
Eur,
#[serde(rename = "GBP")]
Gbp,
#[serde(rename = "GEL")]
Gel,
#[serde(rename = "GTQ")]
Gtq,
#[serde(rename = "HKD")]
Hkd,
#[serde(rename = "HNL")]
Hnl,
#[serde(rename = "HRK")]
Hrk,
#[serde(rename = "HUF")]
Huf,
#[serde(rename = "IDR")]
Idr,
#[serde(rename = "ILS")]
Ils,
#[serde(rename = "INR")]
Inr,
#[serde(rename = "ISK")]
Isk,
#[serde(rename = "JMD")]
Jmd,
#[serde(rename = "JPY")]
Jpy,
#[serde(rename = "KES")]
Kes,
#[serde(rename = "KGS")]
Kgs,
#[serde(rename = "KRW")]
Krw,
#[serde(rename = "KZT")]
Kzt,
#[serde(rename = "LBP")]
Lbp,
#[serde(rename = "LKR")]
Lkr,
#[serde(rename = "MAD")]
Mad,
#[serde(rename = "MDL")]
Mdl,
#[serde(rename = "MNT")]
Mnt,
#[serde(rename = "MUR")]
Mur,
#[serde(rename = "MVR")]
Mvr,
#[serde(rename = "MXN")]
Mxn,
#[serde(rename = "MYR")]
Myr,
#[serde(rename = "MZN")]
Mzn,
#[serde(rename = "NGN")]
Ngn,
#[serde(rename = "NIO")]
Nio,
#[serde(rename = "NOK")]
Nok,
#[serde(rename = "NPR")]
Npr,
#[serde(rename = "NZD")]
Nzd,
#[serde(rename = "PAB")]
Pab,
#[serde(rename = "PEN")]
Pen,
#[serde(rename = "PHP")]
Php,
#[serde(rename = "PKR")]
Pkr,
#[serde(rename = "PLN")]
Pln,
#[serde(rename = "PYG")]
Pyg,
#[serde(rename = "QAR")]
Qar,
#[serde(rename = "RON")]
Ron,
#[serde(rename = "RSD")]
Rsd,
#[serde(rename = "RUB")]
Rub,
#[serde(rename = "SAR")]
Sar,
#[serde(rename = "SEK")]
Sek,
#[serde(rename = "SGD")]
Sgd,
#[serde(rename = "THB")]
Thb,
#[serde(rename = "TJS")]
Tjs,
#[serde(rename = "TRY")]
Try,
#[serde(rename = "TTD")]
Ttd,
#[serde(rename = "TWD")]
Twd,
#[serde(rename = "TZS")]
Tzs,
#[serde(rename = "UAH")]
Uah,
#[serde(rename = "UGX")]
Ugx,
#[serde(rename = "USD")]
Usd,
#[serde(rename = "UYU")]
Uyu,
#[serde(rename = "UZS")]
Uzs,
#[serde(rename = "VND")]
Vnd,
#[serde(rename = "YER")]
Yer,
#[serde(rename = "ZAR")]
Zar,
}
impl Currency {
pub const fn as_str(self) -> &'static str {
match self {
Self::Aed => "AED",
Self::Afn => "AFN",
Self::All => "ALL",
Self::Amd => "AMD",
Self::Ars => "ARS",
Self::Aud => "AUD",
Self::Azn => "AZN",
Self::Bam => "BAM",
Self::Bdt => "BDT",
Self::Bgn => "BGN",
Self::Bnd => "BND",
Self::Bob => "BOB",
Self::Brl => "BRL",
Self::Byn => "BYN",
Self::Cad => "CAD",
Self::Chf => "CHF",
Self::Clp => "CLP",
Self::Cny => "CNY",
Self::Cop => "COP",
Self::Crc => "CRC",
Self::Czk => "CZK",
Self::Dkk => "DKK",
Self::Dop => "DOP",
Self::Dzd => "DZD",
Self::Egp => "EGP",
Self::Etb => "ETB",
Self::Eur => "EUR",
Self::Gbp => "GBP",
Self::Gel => "GEL",
Self::Gtq => "GTQ",
Self::Hkd => "HKD",
Self::Hnl => "HNL",
Self::Hrk => "HRK",
Self::Huf => "HUF",
Self::Idr => "IDR",
Self::Ils => "ILS",
Self::Inr => "INR",
Self::Isk => "ISK",
Self::Jmd => "JMD",
Self::Jpy => "JPY",
Self::Kes => "KES",
Self::Kgs => "KGS",
Self::Krw => "KRW",
Self::Kzt => "KZT",
Self::Lbp => "LBP",
Self::Lkr => "LKR",
Self::Mad => "MAD",
Self::Mdl => "MDL",
Self::Mnt => "MNT",
Self::Mur => "MUR",
Self::Mvr => "MVR",
Self::Mxn => "MXN",
Self::Myr => "MYR",
Self::Mzn => "MZN",
Self::Ngn => "NGN",
Self::Nio => "NIO",
Self::Nok => "NOK",
Self::Npr => "NPR",
Self::Nzd => "NZD",
Self::Pab => "PAB",
Self::Pen => "PEN",
Self::Php => "PHP",
Self::Pkr => "PKR",
Self::Pln => "PLN",
Self::Pyg => "PYG",
Self::Qar => "QAR",
Self::Ron => "RON",
Self::Rsd => "RSD",
Self::Rub => "RUB",
Self::Sar => "SAR",
Self::Sek => "SEK",
Self::Sgd => "SGD",
Self::Thb => "THB",
Self::Tjs => "TJS",
Self::Try => "TRY",
Self::Ttd => "TTD",
Self::Twd => "TWD",
Self::Tzs => "TZS",
Self::Uah => "UAH",
Self::Ugx => "UGX",
Self::Usd => "USD",
Self::Uyu => "UYU",
Self::Uzs => "UZS",
Self::Vnd => "VND",
Self::Yer => "YER",
Self::Zar => "ZAR",
}
}
}
impl fmt::Display for Currency {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for Currency {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<Currency> for String {
fn from(value: Currency) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for Currency {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"AED" => Ok(Self::Aed),
"AFN" => Ok(Self::Afn),
"ALL" => Ok(Self::All),
"AMD" => Ok(Self::Amd),
"ARS" => Ok(Self::Ars),
"AUD" => Ok(Self::Aud),
"AZN" => Ok(Self::Azn),
"BAM" => Ok(Self::Bam),
"BDT" => Ok(Self::Bdt),
"BGN" => Ok(Self::Bgn),
"BND" => Ok(Self::Bnd),
"BOB" => Ok(Self::Bob),
"BRL" => Ok(Self::Brl),
"BYN" => Ok(Self::Byn),
"CAD" => Ok(Self::Cad),
"CHF" => Ok(Self::Chf),
"CLP" => Ok(Self::Clp),
"CNY" => Ok(Self::Cny),
"COP" => Ok(Self::Cop),
"CRC" => Ok(Self::Crc),
"CZK" => Ok(Self::Czk),
"DKK" => Ok(Self::Dkk),
"DOP" => Ok(Self::Dop),
"DZD" => Ok(Self::Dzd),
"EGP" => Ok(Self::Egp),
"ETB" => Ok(Self::Etb),
"EUR" => Ok(Self::Eur),
"GBP" => Ok(Self::Gbp),
"GEL" => Ok(Self::Gel),
"GTQ" => Ok(Self::Gtq),
"HKD" => Ok(Self::Hkd),
"HNL" => Ok(Self::Hnl),
"HRK" => Ok(Self::Hrk),
"HUF" => Ok(Self::Huf),
"IDR" => Ok(Self::Idr),
"ILS" => Ok(Self::Ils),
"INR" => Ok(Self::Inr),
"ISK" => Ok(Self::Isk),
"JMD" => Ok(Self::Jmd),
"JPY" => Ok(Self::Jpy),
"KES" => Ok(Self::Kes),
"KGS" => Ok(Self::Kgs),
"KRW" => Ok(Self::Krw),
"KZT" => Ok(Self::Kzt),
"LBP" => Ok(Self::Lbp),
"LKR" => Ok(Self::Lkr),
"MAD" => Ok(Self::Mad),
"MDL" => Ok(Self::Mdl),
"MNT" => Ok(Self::Mnt),
"MUR" => Ok(Self::Mur),
"MVR" => Ok(Self::Mvr),
"MXN" => Ok(Self::Mxn),
"MYR" => Ok(Self::Myr),
"MZN" => Ok(Self::Mzn),
"NGN" => Ok(Self::Ngn),
"NIO" => Ok(Self::Nio),
"NOK" => Ok(Self::Nok),
"NPR" => Ok(Self::Npr),
"NZD" => Ok(Self::Nzd),
"PAB" => Ok(Self::Pab),
"PEN" => Ok(Self::Pen),
"PHP" => Ok(Self::Php),
"PKR" => Ok(Self::Pkr),
"PLN" => Ok(Self::Pln),
"PYG" => Ok(Self::Pyg),
"QAR" => Ok(Self::Qar),
"RON" => Ok(Self::Ron),
"RSD" => Ok(Self::Rsd),
"RUB" => Ok(Self::Rub),
"SAR" => Ok(Self::Sar),
"SEK" => Ok(Self::Sek),
"SGD" => Ok(Self::Sgd),
"THB" => Ok(Self::Thb),
"TJS" => Ok(Self::Tjs),
"TRY" => Ok(Self::Try),
"TTD" => Ok(Self::Ttd),
"TWD" => Ok(Self::Twd),
"TZS" => Ok(Self::Tzs),
"UAH" => Ok(Self::Uah),
"UGX" => Ok(Self::Ugx),
"USD" => Ok(Self::Usd),
"UYU" => Ok(Self::Uyu),
"UZS" => Ok(Self::Uzs),
"VND" => Ok(Self::Vnd),
"YER" => Ok(Self::Yer),
"ZAR" => Ok(Self::Zar),
_ => Err(ParseTelegramEnumError {
enum_name: "Currency",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DiceEmoji {
#[serde(rename = "🎲")]
Dice,
#[serde(rename = "🎯")]
Dart,
#[serde(rename = "🏀")]
Basketball,
#[serde(rename = "⚽")]
Football,
#[serde(rename = "🎰")]
SlotMachine,
#[serde(rename = "🎳")]
Bowling,
}
impl DiceEmoji {
pub const fn as_str(self) -> &'static str {
match self {
Self::Dice => "🎲",
Self::Dart => "🎯",
Self::Basketball => "🏀",
Self::Football => "⚽",
Self::SlotMachine => "🎰",
Self::Bowling => "🎳",
}
}
}
impl fmt::Display for DiceEmoji {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for DiceEmoji {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<DiceEmoji> for String {
fn from(value: DiceEmoji) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for DiceEmoji {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"🎲" => Ok(Self::Dice),
"🎯" => Ok(Self::Dart),
"🏀" => Ok(Self::Basketball),
"⚽" => Ok(Self::Football),
"🎰" => Ok(Self::SlotMachine),
"🎳" => Ok(Self::Bowling),
_ => Err(ParseTelegramEnumError {
enum_name: "DiceEmoji",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum EncryptedPassportElement {
#[serde(rename = "personal_details")]
PersonalDetails,
#[serde(rename = "passport")]
Passport,
#[serde(rename = "driver_license")]
DriverLicense,
#[serde(rename = "identity_card")]
IdentityCard,
#[serde(rename = "internal_passport")]
InternalPassport,
#[serde(rename = "address")]
Address,
#[serde(rename = "utility_bill")]
UtilityBill,
#[serde(rename = "bank_statement")]
BankStatement,
#[serde(rename = "rental_agreement")]
RentalAgreement,
#[serde(rename = "passport_registration")]
PassportRegistration,
#[serde(rename = "temporary_registration")]
TemporaryRegistration,
#[serde(rename = "phone_number")]
PhoneNumber,
#[serde(rename = "email")]
Email,
}
impl EncryptedPassportElement {
pub const fn as_str(self) -> &'static str {
match self {
Self::PersonalDetails => "personal_details",
Self::Passport => "passport",
Self::DriverLicense => "driver_license",
Self::IdentityCard => "identity_card",
Self::InternalPassport => "internal_passport",
Self::Address => "address",
Self::UtilityBill => "utility_bill",
Self::BankStatement => "bank_statement",
Self::RentalAgreement => "rental_agreement",
Self::PassportRegistration => "passport_registration",
Self::TemporaryRegistration => "temporary_registration",
Self::PhoneNumber => "phone_number",
Self::Email => "email",
}
}
}
impl fmt::Display for EncryptedPassportElement {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for EncryptedPassportElement {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<EncryptedPassportElement> for String {
fn from(value: EncryptedPassportElement) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for EncryptedPassportElement {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"personal_details" => Ok(Self::PersonalDetails),
"passport" => Ok(Self::Passport),
"driver_license" => Ok(Self::DriverLicense),
"identity_card" => Ok(Self::IdentityCard),
"internal_passport" => Ok(Self::InternalPassport),
"address" => Ok(Self::Address),
"utility_bill" => Ok(Self::UtilityBill),
"bank_statement" => Ok(Self::BankStatement),
"rental_agreement" => Ok(Self::RentalAgreement),
"passport_registration" => Ok(Self::PassportRegistration),
"temporary_registration" => Ok(Self::TemporaryRegistration),
"phone_number" => Ok(Self::PhoneNumber),
"email" => Ok(Self::Email),
_ => Err(ParseTelegramEnumError {
enum_name: "EncryptedPassportElement",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum InlineQueryResultType {
#[serde(rename = "audio")]
Audio,
#[serde(rename = "document")]
Document,
#[serde(rename = "gif")]
Gif,
#[serde(rename = "mpeg4_gif")]
Mpeg4Gif,
#[serde(rename = "photo")]
Photo,
#[serde(rename = "sticker")]
Sticker,
#[serde(rename = "video")]
Video,
#[serde(rename = "voice")]
Voice,
#[serde(rename = "article")]
Article,
#[serde(rename = "contact")]
Contact,
#[serde(rename = "game")]
Game,
#[serde(rename = "location")]
Location,
#[serde(rename = "venue")]
Venue,
}
impl InlineQueryResultType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Audio => "audio",
Self::Document => "document",
Self::Gif => "gif",
Self::Mpeg4Gif => "mpeg4_gif",
Self::Photo => "photo",
Self::Sticker => "sticker",
Self::Video => "video",
Self::Voice => "voice",
Self::Article => "article",
Self::Contact => "contact",
Self::Game => "game",
Self::Location => "location",
Self::Venue => "venue",
}
}
}
impl fmt::Display for InlineQueryResultType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for InlineQueryResultType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<InlineQueryResultType> for String {
fn from(value: InlineQueryResultType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for InlineQueryResultType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"audio" => Ok(Self::Audio),
"document" => Ok(Self::Document),
"gif" => Ok(Self::Gif),
"mpeg4_gif" => Ok(Self::Mpeg4Gif),
"photo" => Ok(Self::Photo),
"sticker" => Ok(Self::Sticker),
"video" => Ok(Self::Video),
"voice" => Ok(Self::Voice),
"article" => Ok(Self::Article),
"contact" => Ok(Self::Contact),
"game" => Ok(Self::Game),
"location" => Ok(Self::Location),
"venue" => Ok(Self::Venue),
_ => Err(ParseTelegramEnumError {
enum_name: "InlineQueryResultType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum InputMediaType {
#[serde(rename = "animation")]
Animation,
#[serde(rename = "audio")]
Audio,
#[serde(rename = "document")]
Document,
#[serde(rename = "photo")]
Photo,
#[serde(rename = "video")]
Video,
#[serde(rename = "live_photo")]
LivePhoto,
#[serde(rename = "venue")]
Venue,
#[serde(rename = "sticker")]
Sticker,
#[serde(rename = "location")]
Location,
}
impl InputMediaType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Animation => "animation",
Self::Audio => "audio",
Self::Document => "document",
Self::Photo => "photo",
Self::Video => "video",
Self::LivePhoto => "live_photo",
Self::Venue => "venue",
Self::Sticker => "sticker",
Self::Location => "location",
}
}
}
impl fmt::Display for InputMediaType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for InputMediaType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<InputMediaType> for String {
fn from(value: InputMediaType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for InputMediaType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"animation" => Ok(Self::Animation),
"audio" => Ok(Self::Audio),
"document" => Ok(Self::Document),
"photo" => Ok(Self::Photo),
"video" => Ok(Self::Video),
"live_photo" => Ok(Self::LivePhoto),
"venue" => Ok(Self::Venue),
"sticker" => Ok(Self::Sticker),
"location" => Ok(Self::Location),
_ => Err(ParseTelegramEnumError {
enum_name: "InputMediaType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum InputPaidMediaType {
#[serde(rename = "photo")]
Photo,
#[serde(rename = "video")]
Video,
#[serde(rename = "live_photo")]
LivePhoto,
}
impl InputPaidMediaType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Photo => "photo",
Self::Video => "video",
Self::LivePhoto => "live_photo",
}
}
}
impl fmt::Display for InputPaidMediaType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for InputPaidMediaType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<InputPaidMediaType> for String {
fn from(value: InputPaidMediaType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for InputPaidMediaType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"photo" => Ok(Self::Photo),
"video" => Ok(Self::Video),
"live_photo" => Ok(Self::LivePhoto),
_ => Err(ParseTelegramEnumError {
enum_name: "InputPaidMediaType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum InputProfilePhotoType {
#[serde(rename = "static")]
Static,
#[serde(rename = "animated")]
Animated,
}
impl InputProfilePhotoType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Static => "static",
Self::Animated => "animated",
}
}
}
impl fmt::Display for InputProfilePhotoType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for InputProfilePhotoType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<InputProfilePhotoType> for String {
fn from(value: InputProfilePhotoType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for InputProfilePhotoType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"static" => Ok(Self::Static),
"animated" => Ok(Self::Animated),
_ => Err(ParseTelegramEnumError {
enum_name: "InputProfilePhotoType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum InputRichBlockType {
#[serde(rename = "anchor")]
Anchor,
#[serde(rename = "animation")]
Animation,
#[serde(rename = "audio")]
Audio,
#[serde(rename = "blockquote")]
Blockquote,
#[serde(rename = "collage")]
Collage,
#[serde(rename = "details")]
Details,
#[serde(rename = "divider")]
Divider,
#[serde(rename = "footer")]
Footer,
#[serde(rename = "list")]
List,
#[serde(rename = "map")]
Map,
#[serde(rename = "mathematical_expression")]
MathematicalExpression,
#[serde(rename = "paragraph")]
Paragraph,
#[serde(rename = "photo")]
Photo,
#[serde(rename = "pre")]
Pre,
#[serde(rename = "pullquote")]
Pullquote,
#[serde(rename = "heading")]
Heading,
#[serde(rename = "slideshow")]
Slideshow,
#[serde(rename = "table")]
Table,
#[serde(rename = "thinking")]
Thinking,
#[serde(rename = "video")]
Video,
#[serde(rename = "voice_note")]
VoiceNote,
}
impl InputRichBlockType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Anchor => "anchor",
Self::Animation => "animation",
Self::Audio => "audio",
Self::Blockquote => "blockquote",
Self::Collage => "collage",
Self::Details => "details",
Self::Divider => "divider",
Self::Footer => "footer",
Self::List => "list",
Self::Map => "map",
Self::MathematicalExpression => "mathematical_expression",
Self::Paragraph => "paragraph",
Self::Photo => "photo",
Self::Pre => "pre",
Self::Pullquote => "pullquote",
Self::Heading => "heading",
Self::Slideshow => "slideshow",
Self::Table => "table",
Self::Thinking => "thinking",
Self::Video => "video",
Self::VoiceNote => "voice_note",
}
}
}
impl fmt::Display for InputRichBlockType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for InputRichBlockType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<InputRichBlockType> for String {
fn from(value: InputRichBlockType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for InputRichBlockType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"anchor" => Ok(Self::Anchor),
"animation" => Ok(Self::Animation),
"audio" => Ok(Self::Audio),
"blockquote" => Ok(Self::Blockquote),
"collage" => Ok(Self::Collage),
"details" => Ok(Self::Details),
"divider" => Ok(Self::Divider),
"footer" => Ok(Self::Footer),
"list" => Ok(Self::List),
"map" => Ok(Self::Map),
"mathematical_expression" => Ok(Self::MathematicalExpression),
"paragraph" => Ok(Self::Paragraph),
"photo" => Ok(Self::Photo),
"pre" => Ok(Self::Pre),
"pullquote" => Ok(Self::Pullquote),
"heading" => Ok(Self::Heading),
"slideshow" => Ok(Self::Slideshow),
"table" => Ok(Self::Table),
"thinking" => Ok(Self::Thinking),
"video" => Ok(Self::Video),
"voice_note" => Ok(Self::VoiceNote),
_ => Err(ParseTelegramEnumError {
enum_name: "InputRichBlockType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum InputStoryContentType {
#[serde(rename = "photo")]
Photo,
#[serde(rename = "video")]
Video,
}
impl InputStoryContentType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Photo => "photo",
Self::Video => "video",
}
}
}
impl fmt::Display for InputStoryContentType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for InputStoryContentType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<InputStoryContentType> for String {
fn from(value: InputStoryContentType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for InputStoryContentType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"photo" => Ok(Self::Photo),
"video" => Ok(Self::Video),
_ => Err(ParseTelegramEnumError {
enum_name: "InputStoryContentType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum KeyboardButtonPollTypeType {
#[serde(rename = "quiz")]
Quiz,
#[serde(rename = "regular")]
Regular,
}
impl KeyboardButtonPollTypeType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Quiz => "quiz",
Self::Regular => "regular",
}
}
}
impl fmt::Display for KeyboardButtonPollTypeType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for KeyboardButtonPollTypeType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<KeyboardButtonPollTypeType> for String {
fn from(value: KeyboardButtonPollTypeType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for KeyboardButtonPollTypeType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"quiz" => Ok(Self::Quiz),
"regular" => Ok(Self::Regular),
_ => Err(ParseTelegramEnumError {
enum_name: "KeyboardButtonPollTypeType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MaskPositionPoint {
#[serde(rename = "forehead")]
Forehead,
#[serde(rename = "eyes")]
Eyes,
#[serde(rename = "mouth")]
Mouth,
#[serde(rename = "chin")]
Chin,
}
impl MaskPositionPoint {
pub const fn as_str(self) -> &'static str {
match self {
Self::Forehead => "forehead",
Self::Eyes => "eyes",
Self::Mouth => "mouth",
Self::Chin => "chin",
}
}
}
impl fmt::Display for MaskPositionPoint {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for MaskPositionPoint {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<MaskPositionPoint> for String {
fn from(value: MaskPositionPoint) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for MaskPositionPoint {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"forehead" => Ok(Self::Forehead),
"eyes" => Ok(Self::Eyes),
"mouth" => Ok(Self::Mouth),
"chin" => Ok(Self::Chin),
_ => Err(ParseTelegramEnumError {
enum_name: "MaskPositionPoint",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MenuButtonType {
#[serde(rename = "default")]
Default,
#[serde(rename = "commands")]
Commands,
#[serde(rename = "web_app")]
WebApp,
}
impl MenuButtonType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Default => "default",
Self::Commands => "commands",
Self::WebApp => "web_app",
}
}
}
impl fmt::Display for MenuButtonType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for MenuButtonType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<MenuButtonType> for String {
fn from(value: MenuButtonType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for MenuButtonType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"default" => Ok(Self::Default),
"commands" => Ok(Self::Commands),
"web_app" => Ok(Self::WebApp),
_ => Err(ParseTelegramEnumError {
enum_name: "MenuButtonType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MessageEntityType {
#[serde(rename = "mention")]
Mention,
#[serde(rename = "hashtag")]
Hashtag,
#[serde(rename = "cashtag")]
Cashtag,
#[serde(rename = "bot_command")]
BotCommand,
#[serde(rename = "url")]
Url,
#[serde(rename = "email")]
Email,
#[serde(rename = "phone_number")]
PhoneNumber,
#[serde(rename = "bold")]
Bold,
#[serde(rename = "italic")]
Italic,
#[serde(rename = "underline")]
Underline,
#[serde(rename = "strikethrough")]
Strikethrough,
#[serde(rename = "spoiler")]
Spoiler,
#[serde(rename = "blockquote")]
Blockquote,
#[serde(rename = "expandable_blockquote")]
ExpandableBlockquote,
#[serde(rename = "code")]
Code,
#[serde(rename = "pre")]
Pre,
#[serde(rename = "text_link")]
TextLink,
#[serde(rename = "text_mention")]
TextMention,
#[serde(rename = "custom_emoji")]
CustomEmoji,
#[serde(rename = "date_time")]
DateTime,
}
impl MessageEntityType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Mention => "mention",
Self::Hashtag => "hashtag",
Self::Cashtag => "cashtag",
Self::BotCommand => "bot_command",
Self::Url => "url",
Self::Email => "email",
Self::PhoneNumber => "phone_number",
Self::Bold => "bold",
Self::Italic => "italic",
Self::Underline => "underline",
Self::Strikethrough => "strikethrough",
Self::Spoiler => "spoiler",
Self::Blockquote => "blockquote",
Self::ExpandableBlockquote => "expandable_blockquote",
Self::Code => "code",
Self::Pre => "pre",
Self::TextLink => "text_link",
Self::TextMention => "text_mention",
Self::CustomEmoji => "custom_emoji",
Self::DateTime => "date_time",
}
}
}
impl fmt::Display for MessageEntityType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for MessageEntityType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<MessageEntityType> for String {
fn from(value: MessageEntityType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for MessageEntityType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"mention" => Ok(Self::Mention),
"hashtag" => Ok(Self::Hashtag),
"cashtag" => Ok(Self::Cashtag),
"bot_command" => Ok(Self::BotCommand),
"url" => Ok(Self::Url),
"email" => Ok(Self::Email),
"phone_number" => Ok(Self::PhoneNumber),
"bold" => Ok(Self::Bold),
"italic" => Ok(Self::Italic),
"underline" => Ok(Self::Underline),
"strikethrough" => Ok(Self::Strikethrough),
"spoiler" => Ok(Self::Spoiler),
"blockquote" => Ok(Self::Blockquote),
"expandable_blockquote" => Ok(Self::ExpandableBlockquote),
"code" => Ok(Self::Code),
"pre" => Ok(Self::Pre),
"text_link" => Ok(Self::TextLink),
"text_mention" => Ok(Self::TextMention),
"custom_emoji" => Ok(Self::CustomEmoji),
"date_time" => Ok(Self::DateTime),
_ => Err(ParseTelegramEnumError {
enum_name: "MessageEntityType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MessageOriginType {
#[serde(rename = "user")]
User,
#[serde(rename = "hidden_user")]
HiddenUser,
#[serde(rename = "chat")]
Chat,
#[serde(rename = "channel")]
Channel,
}
impl MessageOriginType {
pub const fn as_str(self) -> &'static str {
match self {
Self::User => "user",
Self::HiddenUser => "hidden_user",
Self::Chat => "chat",
Self::Channel => "channel",
}
}
}
impl fmt::Display for MessageOriginType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for MessageOriginType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<MessageOriginType> for String {
fn from(value: MessageOriginType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for MessageOriginType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"user" => Ok(Self::User),
"hidden_user" => Ok(Self::HiddenUser),
"chat" => Ok(Self::Chat),
"channel" => Ok(Self::Channel),
_ => Err(ParseTelegramEnumError {
enum_name: "MessageOriginType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum OwnedGiftType {
#[serde(rename = "regular")]
Regular,
#[serde(rename = "unique")]
Unique,
}
impl OwnedGiftType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Regular => "regular",
Self::Unique => "unique",
}
}
}
impl fmt::Display for OwnedGiftType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for OwnedGiftType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<OwnedGiftType> for String {
fn from(value: OwnedGiftType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for OwnedGiftType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"regular" => Ok(Self::Regular),
"unique" => Ok(Self::Unique),
_ => Err(ParseTelegramEnumError {
enum_name: "OwnedGiftType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PaidMediaType {
#[serde(rename = "photo")]
Photo,
#[serde(rename = "preview")]
Preview,
#[serde(rename = "video")]
Video,
#[serde(rename = "live_photo")]
LivePhoto,
}
impl PaidMediaType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Photo => "photo",
Self::Preview => "preview",
Self::Video => "video",
Self::LivePhoto => "live_photo",
}
}
}
impl fmt::Display for PaidMediaType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for PaidMediaType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<PaidMediaType> for String {
fn from(value: PaidMediaType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for PaidMediaType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"photo" => Ok(Self::Photo),
"preview" => Ok(Self::Preview),
"video" => Ok(Self::Video),
"live_photo" => Ok(Self::LivePhoto),
_ => Err(ParseTelegramEnumError {
enum_name: "PaidMediaType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ParseMode {
#[serde(rename = "MarkdownV2")]
MarkdownV2,
#[serde(rename = "Markdown")]
Markdown,
#[serde(rename = "HTML")]
Html,
}
impl ParseMode {
pub const fn as_str(self) -> &'static str {
match self {
Self::MarkdownV2 => "MarkdownV2",
Self::Markdown => "Markdown",
Self::Html => "HTML",
}
}
}
impl fmt::Display for ParseMode {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for ParseMode {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<ParseMode> for String {
fn from(value: ParseMode) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for ParseMode {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"MarkdownV2" => Ok(Self::MarkdownV2),
"Markdown" => Ok(Self::Markdown),
"HTML" => Ok(Self::Html),
_ => Err(ParseTelegramEnumError {
enum_name: "ParseMode",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PassportElementErrorType {
#[serde(rename = "data")]
Data,
#[serde(rename = "front_side")]
FrontSide,
#[serde(rename = "reverse_side")]
ReverseSide,
#[serde(rename = "selfie")]
Selfie,
#[serde(rename = "file")]
File,
#[serde(rename = "files")]
Files,
#[serde(rename = "translation_file")]
TranslationFile,
#[serde(rename = "translation_files")]
TranslationFiles,
#[serde(rename = "unspecified")]
Unspecified,
}
impl PassportElementErrorType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Data => "data",
Self::FrontSide => "front_side",
Self::ReverseSide => "reverse_side",
Self::Selfie => "selfie",
Self::File => "file",
Self::Files => "files",
Self::TranslationFile => "translation_file",
Self::TranslationFiles => "translation_files",
Self::Unspecified => "unspecified",
}
}
}
impl fmt::Display for PassportElementErrorType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for PassportElementErrorType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<PassportElementErrorType> for String {
fn from(value: PassportElementErrorType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for PassportElementErrorType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"data" => Ok(Self::Data),
"front_side" => Ok(Self::FrontSide),
"reverse_side" => Ok(Self::ReverseSide),
"selfie" => Ok(Self::Selfie),
"file" => Ok(Self::File),
"files" => Ok(Self::Files),
"translation_file" => Ok(Self::TranslationFile),
"translation_files" => Ok(Self::TranslationFiles),
"unspecified" => Ok(Self::Unspecified),
_ => Err(ParseTelegramEnumError {
enum_name: "PassportElementErrorType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PollType {
#[serde(rename = "regular")]
Regular,
#[serde(rename = "quiz")]
Quiz,
}
impl PollType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Regular => "regular",
Self::Quiz => "quiz",
}
}
}
impl fmt::Display for PollType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for PollType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<PollType> for String {
fn from(value: PollType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for PollType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"regular" => Ok(Self::Regular),
"quiz" => Ok(Self::Quiz),
_ => Err(ParseTelegramEnumError {
enum_name: "PollType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ReactionTypeType {
#[serde(rename = "emoji")]
Emoji,
#[serde(rename = "custom_emoji")]
CustomEmoji,
#[serde(rename = "paid")]
Paid,
}
impl ReactionTypeType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Emoji => "emoji",
Self::CustomEmoji => "custom_emoji",
Self::Paid => "paid",
}
}
}
impl fmt::Display for ReactionTypeType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for ReactionTypeType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<ReactionTypeType> for String {
fn from(value: ReactionTypeType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for ReactionTypeType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"emoji" => Ok(Self::Emoji),
"custom_emoji" => Ok(Self::CustomEmoji),
"paid" => Ok(Self::Paid),
_ => Err(ParseTelegramEnumError {
enum_name: "ReactionTypeType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum RevenueWithdrawalStateType {
#[serde(rename = "failed")]
Failed,
#[serde(rename = "pending")]
Pending,
#[serde(rename = "succeeded")]
Succeeded,
}
impl RevenueWithdrawalStateType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Failed => "failed",
Self::Pending => "pending",
Self::Succeeded => "succeeded",
}
}
}
impl fmt::Display for RevenueWithdrawalStateType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for RevenueWithdrawalStateType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<RevenueWithdrawalStateType> for String {
fn from(value: RevenueWithdrawalStateType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for RevenueWithdrawalStateType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"failed" => Ok(Self::Failed),
"pending" => Ok(Self::Pending),
"succeeded" => Ok(Self::Succeeded),
_ => Err(ParseTelegramEnumError {
enum_name: "RevenueWithdrawalStateType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum RichBlockType {
#[serde(rename = "paragraph")]
Paragraph,
#[serde(rename = "heading")]
Heading,
#[serde(rename = "pre")]
Pre,
#[serde(rename = "footer")]
Footer,
#[serde(rename = "divider")]
Divider,
#[serde(rename = "mathematical_expression")]
MathematicalExpression,
#[serde(rename = "anchor")]
Anchor,
#[serde(rename = "list")]
List,
#[serde(rename = "blockquote")]
Blockquote,
#[serde(rename = "pullquote")]
Pullquote,
#[serde(rename = "collage")]
Collage,
#[serde(rename = "slideshow")]
Slideshow,
#[serde(rename = "table")]
Table,
#[serde(rename = "details")]
Details,
#[serde(rename = "map")]
Map,
#[serde(rename = "animation")]
Animation,
#[serde(rename = "audio")]
Audio,
#[serde(rename = "photo")]
Photo,
#[serde(rename = "video")]
Video,
#[serde(rename = "voice_note")]
VoiceNote,
#[serde(rename = "thinking")]
Thinking,
}
impl RichBlockType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Paragraph => "paragraph",
Self::Heading => "heading",
Self::Pre => "pre",
Self::Footer => "footer",
Self::Divider => "divider",
Self::MathematicalExpression => "mathematical_expression",
Self::Anchor => "anchor",
Self::List => "list",
Self::Blockquote => "blockquote",
Self::Pullquote => "pullquote",
Self::Collage => "collage",
Self::Slideshow => "slideshow",
Self::Table => "table",
Self::Details => "details",
Self::Map => "map",
Self::Animation => "animation",
Self::Audio => "audio",
Self::Photo => "photo",
Self::Video => "video",
Self::VoiceNote => "voice_note",
Self::Thinking => "thinking",
}
}
}
impl fmt::Display for RichBlockType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for RichBlockType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<RichBlockType> for String {
fn from(value: RichBlockType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for RichBlockType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"paragraph" => Ok(Self::Paragraph),
"heading" => Ok(Self::Heading),
"pre" => Ok(Self::Pre),
"footer" => Ok(Self::Footer),
"divider" => Ok(Self::Divider),
"mathematical_expression" => Ok(Self::MathematicalExpression),
"anchor" => Ok(Self::Anchor),
"list" => Ok(Self::List),
"blockquote" => Ok(Self::Blockquote),
"pullquote" => Ok(Self::Pullquote),
"collage" => Ok(Self::Collage),
"slideshow" => Ok(Self::Slideshow),
"table" => Ok(Self::Table),
"details" => Ok(Self::Details),
"map" => Ok(Self::Map),
"animation" => Ok(Self::Animation),
"audio" => Ok(Self::Audio),
"photo" => Ok(Self::Photo),
"video" => Ok(Self::Video),
"voice_note" => Ok(Self::VoiceNote),
"thinking" => Ok(Self::Thinking),
_ => Err(ParseTelegramEnumError {
enum_name: "RichBlockType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum RichTextType {
#[serde(rename = "bold")]
Bold,
#[serde(rename = "italic")]
Italic,
#[serde(rename = "underline")]
Underline,
#[serde(rename = "strikethrough")]
Strikethrough,
#[serde(rename = "spoiler")]
Spoiler,
#[serde(rename = "date_time")]
DateTime,
#[serde(rename = "text_mention")]
TextMention,
#[serde(rename = "subscript")]
Subscript,
#[serde(rename = "superscript")]
Superscript,
#[serde(rename = "marked")]
Marked,
#[serde(rename = "code")]
Code,
#[serde(rename = "custom_emoji")]
CustomEmoji,
#[serde(rename = "mathematical_expression")]
MathematicalExpression,
#[serde(rename = "url")]
Url,
#[serde(rename = "email_address")]
EmailAddress,
#[serde(rename = "phone_number")]
PhoneNumber,
#[serde(rename = "bank_card_number")]
BankCardNumber,
#[serde(rename = "mention")]
Mention,
#[serde(rename = "hashtag")]
Hashtag,
#[serde(rename = "cashtag")]
Cashtag,
#[serde(rename = "bot_command")]
BotCommand,
#[serde(rename = "anchor")]
Anchor,
#[serde(rename = "anchor_link")]
AnchorLink,
#[serde(rename = "reference")]
Reference,
#[serde(rename = "reference_link")]
ReferenceLink,
}
impl RichTextType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Bold => "bold",
Self::Italic => "italic",
Self::Underline => "underline",
Self::Strikethrough => "strikethrough",
Self::Spoiler => "spoiler",
Self::DateTime => "date_time",
Self::TextMention => "text_mention",
Self::Subscript => "subscript",
Self::Superscript => "superscript",
Self::Marked => "marked",
Self::Code => "code",
Self::CustomEmoji => "custom_emoji",
Self::MathematicalExpression => "mathematical_expression",
Self::Url => "url",
Self::EmailAddress => "email_address",
Self::PhoneNumber => "phone_number",
Self::BankCardNumber => "bank_card_number",
Self::Mention => "mention",
Self::Hashtag => "hashtag",
Self::Cashtag => "cashtag",
Self::BotCommand => "bot_command",
Self::Anchor => "anchor",
Self::AnchorLink => "anchor_link",
Self::Reference => "reference",
Self::ReferenceLink => "reference_link",
}
}
}
impl fmt::Display for RichTextType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for RichTextType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<RichTextType> for String {
fn from(value: RichTextType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for RichTextType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"bold" => Ok(Self::Bold),
"italic" => Ok(Self::Italic),
"underline" => Ok(Self::Underline),
"strikethrough" => Ok(Self::Strikethrough),
"spoiler" => Ok(Self::Spoiler),
"date_time" => Ok(Self::DateTime),
"text_mention" => Ok(Self::TextMention),
"subscript" => Ok(Self::Subscript),
"superscript" => Ok(Self::Superscript),
"marked" => Ok(Self::Marked),
"code" => Ok(Self::Code),
"custom_emoji" => Ok(Self::CustomEmoji),
"mathematical_expression" => Ok(Self::MathematicalExpression),
"url" => Ok(Self::Url),
"email_address" => Ok(Self::EmailAddress),
"phone_number" => Ok(Self::PhoneNumber),
"bank_card_number" => Ok(Self::BankCardNumber),
"mention" => Ok(Self::Mention),
"hashtag" => Ok(Self::Hashtag),
"cashtag" => Ok(Self::Cashtag),
"bot_command" => Ok(Self::BotCommand),
"anchor" => Ok(Self::Anchor),
"anchor_link" => Ok(Self::AnchorLink),
"reference" => Ok(Self::Reference),
"reference_link" => Ok(Self::ReferenceLink),
_ => Err(ParseTelegramEnumError {
enum_name: "RichTextType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum StickerFormat {
#[serde(rename = "static")]
Static,
#[serde(rename = "animated")]
Animated,
#[serde(rename = "video")]
Video,
}
impl StickerFormat {
pub const fn as_str(self) -> &'static str {
match self {
Self::Static => "static",
Self::Animated => "animated",
Self::Video => "video",
}
}
}
impl fmt::Display for StickerFormat {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for StickerFormat {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<StickerFormat> for String {
fn from(value: StickerFormat) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for StickerFormat {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"static" => Ok(Self::Static),
"animated" => Ok(Self::Animated),
"video" => Ok(Self::Video),
_ => Err(ParseTelegramEnumError {
enum_name: "StickerFormat",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum StickerType {
#[serde(rename = "regular")]
Regular,
#[serde(rename = "mask")]
Mask,
#[serde(rename = "custom_emoji")]
CustomEmoji,
}
impl StickerType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Regular => "regular",
Self::Mask => "mask",
Self::CustomEmoji => "custom_emoji",
}
}
}
impl fmt::Display for StickerType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for StickerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<StickerType> for String {
fn from(value: StickerType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for StickerType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"regular" => Ok(Self::Regular),
"mask" => Ok(Self::Mask),
"custom_emoji" => Ok(Self::CustomEmoji),
_ => Err(ParseTelegramEnumError {
enum_name: "StickerType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum StoryAreaTypeType {
#[serde(rename = "location")]
Location,
#[serde(rename = "suggested_reaction")]
SuggestedReaction,
#[serde(rename = "link")]
Link,
#[serde(rename = "weather")]
Weather,
#[serde(rename = "unique_gift")]
UniqueGift,
}
impl StoryAreaTypeType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Location => "location",
Self::SuggestedReaction => "suggested_reaction",
Self::Link => "link",
Self::Weather => "weather",
Self::UniqueGift => "unique_gift",
}
}
}
impl fmt::Display for StoryAreaTypeType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for StoryAreaTypeType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<StoryAreaTypeType> for String {
fn from(value: StoryAreaTypeType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for StoryAreaTypeType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"location" => Ok(Self::Location),
"suggested_reaction" => Ok(Self::SuggestedReaction),
"link" => Ok(Self::Link),
"weather" => Ok(Self::Weather),
"unique_gift" => Ok(Self::UniqueGift),
_ => Err(ParseTelegramEnumError {
enum_name: "StoryAreaTypeType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u32)]
pub enum TopicIconColor {
Blue = 0x6FB9F0,
Yellow = 0xFFD67E,
Violet = 0xCB86DB,
Green = 0x8EEE98,
Rose = 0xFF93B2,
Red = 0xFB6F5F,
}
impl TopicIconColor {
pub const fn as_u32(self) -> u32 {
self as u32
}
pub const fn from_u32(value: u32) -> Option<Self> {
match value {
value if value == Self::Blue as u32 => Some(Self::Blue),
value if value == Self::Yellow as u32 => Some(Self::Yellow),
value if value == Self::Violet as u32 => Some(Self::Violet),
value if value == Self::Green as u32 => Some(Self::Green),
value if value == Self::Rose as u32 => Some(Self::Rose),
value if value == Self::Red as u32 => Some(Self::Red),
_ => None,
}
}
}
impl Serialize for TopicIconColor {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_u32(self.as_u32())
}
}
impl<'de> Deserialize<'de> for TopicIconColor {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = u32::deserialize(deserializer)?;
Self::from_u32(value).ok_or_else(|| {
serde::de::Error::custom(format!("unknown TopicIconColor value: {value}"))
})
}
}
impl From<TopicIconColor> for u32 {
fn from(value: TopicIconColor) -> Self {
value.as_u32()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TransactionPartnerType {
#[serde(rename = "fragment")]
Fragment,
#[serde(rename = "other")]
Other,
#[serde(rename = "user")]
User,
#[serde(rename = "telegram_ads")]
TelegramAds,
#[serde(rename = "telegram_api")]
TelegramApi,
#[serde(rename = "affiliate_program")]
AffiliateProgram,
#[serde(rename = "chat")]
Chat,
}
impl TransactionPartnerType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Fragment => "fragment",
Self::Other => "other",
Self::User => "user",
Self::TelegramAds => "telegram_ads",
Self::TelegramApi => "telegram_api",
Self::AffiliateProgram => "affiliate_program",
Self::Chat => "chat",
}
}
}
impl fmt::Display for TransactionPartnerType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for TransactionPartnerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<TransactionPartnerType> for String {
fn from(value: TransactionPartnerType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for TransactionPartnerType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"fragment" => Ok(Self::Fragment),
"other" => Ok(Self::Other),
"user" => Ok(Self::User),
"telegram_ads" => Ok(Self::TelegramAds),
"telegram_api" => Ok(Self::TelegramApi),
"affiliate_program" => Ok(Self::AffiliateProgram),
"chat" => Ok(Self::Chat),
_ => Err(ParseTelegramEnumError {
enum_name: "TransactionPartnerType",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TransactionPartnerUserTransactionTypeEnum {
#[serde(rename = "invoice_payment")]
InvoicePayment,
#[serde(rename = "paid_media_payment")]
PaidMediaPayment,
#[serde(rename = "gift_purchase")]
GiftPurchase,
#[serde(rename = "premium_purchase")]
PremiumPurchase,
#[serde(rename = "business_account_transfer")]
BusinessAccountTransfer,
}
impl TransactionPartnerUserTransactionTypeEnum {
pub const fn as_str(self) -> &'static str {
match self {
Self::InvoicePayment => "invoice_payment",
Self::PaidMediaPayment => "paid_media_payment",
Self::GiftPurchase => "gift_purchase",
Self::PremiumPurchase => "premium_purchase",
Self::BusinessAccountTransfer => "business_account_transfer",
}
}
}
impl fmt::Display for TransactionPartnerUserTransactionTypeEnum {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for TransactionPartnerUserTransactionTypeEnum {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<TransactionPartnerUserTransactionTypeEnum> for String {
fn from(value: TransactionPartnerUserTransactionTypeEnum) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for TransactionPartnerUserTransactionTypeEnum {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"invoice_payment" => Ok(Self::InvoicePayment),
"paid_media_payment" => Ok(Self::PaidMediaPayment),
"gift_purchase" => Ok(Self::GiftPurchase),
"premium_purchase" => Ok(Self::PremiumPurchase),
"business_account_transfer" => Ok(Self::BusinessAccountTransfer),
_ => Err(ParseTelegramEnumError {
enum_name: "TransactionPartnerUserTransactionTypeEnum",
value: value.to_owned(),
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum UpdateType {
#[serde(rename = "message")]
Message,
#[serde(rename = "edited_message")]
EditedMessage,
#[serde(rename = "channel_post")]
ChannelPost,
#[serde(rename = "edited_channel_post")]
EditedChannelPost,
#[serde(rename = "business_connection")]
BusinessConnection,
#[serde(rename = "business_message")]
BusinessMessage,
#[serde(rename = "edited_business_message")]
EditedBusinessMessage,
#[serde(rename = "deleted_business_messages")]
DeletedBusinessMessages,
#[serde(rename = "guest_message")]
GuestMessage,
#[serde(rename = "message_reaction")]
MessageReaction,
#[serde(rename = "message_reaction_count")]
MessageReactionCount,
#[serde(rename = "inline_query")]
InlineQuery,
#[serde(rename = "chosen_inline_result")]
ChosenInlineResult,
#[serde(rename = "callback_query")]
CallbackQuery,
#[serde(rename = "shipping_query")]
ShippingQuery,
#[serde(rename = "pre_checkout_query")]
PreCheckoutQuery,
#[serde(rename = "purchased_paid_media")]
PurchasedPaidMedia,
#[serde(rename = "poll")]
Poll,
#[serde(rename = "poll_answer")]
PollAnswer,
#[serde(rename = "my_chat_member")]
MyChatMember,
#[serde(rename = "chat_member")]
ChatMember,
#[serde(rename = "chat_join_request")]
ChatJoinRequest,
#[serde(rename = "chat_boost")]
ChatBoost,
#[serde(rename = "removed_chat_boost")]
RemovedChatBoost,
#[serde(rename = "managed_bot")]
ManagedBot,
#[serde(rename = "subscription")]
Subscription,
}
impl UpdateType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Message => "message",
Self::EditedMessage => "edited_message",
Self::ChannelPost => "channel_post",
Self::EditedChannelPost => "edited_channel_post",
Self::BusinessConnection => "business_connection",
Self::BusinessMessage => "business_message",
Self::EditedBusinessMessage => "edited_business_message",
Self::DeletedBusinessMessages => "deleted_business_messages",
Self::GuestMessage => "guest_message",
Self::MessageReaction => "message_reaction",
Self::MessageReactionCount => "message_reaction_count",
Self::InlineQuery => "inline_query",
Self::ChosenInlineResult => "chosen_inline_result",
Self::CallbackQuery => "callback_query",
Self::ShippingQuery => "shipping_query",
Self::PreCheckoutQuery => "pre_checkout_query",
Self::PurchasedPaidMedia => "purchased_paid_media",
Self::Poll => "poll",
Self::PollAnswer => "poll_answer",
Self::MyChatMember => "my_chat_member",
Self::ChatMember => "chat_member",
Self::ChatJoinRequest => "chat_join_request",
Self::ChatBoost => "chat_boost",
Self::RemovedChatBoost => "removed_chat_boost",
Self::ManagedBot => "managed_bot",
Self::Subscription => "subscription",
}
}
}
impl fmt::Display for UpdateType {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl AsRef<str> for UpdateType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<UpdateType> for String {
fn from(value: UpdateType) -> Self {
value.as_str().to_owned()
}
}
impl FromStr for UpdateType {
type Err = ParseTelegramEnumError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"message" => Ok(Self::Message),
"edited_message" => Ok(Self::EditedMessage),
"channel_post" => Ok(Self::ChannelPost),
"edited_channel_post" => Ok(Self::EditedChannelPost),
"business_connection" => Ok(Self::BusinessConnection),
"business_message" => Ok(Self::BusinessMessage),
"edited_business_message" => Ok(Self::EditedBusinessMessage),
"deleted_business_messages" => Ok(Self::DeletedBusinessMessages),
"guest_message" => Ok(Self::GuestMessage),
"message_reaction" => Ok(Self::MessageReaction),
"message_reaction_count" => Ok(Self::MessageReactionCount),
"inline_query" => Ok(Self::InlineQuery),
"chosen_inline_result" => Ok(Self::ChosenInlineResult),
"callback_query" => Ok(Self::CallbackQuery),
"shipping_query" => Ok(Self::ShippingQuery),
"pre_checkout_query" => Ok(Self::PreCheckoutQuery),
"purchased_paid_media" => Ok(Self::PurchasedPaidMedia),
"poll" => Ok(Self::Poll),
"poll_answer" => Ok(Self::PollAnswer),
"my_chat_member" => Ok(Self::MyChatMember),
"chat_member" => Ok(Self::ChatMember),
"chat_join_request" => Ok(Self::ChatJoinRequest),
"chat_boost" => Ok(Self::ChatBoost),
"removed_chat_boost" => Ok(Self::RemovedChatBoost),
"managed_bot" => Ok(Self::ManagedBot),
"subscription" => Ok(Self::Subscription),
_ => Err(ParseTelegramEnumError {
enum_name: "UpdateType",
value: value.to_owned(),
}),
}
}
}