use crate::errors::Result;
use crate::types::*;
use uuid::Uuid;
use std::fmt::Debug;
pub trait TDMessageContent: Debug + RObject {}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(tag = "@type")]
pub enum MessageContent {
#[doc(hidden)]
#[default]
_Default,
#[serde(rename = "messageAnimatedEmoji")]
MessageAnimatedEmoji(MessageAnimatedEmoji),
#[serde(rename = "messageAnimation")]
MessageAnimation(MessageAnimation),
#[serde(rename = "messageAudio")]
MessageAudio(MessageAudio),
#[serde(rename = "messageBasicGroupChatCreate")]
MessageBasicGroupChatCreate(MessageBasicGroupChatCreate),
#[serde(rename = "messageCall")]
MessageCall(MessageCall),
#[serde(rename = "messageChatAddMembers")]
MessageChatAddMembers(MessageChatAddMembers),
#[serde(rename = "messageChatChangePhoto")]
MessageChatChangePhoto(MessageChatChangePhoto),
#[serde(rename = "messageChatChangeTitle")]
MessageChatChangeTitle(MessageChatChangeTitle),
#[serde(rename = "messageChatDeleteMember")]
MessageChatDeleteMember(MessageChatDeleteMember),
#[serde(rename = "messageChatDeletePhoto")]
MessageChatDeletePhoto(MessageChatDeletePhoto),
#[serde(rename = "messageChatJoinByLink")]
MessageChatJoinByLink(MessageChatJoinByLink),
#[serde(rename = "messageChatJoinByRequest")]
MessageChatJoinByRequest(MessageChatJoinByRequest),
#[serde(rename = "messageChatSetTheme")]
MessageChatSetTheme(MessageChatSetTheme),
#[serde(rename = "messageChatSetTtl")]
MessageChatSetTtl(MessageChatSetTtl),
#[serde(rename = "messageChatUpgradeFrom")]
MessageChatUpgradeFrom(MessageChatUpgradeFrom),
#[serde(rename = "messageChatUpgradeTo")]
MessageChatUpgradeTo(MessageChatUpgradeTo),
#[serde(rename = "messageContact")]
MessageContact(MessageContact),
#[serde(rename = "messageContactRegistered")]
MessageContactRegistered(MessageContactRegistered),
#[serde(rename = "messageCustomServiceAction")]
MessageCustomServiceAction(MessageCustomServiceAction),
#[serde(rename = "messageDice")]
MessageDice(Box<MessageDice>),
#[serde(rename = "messageDocument")]
MessageDocument(MessageDocument),
#[serde(rename = "messageExpiredPhoto")]
MessageExpiredPhoto(MessageExpiredPhoto),
#[serde(rename = "messageExpiredVideo")]
MessageExpiredVideo(MessageExpiredVideo),
#[serde(rename = "messageGame")]
MessageGame(MessageGame),
#[serde(rename = "messageGameScore")]
MessageGameScore(MessageGameScore),
#[serde(rename = "messageInviteVideoChatParticipants")]
MessageInviteVideoChatParticipants(MessageInviteVideoChatParticipants),
#[serde(rename = "messageInvoice")]
MessageInvoice(MessageInvoice),
#[serde(rename = "messageLocation")]
MessageLocation(MessageLocation),
#[serde(rename = "messagePassportDataReceived")]
MessagePassportDataReceived(MessagePassportDataReceived),
#[serde(rename = "messagePassportDataSent")]
MessagePassportDataSent(MessagePassportDataSent),
#[serde(rename = "messagePaymentSuccessful")]
MessagePaymentSuccessful(MessagePaymentSuccessful),
#[serde(rename = "messagePaymentSuccessfulBot")]
MessagePaymentSuccessfulBot(MessagePaymentSuccessfulBot),
#[serde(rename = "messagePhoto")]
MessagePhoto(MessagePhoto),
#[serde(rename = "messagePinMessage")]
MessagePinMessage(MessagePinMessage),
#[serde(rename = "messagePoll")]
MessagePoll(MessagePoll),
#[serde(rename = "messageProximityAlertTriggered")]
MessageProximityAlertTriggered(MessageProximityAlertTriggered),
#[serde(rename = "messageScreenshotTaken")]
MessageScreenshotTaken(MessageScreenshotTaken),
#[serde(rename = "messageSticker")]
MessageSticker(MessageSticker),
#[serde(rename = "messageSupergroupChatCreate")]
MessageSupergroupChatCreate(MessageSupergroupChatCreate),
#[serde(rename = "messageText")]
MessageText(Box<MessageText>),
#[serde(rename = "messageUnsupported")]
MessageUnsupported(MessageUnsupported),
#[serde(rename = "messageVenue")]
MessageVenue(MessageVenue),
#[serde(rename = "messageVideo")]
MessageVideo(MessageVideo),
#[serde(rename = "messageVideoChatEnded")]
MessageVideoChatEnded(MessageVideoChatEnded),
#[serde(rename = "messageVideoChatScheduled")]
MessageVideoChatScheduled(MessageVideoChatScheduled),
#[serde(rename = "messageVideoChatStarted")]
MessageVideoChatStarted(MessageVideoChatStarted),
#[serde(rename = "messageVideoNote")]
MessageVideoNote(MessageVideoNote),
#[serde(rename = "messageVoiceNote")]
MessageVoiceNote(MessageVoiceNote),
#[serde(rename = "messageWebsiteConnected")]
MessageWebsiteConnected(MessageWebsiteConnected),
}
impl RObject for MessageContent {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
match self {
MessageContent::MessageAnimatedEmoji(t) => t.extra(),
MessageContent::MessageAnimation(t) => t.extra(),
MessageContent::MessageAudio(t) => t.extra(),
MessageContent::MessageBasicGroupChatCreate(t) => t.extra(),
MessageContent::MessageCall(t) => t.extra(),
MessageContent::MessageChatAddMembers(t) => t.extra(),
MessageContent::MessageChatChangePhoto(t) => t.extra(),
MessageContent::MessageChatChangeTitle(t) => t.extra(),
MessageContent::MessageChatDeleteMember(t) => t.extra(),
MessageContent::MessageChatDeletePhoto(t) => t.extra(),
MessageContent::MessageChatJoinByLink(t) => t.extra(),
MessageContent::MessageChatJoinByRequest(t) => t.extra(),
MessageContent::MessageChatSetTheme(t) => t.extra(),
MessageContent::MessageChatSetTtl(t) => t.extra(),
MessageContent::MessageChatUpgradeFrom(t) => t.extra(),
MessageContent::MessageChatUpgradeTo(t) => t.extra(),
MessageContent::MessageContact(t) => t.extra(),
MessageContent::MessageContactRegistered(t) => t.extra(),
MessageContent::MessageCustomServiceAction(t) => t.extra(),
MessageContent::MessageDice(t) => t.extra(),
MessageContent::MessageDocument(t) => t.extra(),
MessageContent::MessageExpiredPhoto(t) => t.extra(),
MessageContent::MessageExpiredVideo(t) => t.extra(),
MessageContent::MessageGame(t) => t.extra(),
MessageContent::MessageGameScore(t) => t.extra(),
MessageContent::MessageInviteVideoChatParticipants(t) => t.extra(),
MessageContent::MessageInvoice(t) => t.extra(),
MessageContent::MessageLocation(t) => t.extra(),
MessageContent::MessagePassportDataReceived(t) => t.extra(),
MessageContent::MessagePassportDataSent(t) => t.extra(),
MessageContent::MessagePaymentSuccessful(t) => t.extra(),
MessageContent::MessagePaymentSuccessfulBot(t) => t.extra(),
MessageContent::MessagePhoto(t) => t.extra(),
MessageContent::MessagePinMessage(t) => t.extra(),
MessageContent::MessagePoll(t) => t.extra(),
MessageContent::MessageProximityAlertTriggered(t) => t.extra(),
MessageContent::MessageScreenshotTaken(t) => t.extra(),
MessageContent::MessageSticker(t) => t.extra(),
MessageContent::MessageSupergroupChatCreate(t) => t.extra(),
MessageContent::MessageText(t) => t.extra(),
MessageContent::MessageUnsupported(t) => t.extra(),
MessageContent::MessageVenue(t) => t.extra(),
MessageContent::MessageVideo(t) => t.extra(),
MessageContent::MessageVideoChatEnded(t) => t.extra(),
MessageContent::MessageVideoChatScheduled(t) => t.extra(),
MessageContent::MessageVideoChatStarted(t) => t.extra(),
MessageContent::MessageVideoNote(t) => t.extra(),
MessageContent::MessageVoiceNote(t) => t.extra(),
MessageContent::MessageWebsiteConnected(t) => t.extra(),
_ => None,
}
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
match self {
MessageContent::MessageAnimatedEmoji(t) => t.client_id(),
MessageContent::MessageAnimation(t) => t.client_id(),
MessageContent::MessageAudio(t) => t.client_id(),
MessageContent::MessageBasicGroupChatCreate(t) => t.client_id(),
MessageContent::MessageCall(t) => t.client_id(),
MessageContent::MessageChatAddMembers(t) => t.client_id(),
MessageContent::MessageChatChangePhoto(t) => t.client_id(),
MessageContent::MessageChatChangeTitle(t) => t.client_id(),
MessageContent::MessageChatDeleteMember(t) => t.client_id(),
MessageContent::MessageChatDeletePhoto(t) => t.client_id(),
MessageContent::MessageChatJoinByLink(t) => t.client_id(),
MessageContent::MessageChatJoinByRequest(t) => t.client_id(),
MessageContent::MessageChatSetTheme(t) => t.client_id(),
MessageContent::MessageChatSetTtl(t) => t.client_id(),
MessageContent::MessageChatUpgradeFrom(t) => t.client_id(),
MessageContent::MessageChatUpgradeTo(t) => t.client_id(),
MessageContent::MessageContact(t) => t.client_id(),
MessageContent::MessageContactRegistered(t) => t.client_id(),
MessageContent::MessageCustomServiceAction(t) => t.client_id(),
MessageContent::MessageDice(t) => t.client_id(),
MessageContent::MessageDocument(t) => t.client_id(),
MessageContent::MessageExpiredPhoto(t) => t.client_id(),
MessageContent::MessageExpiredVideo(t) => t.client_id(),
MessageContent::MessageGame(t) => t.client_id(),
MessageContent::MessageGameScore(t) => t.client_id(),
MessageContent::MessageInviteVideoChatParticipants(t) => t.client_id(),
MessageContent::MessageInvoice(t) => t.client_id(),
MessageContent::MessageLocation(t) => t.client_id(),
MessageContent::MessagePassportDataReceived(t) => t.client_id(),
MessageContent::MessagePassportDataSent(t) => t.client_id(),
MessageContent::MessagePaymentSuccessful(t) => t.client_id(),
MessageContent::MessagePaymentSuccessfulBot(t) => t.client_id(),
MessageContent::MessagePhoto(t) => t.client_id(),
MessageContent::MessagePinMessage(t) => t.client_id(),
MessageContent::MessagePoll(t) => t.client_id(),
MessageContent::MessageProximityAlertTriggered(t) => t.client_id(),
MessageContent::MessageScreenshotTaken(t) => t.client_id(),
MessageContent::MessageSticker(t) => t.client_id(),
MessageContent::MessageSupergroupChatCreate(t) => t.client_id(),
MessageContent::MessageText(t) => t.client_id(),
MessageContent::MessageUnsupported(t) => t.client_id(),
MessageContent::MessageVenue(t) => t.client_id(),
MessageContent::MessageVideo(t) => t.client_id(),
MessageContent::MessageVideoChatEnded(t) => t.client_id(),
MessageContent::MessageVideoChatScheduled(t) => t.client_id(),
MessageContent::MessageVideoChatStarted(t) => t.client_id(),
MessageContent::MessageVideoNote(t) => t.client_id(),
MessageContent::MessageVoiceNote(t) => t.client_id(),
MessageContent::MessageWebsiteConnected(t) => t.client_id(),
_ => None,
}
}
}
impl MessageContent {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
#[doc(hidden)]
pub fn _is_default(&self) -> bool {
matches!(self, MessageContent::_Default)
}
}
impl AsRef<MessageContent> for MessageContent {
fn as_ref(&self) -> &MessageContent {
self
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageAnimatedEmoji {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
animated_emoji: AnimatedEmoji,
#[serde(default)]
emoji: String,
}
impl RObject for MessageAnimatedEmoji {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageAnimatedEmoji {}
impl MessageAnimatedEmoji {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageAnimatedEmojiBuilder {
let mut inner = MessageAnimatedEmoji::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageAnimatedEmojiBuilder { inner }
}
pub fn animated_emoji(&self) -> &AnimatedEmoji {
&self.animated_emoji
}
pub fn emoji(&self) -> &String {
&self.emoji
}
}
#[doc(hidden)]
pub struct MessageAnimatedEmojiBuilder {
inner: MessageAnimatedEmoji,
}
#[deprecated]
pub type RTDMessageAnimatedEmojiBuilder = MessageAnimatedEmojiBuilder;
impl MessageAnimatedEmojiBuilder {
pub fn build(&self) -> MessageAnimatedEmoji {
self.inner.clone()
}
pub fn animated_emoji<T: AsRef<AnimatedEmoji>>(&mut self, animated_emoji: T) -> &mut Self {
self.inner.animated_emoji = animated_emoji.as_ref().clone();
self
}
pub fn emoji<T: AsRef<str>>(&mut self, emoji: T) -> &mut Self {
self.inner.emoji = emoji.as_ref().to_string();
self
}
}
impl AsRef<MessageAnimatedEmoji> for MessageAnimatedEmoji {
fn as_ref(&self) -> &MessageAnimatedEmoji {
self
}
}
impl AsRef<MessageAnimatedEmoji> for MessageAnimatedEmojiBuilder {
fn as_ref(&self) -> &MessageAnimatedEmoji {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageAnimation {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
animation: Animation,
caption: FormattedText,
#[serde(default)]
is_secret: bool,
}
impl RObject for MessageAnimation {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageAnimation {}
impl MessageAnimation {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageAnimationBuilder {
let mut inner = MessageAnimation::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageAnimationBuilder { inner }
}
pub fn animation(&self) -> &Animation {
&self.animation
}
pub fn caption(&self) -> &FormattedText {
&self.caption
}
pub fn is_secret(&self) -> bool {
self.is_secret
}
}
#[doc(hidden)]
pub struct MessageAnimationBuilder {
inner: MessageAnimation,
}
#[deprecated]
pub type RTDMessageAnimationBuilder = MessageAnimationBuilder;
impl MessageAnimationBuilder {
pub fn build(&self) -> MessageAnimation {
self.inner.clone()
}
pub fn animation<T: AsRef<Animation>>(&mut self, animation: T) -> &mut Self {
self.inner.animation = animation.as_ref().clone();
self
}
pub fn caption<T: AsRef<FormattedText>>(&mut self, caption: T) -> &mut Self {
self.inner.caption = caption.as_ref().clone();
self
}
pub fn is_secret(&mut self, is_secret: bool) -> &mut Self {
self.inner.is_secret = is_secret;
self
}
}
impl AsRef<MessageAnimation> for MessageAnimation {
fn as_ref(&self) -> &MessageAnimation {
self
}
}
impl AsRef<MessageAnimation> for MessageAnimationBuilder {
fn as_ref(&self) -> &MessageAnimation {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageAudio {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
audio: Audio,
caption: FormattedText,
}
impl RObject for MessageAudio {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageAudio {}
impl MessageAudio {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageAudioBuilder {
let mut inner = MessageAudio::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageAudioBuilder { inner }
}
pub fn audio(&self) -> &Audio {
&self.audio
}
pub fn caption(&self) -> &FormattedText {
&self.caption
}
}
#[doc(hidden)]
pub struct MessageAudioBuilder {
inner: MessageAudio,
}
#[deprecated]
pub type RTDMessageAudioBuilder = MessageAudioBuilder;
impl MessageAudioBuilder {
pub fn build(&self) -> MessageAudio {
self.inner.clone()
}
pub fn audio<T: AsRef<Audio>>(&mut self, audio: T) -> &mut Self {
self.inner.audio = audio.as_ref().clone();
self
}
pub fn caption<T: AsRef<FormattedText>>(&mut self, caption: T) -> &mut Self {
self.inner.caption = caption.as_ref().clone();
self
}
}
impl AsRef<MessageAudio> for MessageAudio {
fn as_ref(&self) -> &MessageAudio {
self
}
}
impl AsRef<MessageAudio> for MessageAudioBuilder {
fn as_ref(&self) -> &MessageAudio {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageBasicGroupChatCreate {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
title: String,
#[serde(default)]
member_user_ids: Vec<i64>,
}
impl RObject for MessageBasicGroupChatCreate {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageBasicGroupChatCreate {}
impl MessageBasicGroupChatCreate {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageBasicGroupChatCreateBuilder {
let mut inner = MessageBasicGroupChatCreate::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageBasicGroupChatCreateBuilder { inner }
}
pub fn title(&self) -> &String {
&self.title
}
pub fn member_user_ids(&self) -> &Vec<i64> {
&self.member_user_ids
}
}
#[doc(hidden)]
pub struct MessageBasicGroupChatCreateBuilder {
inner: MessageBasicGroupChatCreate,
}
#[deprecated]
pub type RTDMessageBasicGroupChatCreateBuilder = MessageBasicGroupChatCreateBuilder;
impl MessageBasicGroupChatCreateBuilder {
pub fn build(&self) -> MessageBasicGroupChatCreate {
self.inner.clone()
}
pub fn title<T: AsRef<str>>(&mut self, title: T) -> &mut Self {
self.inner.title = title.as_ref().to_string();
self
}
pub fn member_user_ids(&mut self, member_user_ids: Vec<i64>) -> &mut Self {
self.inner.member_user_ids = member_user_ids;
self
}
}
impl AsRef<MessageBasicGroupChatCreate> for MessageBasicGroupChatCreate {
fn as_ref(&self) -> &MessageBasicGroupChatCreate {
self
}
}
impl AsRef<MessageBasicGroupChatCreate> for MessageBasicGroupChatCreateBuilder {
fn as_ref(&self) -> &MessageBasicGroupChatCreate {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageCall {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
is_video: bool,
#[serde(skip_serializing_if = "CallDiscardReason::_is_default")]
discard_reason: CallDiscardReason,
#[serde(default)]
duration: i32,
}
impl RObject for MessageCall {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageCall {}
impl MessageCall {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageCallBuilder {
let mut inner = MessageCall::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageCallBuilder { inner }
}
pub fn is_video(&self) -> bool {
self.is_video
}
pub fn discard_reason(&self) -> &CallDiscardReason {
&self.discard_reason
}
pub fn duration(&self) -> i32 {
self.duration
}
}
#[doc(hidden)]
pub struct MessageCallBuilder {
inner: MessageCall,
}
#[deprecated]
pub type RTDMessageCallBuilder = MessageCallBuilder;
impl MessageCallBuilder {
pub fn build(&self) -> MessageCall {
self.inner.clone()
}
pub fn is_video(&mut self, is_video: bool) -> &mut Self {
self.inner.is_video = is_video;
self
}
pub fn discard_reason<T: AsRef<CallDiscardReason>>(&mut self, discard_reason: T) -> &mut Self {
self.inner.discard_reason = discard_reason.as_ref().clone();
self
}
pub fn duration(&mut self, duration: i32) -> &mut Self {
self.inner.duration = duration;
self
}
}
impl AsRef<MessageCall> for MessageCall {
fn as_ref(&self) -> &MessageCall {
self
}
}
impl AsRef<MessageCall> for MessageCallBuilder {
fn as_ref(&self) -> &MessageCall {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatAddMembers {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
member_user_ids: Vec<i64>,
}
impl RObject for MessageChatAddMembers {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatAddMembers {}
impl MessageChatAddMembers {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatAddMembersBuilder {
let mut inner = MessageChatAddMembers::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatAddMembersBuilder { inner }
}
pub fn member_user_ids(&self) -> &Vec<i64> {
&self.member_user_ids
}
}
#[doc(hidden)]
pub struct MessageChatAddMembersBuilder {
inner: MessageChatAddMembers,
}
#[deprecated]
pub type RTDMessageChatAddMembersBuilder = MessageChatAddMembersBuilder;
impl MessageChatAddMembersBuilder {
pub fn build(&self) -> MessageChatAddMembers {
self.inner.clone()
}
pub fn member_user_ids(&mut self, member_user_ids: Vec<i64>) -> &mut Self {
self.inner.member_user_ids = member_user_ids;
self
}
}
impl AsRef<MessageChatAddMembers> for MessageChatAddMembers {
fn as_ref(&self) -> &MessageChatAddMembers {
self
}
}
impl AsRef<MessageChatAddMembers> for MessageChatAddMembersBuilder {
fn as_ref(&self) -> &MessageChatAddMembers {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatChangePhoto {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
photo: ChatPhoto,
}
impl RObject for MessageChatChangePhoto {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatChangePhoto {}
impl MessageChatChangePhoto {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatChangePhotoBuilder {
let mut inner = MessageChatChangePhoto::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatChangePhotoBuilder { inner }
}
pub fn photo(&self) -> &ChatPhoto {
&self.photo
}
}
#[doc(hidden)]
pub struct MessageChatChangePhotoBuilder {
inner: MessageChatChangePhoto,
}
#[deprecated]
pub type RTDMessageChatChangePhotoBuilder = MessageChatChangePhotoBuilder;
impl MessageChatChangePhotoBuilder {
pub fn build(&self) -> MessageChatChangePhoto {
self.inner.clone()
}
pub fn photo<T: AsRef<ChatPhoto>>(&mut self, photo: T) -> &mut Self {
self.inner.photo = photo.as_ref().clone();
self
}
}
impl AsRef<MessageChatChangePhoto> for MessageChatChangePhoto {
fn as_ref(&self) -> &MessageChatChangePhoto {
self
}
}
impl AsRef<MessageChatChangePhoto> for MessageChatChangePhotoBuilder {
fn as_ref(&self) -> &MessageChatChangePhoto {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatChangeTitle {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
title: String,
}
impl RObject for MessageChatChangeTitle {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatChangeTitle {}
impl MessageChatChangeTitle {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatChangeTitleBuilder {
let mut inner = MessageChatChangeTitle::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatChangeTitleBuilder { inner }
}
pub fn title(&self) -> &String {
&self.title
}
}
#[doc(hidden)]
pub struct MessageChatChangeTitleBuilder {
inner: MessageChatChangeTitle,
}
#[deprecated]
pub type RTDMessageChatChangeTitleBuilder = MessageChatChangeTitleBuilder;
impl MessageChatChangeTitleBuilder {
pub fn build(&self) -> MessageChatChangeTitle {
self.inner.clone()
}
pub fn title<T: AsRef<str>>(&mut self, title: T) -> &mut Self {
self.inner.title = title.as_ref().to_string();
self
}
}
impl AsRef<MessageChatChangeTitle> for MessageChatChangeTitle {
fn as_ref(&self) -> &MessageChatChangeTitle {
self
}
}
impl AsRef<MessageChatChangeTitle> for MessageChatChangeTitleBuilder {
fn as_ref(&self) -> &MessageChatChangeTitle {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatDeleteMember {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
user_id: i64,
}
impl RObject for MessageChatDeleteMember {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatDeleteMember {}
impl MessageChatDeleteMember {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatDeleteMemberBuilder {
let mut inner = MessageChatDeleteMember::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatDeleteMemberBuilder { inner }
}
pub fn user_id(&self) -> i64 {
self.user_id
}
}
#[doc(hidden)]
pub struct MessageChatDeleteMemberBuilder {
inner: MessageChatDeleteMember,
}
#[deprecated]
pub type RTDMessageChatDeleteMemberBuilder = MessageChatDeleteMemberBuilder;
impl MessageChatDeleteMemberBuilder {
pub fn build(&self) -> MessageChatDeleteMember {
self.inner.clone()
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<MessageChatDeleteMember> for MessageChatDeleteMember {
fn as_ref(&self) -> &MessageChatDeleteMember {
self
}
}
impl AsRef<MessageChatDeleteMember> for MessageChatDeleteMemberBuilder {
fn as_ref(&self) -> &MessageChatDeleteMember {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatDeletePhoto {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
}
impl RObject for MessageChatDeletePhoto {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatDeletePhoto {}
impl MessageChatDeletePhoto {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatDeletePhotoBuilder {
let mut inner = MessageChatDeletePhoto::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatDeletePhotoBuilder { inner }
}
}
#[doc(hidden)]
pub struct MessageChatDeletePhotoBuilder {
inner: MessageChatDeletePhoto,
}
#[deprecated]
pub type RTDMessageChatDeletePhotoBuilder = MessageChatDeletePhotoBuilder;
impl MessageChatDeletePhotoBuilder {
pub fn build(&self) -> MessageChatDeletePhoto {
self.inner.clone()
}
}
impl AsRef<MessageChatDeletePhoto> for MessageChatDeletePhoto {
fn as_ref(&self) -> &MessageChatDeletePhoto {
self
}
}
impl AsRef<MessageChatDeletePhoto> for MessageChatDeletePhotoBuilder {
fn as_ref(&self) -> &MessageChatDeletePhoto {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatJoinByLink {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
}
impl RObject for MessageChatJoinByLink {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatJoinByLink {}
impl MessageChatJoinByLink {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatJoinByLinkBuilder {
let mut inner = MessageChatJoinByLink::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatJoinByLinkBuilder { inner }
}
}
#[doc(hidden)]
pub struct MessageChatJoinByLinkBuilder {
inner: MessageChatJoinByLink,
}
#[deprecated]
pub type RTDMessageChatJoinByLinkBuilder = MessageChatJoinByLinkBuilder;
impl MessageChatJoinByLinkBuilder {
pub fn build(&self) -> MessageChatJoinByLink {
self.inner.clone()
}
}
impl AsRef<MessageChatJoinByLink> for MessageChatJoinByLink {
fn as_ref(&self) -> &MessageChatJoinByLink {
self
}
}
impl AsRef<MessageChatJoinByLink> for MessageChatJoinByLinkBuilder {
fn as_ref(&self) -> &MessageChatJoinByLink {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatJoinByRequest {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
}
impl RObject for MessageChatJoinByRequest {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatJoinByRequest {}
impl MessageChatJoinByRequest {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatJoinByRequestBuilder {
let mut inner = MessageChatJoinByRequest::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatJoinByRequestBuilder { inner }
}
}
#[doc(hidden)]
pub struct MessageChatJoinByRequestBuilder {
inner: MessageChatJoinByRequest,
}
#[deprecated]
pub type RTDMessageChatJoinByRequestBuilder = MessageChatJoinByRequestBuilder;
impl MessageChatJoinByRequestBuilder {
pub fn build(&self) -> MessageChatJoinByRequest {
self.inner.clone()
}
}
impl AsRef<MessageChatJoinByRequest> for MessageChatJoinByRequest {
fn as_ref(&self) -> &MessageChatJoinByRequest {
self
}
}
impl AsRef<MessageChatJoinByRequest> for MessageChatJoinByRequestBuilder {
fn as_ref(&self) -> &MessageChatJoinByRequest {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatSetTheme {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
theme_name: String,
}
impl RObject for MessageChatSetTheme {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatSetTheme {}
impl MessageChatSetTheme {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatSetThemeBuilder {
let mut inner = MessageChatSetTheme::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatSetThemeBuilder { inner }
}
pub fn theme_name(&self) -> &String {
&self.theme_name
}
}
#[doc(hidden)]
pub struct MessageChatSetThemeBuilder {
inner: MessageChatSetTheme,
}
#[deprecated]
pub type RTDMessageChatSetThemeBuilder = MessageChatSetThemeBuilder;
impl MessageChatSetThemeBuilder {
pub fn build(&self) -> MessageChatSetTheme {
self.inner.clone()
}
pub fn theme_name<T: AsRef<str>>(&mut self, theme_name: T) -> &mut Self {
self.inner.theme_name = theme_name.as_ref().to_string();
self
}
}
impl AsRef<MessageChatSetTheme> for MessageChatSetTheme {
fn as_ref(&self) -> &MessageChatSetTheme {
self
}
}
impl AsRef<MessageChatSetTheme> for MessageChatSetThemeBuilder {
fn as_ref(&self) -> &MessageChatSetTheme {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatSetTtl {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
ttl: i32,
}
impl RObject for MessageChatSetTtl {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatSetTtl {}
impl MessageChatSetTtl {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatSetTtlBuilder {
let mut inner = MessageChatSetTtl::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatSetTtlBuilder { inner }
}
pub fn ttl(&self) -> i32 {
self.ttl
}
}
#[doc(hidden)]
pub struct MessageChatSetTtlBuilder {
inner: MessageChatSetTtl,
}
#[deprecated]
pub type RTDMessageChatSetTtlBuilder = MessageChatSetTtlBuilder;
impl MessageChatSetTtlBuilder {
pub fn build(&self) -> MessageChatSetTtl {
self.inner.clone()
}
pub fn ttl(&mut self, ttl: i32) -> &mut Self {
self.inner.ttl = ttl;
self
}
}
impl AsRef<MessageChatSetTtl> for MessageChatSetTtl {
fn as_ref(&self) -> &MessageChatSetTtl {
self
}
}
impl AsRef<MessageChatSetTtl> for MessageChatSetTtlBuilder {
fn as_ref(&self) -> &MessageChatSetTtl {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatUpgradeFrom {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
title: String,
#[serde(default)]
basic_group_id: i64,
}
impl RObject for MessageChatUpgradeFrom {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatUpgradeFrom {}
impl MessageChatUpgradeFrom {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatUpgradeFromBuilder {
let mut inner = MessageChatUpgradeFrom::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatUpgradeFromBuilder { inner }
}
pub fn title(&self) -> &String {
&self.title
}
pub fn basic_group_id(&self) -> i64 {
self.basic_group_id
}
}
#[doc(hidden)]
pub struct MessageChatUpgradeFromBuilder {
inner: MessageChatUpgradeFrom,
}
#[deprecated]
pub type RTDMessageChatUpgradeFromBuilder = MessageChatUpgradeFromBuilder;
impl MessageChatUpgradeFromBuilder {
pub fn build(&self) -> MessageChatUpgradeFrom {
self.inner.clone()
}
pub fn title<T: AsRef<str>>(&mut self, title: T) -> &mut Self {
self.inner.title = title.as_ref().to_string();
self
}
pub fn basic_group_id(&mut self, basic_group_id: i64) -> &mut Self {
self.inner.basic_group_id = basic_group_id;
self
}
}
impl AsRef<MessageChatUpgradeFrom> for MessageChatUpgradeFrom {
fn as_ref(&self) -> &MessageChatUpgradeFrom {
self
}
}
impl AsRef<MessageChatUpgradeFrom> for MessageChatUpgradeFromBuilder {
fn as_ref(&self) -> &MessageChatUpgradeFrom {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageChatUpgradeTo {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
supergroup_id: i64,
}
impl RObject for MessageChatUpgradeTo {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageChatUpgradeTo {}
impl MessageChatUpgradeTo {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageChatUpgradeToBuilder {
let mut inner = MessageChatUpgradeTo::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageChatUpgradeToBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 {
self.supergroup_id
}
}
#[doc(hidden)]
pub struct MessageChatUpgradeToBuilder {
inner: MessageChatUpgradeTo,
}
#[deprecated]
pub type RTDMessageChatUpgradeToBuilder = MessageChatUpgradeToBuilder;
impl MessageChatUpgradeToBuilder {
pub fn build(&self) -> MessageChatUpgradeTo {
self.inner.clone()
}
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
}
impl AsRef<MessageChatUpgradeTo> for MessageChatUpgradeTo {
fn as_ref(&self) -> &MessageChatUpgradeTo {
self
}
}
impl AsRef<MessageChatUpgradeTo> for MessageChatUpgradeToBuilder {
fn as_ref(&self) -> &MessageChatUpgradeTo {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageContact {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
contact: Contact,
}
impl RObject for MessageContact {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageContact {}
impl MessageContact {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageContactBuilder {
let mut inner = MessageContact::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageContactBuilder { inner }
}
pub fn contact(&self) -> &Contact {
&self.contact
}
}
#[doc(hidden)]
pub struct MessageContactBuilder {
inner: MessageContact,
}
#[deprecated]
pub type RTDMessageContactBuilder = MessageContactBuilder;
impl MessageContactBuilder {
pub fn build(&self) -> MessageContact {
self.inner.clone()
}
pub fn contact<T: AsRef<Contact>>(&mut self, contact: T) -> &mut Self {
self.inner.contact = contact.as_ref().clone();
self
}
}
impl AsRef<MessageContact> for MessageContact {
fn as_ref(&self) -> &MessageContact {
self
}
}
impl AsRef<MessageContact> for MessageContactBuilder {
fn as_ref(&self) -> &MessageContact {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageContactRegistered {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
}
impl RObject for MessageContactRegistered {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageContactRegistered {}
impl MessageContactRegistered {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageContactRegisteredBuilder {
let mut inner = MessageContactRegistered::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageContactRegisteredBuilder { inner }
}
}
#[doc(hidden)]
pub struct MessageContactRegisteredBuilder {
inner: MessageContactRegistered,
}
#[deprecated]
pub type RTDMessageContactRegisteredBuilder = MessageContactRegisteredBuilder;
impl MessageContactRegisteredBuilder {
pub fn build(&self) -> MessageContactRegistered {
self.inner.clone()
}
}
impl AsRef<MessageContactRegistered> for MessageContactRegistered {
fn as_ref(&self) -> &MessageContactRegistered {
self
}
}
impl AsRef<MessageContactRegistered> for MessageContactRegisteredBuilder {
fn as_ref(&self) -> &MessageContactRegistered {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageCustomServiceAction {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
text: String,
}
impl RObject for MessageCustomServiceAction {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageCustomServiceAction {}
impl MessageCustomServiceAction {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageCustomServiceActionBuilder {
let mut inner = MessageCustomServiceAction::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageCustomServiceActionBuilder { inner }
}
pub fn text(&self) -> &String {
&self.text
}
}
#[doc(hidden)]
pub struct MessageCustomServiceActionBuilder {
inner: MessageCustomServiceAction,
}
#[deprecated]
pub type RTDMessageCustomServiceActionBuilder = MessageCustomServiceActionBuilder;
impl MessageCustomServiceActionBuilder {
pub fn build(&self) -> MessageCustomServiceAction {
self.inner.clone()
}
pub fn text<T: AsRef<str>>(&mut self, text: T) -> &mut Self {
self.inner.text = text.as_ref().to_string();
self
}
}
impl AsRef<MessageCustomServiceAction> for MessageCustomServiceAction {
fn as_ref(&self) -> &MessageCustomServiceAction {
self
}
}
impl AsRef<MessageCustomServiceAction> for MessageCustomServiceActionBuilder {
fn as_ref(&self) -> &MessageCustomServiceAction {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageDice {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
initial_state: Option<DiceStickers>,
final_state: Option<DiceStickers>,
#[serde(default)]
emoji: String,
#[serde(default)]
value: i32,
#[serde(default)]
success_animation_frame_number: i32,
}
impl RObject for MessageDice {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageDice {}
impl MessageDice {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageDiceBuilder {
let mut inner = MessageDice::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageDiceBuilder { inner }
}
pub fn initial_state(&self) -> &Option<DiceStickers> {
&self.initial_state
}
pub fn final_state(&self) -> &Option<DiceStickers> {
&self.final_state
}
pub fn emoji(&self) -> &String {
&self.emoji
}
pub fn value(&self) -> i32 {
self.value
}
pub fn success_animation_frame_number(&self) -> i32 {
self.success_animation_frame_number
}
}
#[doc(hidden)]
pub struct MessageDiceBuilder {
inner: MessageDice,
}
#[deprecated]
pub type RTDMessageDiceBuilder = MessageDiceBuilder;
impl MessageDiceBuilder {
pub fn build(&self) -> MessageDice {
self.inner.clone()
}
pub fn initial_state<T: AsRef<DiceStickers>>(&mut self, initial_state: T) -> &mut Self {
self.inner.initial_state = Some(initial_state.as_ref().clone());
self
}
pub fn final_state<T: AsRef<DiceStickers>>(&mut self, final_state: T) -> &mut Self {
self.inner.final_state = Some(final_state.as_ref().clone());
self
}
pub fn emoji<T: AsRef<str>>(&mut self, emoji: T) -> &mut Self {
self.inner.emoji = emoji.as_ref().to_string();
self
}
pub fn value(&mut self, value: i32) -> &mut Self {
self.inner.value = value;
self
}
pub fn success_animation_frame_number(
&mut self,
success_animation_frame_number: i32,
) -> &mut Self {
self.inner.success_animation_frame_number = success_animation_frame_number;
self
}
}
impl AsRef<MessageDice> for MessageDice {
fn as_ref(&self) -> &MessageDice {
self
}
}
impl AsRef<MessageDice> for MessageDiceBuilder {
fn as_ref(&self) -> &MessageDice {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageDocument {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
document: Document,
caption: FormattedText,
}
impl RObject for MessageDocument {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageDocument {}
impl MessageDocument {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageDocumentBuilder {
let mut inner = MessageDocument::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageDocumentBuilder { inner }
}
pub fn document(&self) -> &Document {
&self.document
}
pub fn caption(&self) -> &FormattedText {
&self.caption
}
}
#[doc(hidden)]
pub struct MessageDocumentBuilder {
inner: MessageDocument,
}
#[deprecated]
pub type RTDMessageDocumentBuilder = MessageDocumentBuilder;
impl MessageDocumentBuilder {
pub fn build(&self) -> MessageDocument {
self.inner.clone()
}
pub fn document<T: AsRef<Document>>(&mut self, document: T) -> &mut Self {
self.inner.document = document.as_ref().clone();
self
}
pub fn caption<T: AsRef<FormattedText>>(&mut self, caption: T) -> &mut Self {
self.inner.caption = caption.as_ref().clone();
self
}
}
impl AsRef<MessageDocument> for MessageDocument {
fn as_ref(&self) -> &MessageDocument {
self
}
}
impl AsRef<MessageDocument> for MessageDocumentBuilder {
fn as_ref(&self) -> &MessageDocument {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageExpiredPhoto {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
}
impl RObject for MessageExpiredPhoto {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageExpiredPhoto {}
impl MessageExpiredPhoto {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageExpiredPhotoBuilder {
let mut inner = MessageExpiredPhoto::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageExpiredPhotoBuilder { inner }
}
}
#[doc(hidden)]
pub struct MessageExpiredPhotoBuilder {
inner: MessageExpiredPhoto,
}
#[deprecated]
pub type RTDMessageExpiredPhotoBuilder = MessageExpiredPhotoBuilder;
impl MessageExpiredPhotoBuilder {
pub fn build(&self) -> MessageExpiredPhoto {
self.inner.clone()
}
}
impl AsRef<MessageExpiredPhoto> for MessageExpiredPhoto {
fn as_ref(&self) -> &MessageExpiredPhoto {
self
}
}
impl AsRef<MessageExpiredPhoto> for MessageExpiredPhotoBuilder {
fn as_ref(&self) -> &MessageExpiredPhoto {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageExpiredVideo {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
}
impl RObject for MessageExpiredVideo {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageExpiredVideo {}
impl MessageExpiredVideo {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageExpiredVideoBuilder {
let mut inner = MessageExpiredVideo::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageExpiredVideoBuilder { inner }
}
}
#[doc(hidden)]
pub struct MessageExpiredVideoBuilder {
inner: MessageExpiredVideo,
}
#[deprecated]
pub type RTDMessageExpiredVideoBuilder = MessageExpiredVideoBuilder;
impl MessageExpiredVideoBuilder {
pub fn build(&self) -> MessageExpiredVideo {
self.inner.clone()
}
}
impl AsRef<MessageExpiredVideo> for MessageExpiredVideo {
fn as_ref(&self) -> &MessageExpiredVideo {
self
}
}
impl AsRef<MessageExpiredVideo> for MessageExpiredVideoBuilder {
fn as_ref(&self) -> &MessageExpiredVideo {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageGame {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
game: Game,
}
impl RObject for MessageGame {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageGame {}
impl MessageGame {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageGameBuilder {
let mut inner = MessageGame::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageGameBuilder { inner }
}
pub fn game(&self) -> &Game {
&self.game
}
}
#[doc(hidden)]
pub struct MessageGameBuilder {
inner: MessageGame,
}
#[deprecated]
pub type RTDMessageGameBuilder = MessageGameBuilder;
impl MessageGameBuilder {
pub fn build(&self) -> MessageGame {
self.inner.clone()
}
pub fn game<T: AsRef<Game>>(&mut self, game: T) -> &mut Self {
self.inner.game = game.as_ref().clone();
self
}
}
impl AsRef<MessageGame> for MessageGame {
fn as_ref(&self) -> &MessageGame {
self
}
}
impl AsRef<MessageGame> for MessageGameBuilder {
fn as_ref(&self) -> &MessageGame {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageGameScore {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
game_message_id: i64,
#[serde(
deserialize_with = "super::_common::number_from_string",
serialize_with = "super::_common::string_to_number"
)]
#[serde(default)]
game_id: i64,
#[serde(default)]
score: i32,
}
impl RObject for MessageGameScore {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageGameScore {}
impl MessageGameScore {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageGameScoreBuilder {
let mut inner = MessageGameScore::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageGameScoreBuilder { inner }
}
pub fn game_message_id(&self) -> i64 {
self.game_message_id
}
pub fn game_id(&self) -> i64 {
self.game_id
}
pub fn score(&self) -> i32 {
self.score
}
}
#[doc(hidden)]
pub struct MessageGameScoreBuilder {
inner: MessageGameScore,
}
#[deprecated]
pub type RTDMessageGameScoreBuilder = MessageGameScoreBuilder;
impl MessageGameScoreBuilder {
pub fn build(&self) -> MessageGameScore {
self.inner.clone()
}
pub fn game_message_id(&mut self, game_message_id: i64) -> &mut Self {
self.inner.game_message_id = game_message_id;
self
}
pub fn game_id(&mut self, game_id: i64) -> &mut Self {
self.inner.game_id = game_id;
self
}
pub fn score(&mut self, score: i32) -> &mut Self {
self.inner.score = score;
self
}
}
impl AsRef<MessageGameScore> for MessageGameScore {
fn as_ref(&self) -> &MessageGameScore {
self
}
}
impl AsRef<MessageGameScore> for MessageGameScoreBuilder {
fn as_ref(&self) -> &MessageGameScore {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageInviteVideoChatParticipants {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
group_call_id: i32,
#[serde(default)]
user_ids: Vec<i64>,
}
impl RObject for MessageInviteVideoChatParticipants {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageInviteVideoChatParticipants {}
impl MessageInviteVideoChatParticipants {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageInviteVideoChatParticipantsBuilder {
let mut inner = MessageInviteVideoChatParticipants::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageInviteVideoChatParticipantsBuilder { inner }
}
pub fn group_call_id(&self) -> i32 {
self.group_call_id
}
pub fn user_ids(&self) -> &Vec<i64> {
&self.user_ids
}
}
#[doc(hidden)]
pub struct MessageInviteVideoChatParticipantsBuilder {
inner: MessageInviteVideoChatParticipants,
}
#[deprecated]
pub type RTDMessageInviteVideoChatParticipantsBuilder = MessageInviteVideoChatParticipantsBuilder;
impl MessageInviteVideoChatParticipantsBuilder {
pub fn build(&self) -> MessageInviteVideoChatParticipants {
self.inner.clone()
}
pub fn group_call_id(&mut self, group_call_id: i32) -> &mut Self {
self.inner.group_call_id = group_call_id;
self
}
pub fn user_ids(&mut self, user_ids: Vec<i64>) -> &mut Self {
self.inner.user_ids = user_ids;
self
}
}
impl AsRef<MessageInviteVideoChatParticipants> for MessageInviteVideoChatParticipants {
fn as_ref(&self) -> &MessageInviteVideoChatParticipants {
self
}
}
impl AsRef<MessageInviteVideoChatParticipants> for MessageInviteVideoChatParticipantsBuilder {
fn as_ref(&self) -> &MessageInviteVideoChatParticipants {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageInvoice {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
title: String,
#[serde(default)]
description: String,
photo: Option<Photo>,
#[serde(default)]
currency: String,
#[serde(default)]
total_amount: i64,
#[serde(default)]
start_parameter: String,
#[serde(default)]
is_test: bool,
#[serde(default)]
need_shipping_address: bool,
#[serde(default)]
receipt_message_id: i64,
}
impl RObject for MessageInvoice {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageInvoice {}
impl MessageInvoice {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageInvoiceBuilder {
let mut inner = MessageInvoice::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageInvoiceBuilder { inner }
}
pub fn title(&self) -> &String {
&self.title
}
pub fn description(&self) -> &String {
&self.description
}
pub fn photo(&self) -> &Option<Photo> {
&self.photo
}
pub fn currency(&self) -> &String {
&self.currency
}
pub fn total_amount(&self) -> i64 {
self.total_amount
}
pub fn start_parameter(&self) -> &String {
&self.start_parameter
}
pub fn is_test(&self) -> bool {
self.is_test
}
pub fn need_shipping_address(&self) -> bool {
self.need_shipping_address
}
pub fn receipt_message_id(&self) -> i64 {
self.receipt_message_id
}
}
#[doc(hidden)]
pub struct MessageInvoiceBuilder {
inner: MessageInvoice,
}
#[deprecated]
pub type RTDMessageInvoiceBuilder = MessageInvoiceBuilder;
impl MessageInvoiceBuilder {
pub fn build(&self) -> MessageInvoice {
self.inner.clone()
}
pub fn title<T: AsRef<str>>(&mut self, title: T) -> &mut Self {
self.inner.title = title.as_ref().to_string();
self
}
pub fn description<T: AsRef<str>>(&mut self, description: T) -> &mut Self {
self.inner.description = description.as_ref().to_string();
self
}
pub fn photo<T: AsRef<Photo>>(&mut self, photo: T) -> &mut Self {
self.inner.photo = Some(photo.as_ref().clone());
self
}
pub fn currency<T: AsRef<str>>(&mut self, currency: T) -> &mut Self {
self.inner.currency = currency.as_ref().to_string();
self
}
pub fn total_amount(&mut self, total_amount: i64) -> &mut Self {
self.inner.total_amount = total_amount;
self
}
pub fn start_parameter<T: AsRef<str>>(&mut self, start_parameter: T) -> &mut Self {
self.inner.start_parameter = start_parameter.as_ref().to_string();
self
}
pub fn is_test(&mut self, is_test: bool) -> &mut Self {
self.inner.is_test = is_test;
self
}
pub fn need_shipping_address(&mut self, need_shipping_address: bool) -> &mut Self {
self.inner.need_shipping_address = need_shipping_address;
self
}
pub fn receipt_message_id(&mut self, receipt_message_id: i64) -> &mut Self {
self.inner.receipt_message_id = receipt_message_id;
self
}
}
impl AsRef<MessageInvoice> for MessageInvoice {
fn as_ref(&self) -> &MessageInvoice {
self
}
}
impl AsRef<MessageInvoice> for MessageInvoiceBuilder {
fn as_ref(&self) -> &MessageInvoice {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageLocation {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
location: Location,
#[serde(default)]
live_period: i32,
#[serde(default)]
expires_in: i32,
#[serde(default)]
heading: i32,
#[serde(default)]
proximity_alert_radius: i32,
}
impl RObject for MessageLocation {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageLocation {}
impl MessageLocation {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageLocationBuilder {
let mut inner = MessageLocation::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageLocationBuilder { inner }
}
pub fn location(&self) -> &Location {
&self.location
}
pub fn live_period(&self) -> i32 {
self.live_period
}
pub fn expires_in(&self) -> i32 {
self.expires_in
}
pub fn heading(&self) -> i32 {
self.heading
}
pub fn proximity_alert_radius(&self) -> i32 {
self.proximity_alert_radius
}
}
#[doc(hidden)]
pub struct MessageLocationBuilder {
inner: MessageLocation,
}
#[deprecated]
pub type RTDMessageLocationBuilder = MessageLocationBuilder;
impl MessageLocationBuilder {
pub fn build(&self) -> MessageLocation {
self.inner.clone()
}
pub fn location<T: AsRef<Location>>(&mut self, location: T) -> &mut Self {
self.inner.location = location.as_ref().clone();
self
}
pub fn live_period(&mut self, live_period: i32) -> &mut Self {
self.inner.live_period = live_period;
self
}
pub fn expires_in(&mut self, expires_in: i32) -> &mut Self {
self.inner.expires_in = expires_in;
self
}
pub fn heading(&mut self, heading: i32) -> &mut Self {
self.inner.heading = heading;
self
}
pub fn proximity_alert_radius(&mut self, proximity_alert_radius: i32) -> &mut Self {
self.inner.proximity_alert_radius = proximity_alert_radius;
self
}
}
impl AsRef<MessageLocation> for MessageLocation {
fn as_ref(&self) -> &MessageLocation {
self
}
}
impl AsRef<MessageLocation> for MessageLocationBuilder {
fn as_ref(&self) -> &MessageLocation {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessagePassportDataReceived {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
elements: Vec<EncryptedPassportElement>,
credentials: EncryptedCredentials,
}
impl RObject for MessagePassportDataReceived {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessagePassportDataReceived {}
impl MessagePassportDataReceived {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessagePassportDataReceivedBuilder {
let mut inner = MessagePassportDataReceived::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessagePassportDataReceivedBuilder { inner }
}
pub fn elements(&self) -> &Vec<EncryptedPassportElement> {
&self.elements
}
pub fn credentials(&self) -> &EncryptedCredentials {
&self.credentials
}
}
#[doc(hidden)]
pub struct MessagePassportDataReceivedBuilder {
inner: MessagePassportDataReceived,
}
#[deprecated]
pub type RTDMessagePassportDataReceivedBuilder = MessagePassportDataReceivedBuilder;
impl MessagePassportDataReceivedBuilder {
pub fn build(&self) -> MessagePassportDataReceived {
self.inner.clone()
}
pub fn elements(&mut self, elements: Vec<EncryptedPassportElement>) -> &mut Self {
self.inner.elements = elements;
self
}
pub fn credentials<T: AsRef<EncryptedCredentials>>(&mut self, credentials: T) -> &mut Self {
self.inner.credentials = credentials.as_ref().clone();
self
}
}
impl AsRef<MessagePassportDataReceived> for MessagePassportDataReceived {
fn as_ref(&self) -> &MessagePassportDataReceived {
self
}
}
impl AsRef<MessagePassportDataReceived> for MessagePassportDataReceivedBuilder {
fn as_ref(&self) -> &MessagePassportDataReceived {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessagePassportDataSent {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
types: Vec<PassportElementType>,
}
impl RObject for MessagePassportDataSent {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessagePassportDataSent {}
impl MessagePassportDataSent {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessagePassportDataSentBuilder {
let mut inner = MessagePassportDataSent::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessagePassportDataSentBuilder { inner }
}
pub fn types(&self) -> &Vec<PassportElementType> {
&self.types
}
}
#[doc(hidden)]
pub struct MessagePassportDataSentBuilder {
inner: MessagePassportDataSent,
}
#[deprecated]
pub type RTDMessagePassportDataSentBuilder = MessagePassportDataSentBuilder;
impl MessagePassportDataSentBuilder {
pub fn build(&self) -> MessagePassportDataSent {
self.inner.clone()
}
pub fn types(&mut self, types: Vec<PassportElementType>) -> &mut Self {
self.inner.types = types;
self
}
}
impl AsRef<MessagePassportDataSent> for MessagePassportDataSent {
fn as_ref(&self) -> &MessagePassportDataSent {
self
}
}
impl AsRef<MessagePassportDataSent> for MessagePassportDataSentBuilder {
fn as_ref(&self) -> &MessagePassportDataSent {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessagePaymentSuccessful {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
invoice_chat_id: i64,
#[serde(default)]
invoice_message_id: i64,
#[serde(default)]
currency: String,
#[serde(default)]
total_amount: i64,
}
impl RObject for MessagePaymentSuccessful {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessagePaymentSuccessful {}
impl MessagePaymentSuccessful {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessagePaymentSuccessfulBuilder {
let mut inner = MessagePaymentSuccessful::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessagePaymentSuccessfulBuilder { inner }
}
pub fn invoice_chat_id(&self) -> i64 {
self.invoice_chat_id
}
pub fn invoice_message_id(&self) -> i64 {
self.invoice_message_id
}
pub fn currency(&self) -> &String {
&self.currency
}
pub fn total_amount(&self) -> i64 {
self.total_amount
}
}
#[doc(hidden)]
pub struct MessagePaymentSuccessfulBuilder {
inner: MessagePaymentSuccessful,
}
#[deprecated]
pub type RTDMessagePaymentSuccessfulBuilder = MessagePaymentSuccessfulBuilder;
impl MessagePaymentSuccessfulBuilder {
pub fn build(&self) -> MessagePaymentSuccessful {
self.inner.clone()
}
pub fn invoice_chat_id(&mut self, invoice_chat_id: i64) -> &mut Self {
self.inner.invoice_chat_id = invoice_chat_id;
self
}
pub fn invoice_message_id(&mut self, invoice_message_id: i64) -> &mut Self {
self.inner.invoice_message_id = invoice_message_id;
self
}
pub fn currency<T: AsRef<str>>(&mut self, currency: T) -> &mut Self {
self.inner.currency = currency.as_ref().to_string();
self
}
pub fn total_amount(&mut self, total_amount: i64) -> &mut Self {
self.inner.total_amount = total_amount;
self
}
}
impl AsRef<MessagePaymentSuccessful> for MessagePaymentSuccessful {
fn as_ref(&self) -> &MessagePaymentSuccessful {
self
}
}
impl AsRef<MessagePaymentSuccessful> for MessagePaymentSuccessfulBuilder {
fn as_ref(&self) -> &MessagePaymentSuccessful {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessagePaymentSuccessfulBot {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
currency: String,
#[serde(default)]
total_amount: i64,
#[serde(default)]
invoice_payload: String,
#[serde(default)]
shipping_option_id: String,
order_info: Option<OrderInfo>,
#[serde(default)]
telegram_payment_charge_id: String,
#[serde(default)]
provider_payment_charge_id: String,
}
impl RObject for MessagePaymentSuccessfulBot {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessagePaymentSuccessfulBot {}
impl MessagePaymentSuccessfulBot {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessagePaymentSuccessfulBotBuilder {
let mut inner = MessagePaymentSuccessfulBot::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessagePaymentSuccessfulBotBuilder { inner }
}
pub fn currency(&self) -> &String {
&self.currency
}
pub fn total_amount(&self) -> i64 {
self.total_amount
}
pub fn invoice_payload(&self) -> &String {
&self.invoice_payload
}
pub fn shipping_option_id(&self) -> &String {
&self.shipping_option_id
}
pub fn order_info(&self) -> &Option<OrderInfo> {
&self.order_info
}
pub fn telegram_payment_charge_id(&self) -> &String {
&self.telegram_payment_charge_id
}
pub fn provider_payment_charge_id(&self) -> &String {
&self.provider_payment_charge_id
}
}
#[doc(hidden)]
pub struct MessagePaymentSuccessfulBotBuilder {
inner: MessagePaymentSuccessfulBot,
}
#[deprecated]
pub type RTDMessagePaymentSuccessfulBotBuilder = MessagePaymentSuccessfulBotBuilder;
impl MessagePaymentSuccessfulBotBuilder {
pub fn build(&self) -> MessagePaymentSuccessfulBot {
self.inner.clone()
}
pub fn currency<T: AsRef<str>>(&mut self, currency: T) -> &mut Self {
self.inner.currency = currency.as_ref().to_string();
self
}
pub fn total_amount(&mut self, total_amount: i64) -> &mut Self {
self.inner.total_amount = total_amount;
self
}
pub fn invoice_payload<T: AsRef<str>>(&mut self, invoice_payload: T) -> &mut Self {
self.inner.invoice_payload = invoice_payload.as_ref().to_string();
self
}
pub fn shipping_option_id<T: AsRef<str>>(&mut self, shipping_option_id: T) -> &mut Self {
self.inner.shipping_option_id = shipping_option_id.as_ref().to_string();
self
}
pub fn order_info<T: AsRef<OrderInfo>>(&mut self, order_info: T) -> &mut Self {
self.inner.order_info = Some(order_info.as_ref().clone());
self
}
pub fn telegram_payment_charge_id<T: AsRef<str>>(
&mut self,
telegram_payment_charge_id: T,
) -> &mut Self {
self.inner.telegram_payment_charge_id = telegram_payment_charge_id.as_ref().to_string();
self
}
pub fn provider_payment_charge_id<T: AsRef<str>>(
&mut self,
provider_payment_charge_id: T,
) -> &mut Self {
self.inner.provider_payment_charge_id = provider_payment_charge_id.as_ref().to_string();
self
}
}
impl AsRef<MessagePaymentSuccessfulBot> for MessagePaymentSuccessfulBot {
fn as_ref(&self) -> &MessagePaymentSuccessfulBot {
self
}
}
impl AsRef<MessagePaymentSuccessfulBot> for MessagePaymentSuccessfulBotBuilder {
fn as_ref(&self) -> &MessagePaymentSuccessfulBot {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessagePhoto {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
photo: Photo,
caption: FormattedText,
#[serde(default)]
is_secret: bool,
}
impl RObject for MessagePhoto {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessagePhoto {}
impl MessagePhoto {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessagePhotoBuilder {
let mut inner = MessagePhoto::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessagePhotoBuilder { inner }
}
pub fn photo(&self) -> &Photo {
&self.photo
}
pub fn caption(&self) -> &FormattedText {
&self.caption
}
pub fn is_secret(&self) -> bool {
self.is_secret
}
}
#[doc(hidden)]
pub struct MessagePhotoBuilder {
inner: MessagePhoto,
}
#[deprecated]
pub type RTDMessagePhotoBuilder = MessagePhotoBuilder;
impl MessagePhotoBuilder {
pub fn build(&self) -> MessagePhoto {
self.inner.clone()
}
pub fn photo<T: AsRef<Photo>>(&mut self, photo: T) -> &mut Self {
self.inner.photo = photo.as_ref().clone();
self
}
pub fn caption<T: AsRef<FormattedText>>(&mut self, caption: T) -> &mut Self {
self.inner.caption = caption.as_ref().clone();
self
}
pub fn is_secret(&mut self, is_secret: bool) -> &mut Self {
self.inner.is_secret = is_secret;
self
}
}
impl AsRef<MessagePhoto> for MessagePhoto {
fn as_ref(&self) -> &MessagePhoto {
self
}
}
impl AsRef<MessagePhoto> for MessagePhotoBuilder {
fn as_ref(&self) -> &MessagePhoto {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessagePinMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
message_id: i64,
}
impl RObject for MessagePinMessage {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessagePinMessage {}
impl MessagePinMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessagePinMessageBuilder {
let mut inner = MessagePinMessage::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessagePinMessageBuilder { inner }
}
pub fn message_id(&self) -> i64 {
self.message_id
}
}
#[doc(hidden)]
pub struct MessagePinMessageBuilder {
inner: MessagePinMessage,
}
#[deprecated]
pub type RTDMessagePinMessageBuilder = MessagePinMessageBuilder;
impl MessagePinMessageBuilder {
pub fn build(&self) -> MessagePinMessage {
self.inner.clone()
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
}
impl AsRef<MessagePinMessage> for MessagePinMessage {
fn as_ref(&self) -> &MessagePinMessage {
self
}
}
impl AsRef<MessagePinMessage> for MessagePinMessageBuilder {
fn as_ref(&self) -> &MessagePinMessage {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessagePoll {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
poll: Poll,
}
impl RObject for MessagePoll {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessagePoll {}
impl MessagePoll {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessagePollBuilder {
let mut inner = MessagePoll::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessagePollBuilder { inner }
}
pub fn poll(&self) -> &Poll {
&self.poll
}
}
#[doc(hidden)]
pub struct MessagePollBuilder {
inner: MessagePoll,
}
#[deprecated]
pub type RTDMessagePollBuilder = MessagePollBuilder;
impl MessagePollBuilder {
pub fn build(&self) -> MessagePoll {
self.inner.clone()
}
pub fn poll<T: AsRef<Poll>>(&mut self, poll: T) -> &mut Self {
self.inner.poll = poll.as_ref().clone();
self
}
}
impl AsRef<MessagePoll> for MessagePoll {
fn as_ref(&self) -> &MessagePoll {
self
}
}
impl AsRef<MessagePoll> for MessagePollBuilder {
fn as_ref(&self) -> &MessagePoll {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageProximityAlertTriggered {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(skip_serializing_if = "MessageSender::_is_default")]
traveler_id: MessageSender,
#[serde(skip_serializing_if = "MessageSender::_is_default")]
watcher_id: MessageSender,
#[serde(default)]
distance: i32,
}
impl RObject for MessageProximityAlertTriggered {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageProximityAlertTriggered {}
impl MessageProximityAlertTriggered {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageProximityAlertTriggeredBuilder {
let mut inner = MessageProximityAlertTriggered::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageProximityAlertTriggeredBuilder { inner }
}
pub fn traveler_id(&self) -> &MessageSender {
&self.traveler_id
}
pub fn watcher_id(&self) -> &MessageSender {
&self.watcher_id
}
pub fn distance(&self) -> i32 {
self.distance
}
}
#[doc(hidden)]
pub struct MessageProximityAlertTriggeredBuilder {
inner: MessageProximityAlertTriggered,
}
#[deprecated]
pub type RTDMessageProximityAlertTriggeredBuilder = MessageProximityAlertTriggeredBuilder;
impl MessageProximityAlertTriggeredBuilder {
pub fn build(&self) -> MessageProximityAlertTriggered {
self.inner.clone()
}
pub fn traveler_id<T: AsRef<MessageSender>>(&mut self, traveler_id: T) -> &mut Self {
self.inner.traveler_id = traveler_id.as_ref().clone();
self
}
pub fn watcher_id<T: AsRef<MessageSender>>(&mut self, watcher_id: T) -> &mut Self {
self.inner.watcher_id = watcher_id.as_ref().clone();
self
}
pub fn distance(&mut self, distance: i32) -> &mut Self {
self.inner.distance = distance;
self
}
}
impl AsRef<MessageProximityAlertTriggered> for MessageProximityAlertTriggered {
fn as_ref(&self) -> &MessageProximityAlertTriggered {
self
}
}
impl AsRef<MessageProximityAlertTriggered> for MessageProximityAlertTriggeredBuilder {
fn as_ref(&self) -> &MessageProximityAlertTriggered {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageScreenshotTaken {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
}
impl RObject for MessageScreenshotTaken {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageScreenshotTaken {}
impl MessageScreenshotTaken {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageScreenshotTakenBuilder {
let mut inner = MessageScreenshotTaken::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageScreenshotTakenBuilder { inner }
}
}
#[doc(hidden)]
pub struct MessageScreenshotTakenBuilder {
inner: MessageScreenshotTaken,
}
#[deprecated]
pub type RTDMessageScreenshotTakenBuilder = MessageScreenshotTakenBuilder;
impl MessageScreenshotTakenBuilder {
pub fn build(&self) -> MessageScreenshotTaken {
self.inner.clone()
}
}
impl AsRef<MessageScreenshotTaken> for MessageScreenshotTaken {
fn as_ref(&self) -> &MessageScreenshotTaken {
self
}
}
impl AsRef<MessageScreenshotTaken> for MessageScreenshotTakenBuilder {
fn as_ref(&self) -> &MessageScreenshotTaken {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageSticker {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
sticker: Sticker,
}
impl RObject for MessageSticker {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageSticker {}
impl MessageSticker {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageStickerBuilder {
let mut inner = MessageSticker::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageStickerBuilder { inner }
}
pub fn sticker(&self) -> &Sticker {
&self.sticker
}
}
#[doc(hidden)]
pub struct MessageStickerBuilder {
inner: MessageSticker,
}
#[deprecated]
pub type RTDMessageStickerBuilder = MessageStickerBuilder;
impl MessageStickerBuilder {
pub fn build(&self) -> MessageSticker {
self.inner.clone()
}
pub fn sticker<T: AsRef<Sticker>>(&mut self, sticker: T) -> &mut Self {
self.inner.sticker = sticker.as_ref().clone();
self
}
}
impl AsRef<MessageSticker> for MessageSticker {
fn as_ref(&self) -> &MessageSticker {
self
}
}
impl AsRef<MessageSticker> for MessageStickerBuilder {
fn as_ref(&self) -> &MessageSticker {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageSupergroupChatCreate {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
title: String,
}
impl RObject for MessageSupergroupChatCreate {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageSupergroupChatCreate {}
impl MessageSupergroupChatCreate {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageSupergroupChatCreateBuilder {
let mut inner = MessageSupergroupChatCreate::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageSupergroupChatCreateBuilder { inner }
}
pub fn title(&self) -> &String {
&self.title
}
}
#[doc(hidden)]
pub struct MessageSupergroupChatCreateBuilder {
inner: MessageSupergroupChatCreate,
}
#[deprecated]
pub type RTDMessageSupergroupChatCreateBuilder = MessageSupergroupChatCreateBuilder;
impl MessageSupergroupChatCreateBuilder {
pub fn build(&self) -> MessageSupergroupChatCreate {
self.inner.clone()
}
pub fn title<T: AsRef<str>>(&mut self, title: T) -> &mut Self {
self.inner.title = title.as_ref().to_string();
self
}
}
impl AsRef<MessageSupergroupChatCreate> for MessageSupergroupChatCreate {
fn as_ref(&self) -> &MessageSupergroupChatCreate {
self
}
}
impl AsRef<MessageSupergroupChatCreate> for MessageSupergroupChatCreateBuilder {
fn as_ref(&self) -> &MessageSupergroupChatCreate {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageText {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
text: FormattedText,
web_page: Option<WebPage>,
}
impl RObject for MessageText {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageText {}
impl MessageText {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageTextBuilder {
let mut inner = MessageText::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageTextBuilder { inner }
}
pub fn text(&self) -> &FormattedText {
&self.text
}
pub fn web_page(&self) -> &Option<WebPage> {
&self.web_page
}
}
#[doc(hidden)]
pub struct MessageTextBuilder {
inner: MessageText,
}
#[deprecated]
pub type RTDMessageTextBuilder = MessageTextBuilder;
impl MessageTextBuilder {
pub fn build(&self) -> MessageText {
self.inner.clone()
}
pub fn text<T: AsRef<FormattedText>>(&mut self, text: T) -> &mut Self {
self.inner.text = text.as_ref().clone();
self
}
pub fn web_page<T: AsRef<WebPage>>(&mut self, web_page: T) -> &mut Self {
self.inner.web_page = Some(web_page.as_ref().clone());
self
}
}
impl AsRef<MessageText> for MessageText {
fn as_ref(&self) -> &MessageText {
self
}
}
impl AsRef<MessageText> for MessageTextBuilder {
fn as_ref(&self) -> &MessageText {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageUnsupported {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
}
impl RObject for MessageUnsupported {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageUnsupported {}
impl MessageUnsupported {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageUnsupportedBuilder {
let mut inner = MessageUnsupported::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageUnsupportedBuilder { inner }
}
}
#[doc(hidden)]
pub struct MessageUnsupportedBuilder {
inner: MessageUnsupported,
}
#[deprecated]
pub type RTDMessageUnsupportedBuilder = MessageUnsupportedBuilder;
impl MessageUnsupportedBuilder {
pub fn build(&self) -> MessageUnsupported {
self.inner.clone()
}
}
impl AsRef<MessageUnsupported> for MessageUnsupported {
fn as_ref(&self) -> &MessageUnsupported {
self
}
}
impl AsRef<MessageUnsupported> for MessageUnsupportedBuilder {
fn as_ref(&self) -> &MessageUnsupported {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageVenue {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
venue: Venue,
}
impl RObject for MessageVenue {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageVenue {}
impl MessageVenue {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageVenueBuilder {
let mut inner = MessageVenue::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageVenueBuilder { inner }
}
pub fn venue(&self) -> &Venue {
&self.venue
}
}
#[doc(hidden)]
pub struct MessageVenueBuilder {
inner: MessageVenue,
}
#[deprecated]
pub type RTDMessageVenueBuilder = MessageVenueBuilder;
impl MessageVenueBuilder {
pub fn build(&self) -> MessageVenue {
self.inner.clone()
}
pub fn venue<T: AsRef<Venue>>(&mut self, venue: T) -> &mut Self {
self.inner.venue = venue.as_ref().clone();
self
}
}
impl AsRef<MessageVenue> for MessageVenue {
fn as_ref(&self) -> &MessageVenue {
self
}
}
impl AsRef<MessageVenue> for MessageVenueBuilder {
fn as_ref(&self) -> &MessageVenue {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageVideo {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
video: Video,
caption: FormattedText,
#[serde(default)]
is_secret: bool,
}
impl RObject for MessageVideo {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageVideo {}
impl MessageVideo {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageVideoBuilder {
let mut inner = MessageVideo::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageVideoBuilder { inner }
}
pub fn video(&self) -> &Video {
&self.video
}
pub fn caption(&self) -> &FormattedText {
&self.caption
}
pub fn is_secret(&self) -> bool {
self.is_secret
}
}
#[doc(hidden)]
pub struct MessageVideoBuilder {
inner: MessageVideo,
}
#[deprecated]
pub type RTDMessageVideoBuilder = MessageVideoBuilder;
impl MessageVideoBuilder {
pub fn build(&self) -> MessageVideo {
self.inner.clone()
}
pub fn video<T: AsRef<Video>>(&mut self, video: T) -> &mut Self {
self.inner.video = video.as_ref().clone();
self
}
pub fn caption<T: AsRef<FormattedText>>(&mut self, caption: T) -> &mut Self {
self.inner.caption = caption.as_ref().clone();
self
}
pub fn is_secret(&mut self, is_secret: bool) -> &mut Self {
self.inner.is_secret = is_secret;
self
}
}
impl AsRef<MessageVideo> for MessageVideo {
fn as_ref(&self) -> &MessageVideo {
self
}
}
impl AsRef<MessageVideo> for MessageVideoBuilder {
fn as_ref(&self) -> &MessageVideo {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageVideoChatEnded {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
duration: i32,
}
impl RObject for MessageVideoChatEnded {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageVideoChatEnded {}
impl MessageVideoChatEnded {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageVideoChatEndedBuilder {
let mut inner = MessageVideoChatEnded::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageVideoChatEndedBuilder { inner }
}
pub fn duration(&self) -> i32 {
self.duration
}
}
#[doc(hidden)]
pub struct MessageVideoChatEndedBuilder {
inner: MessageVideoChatEnded,
}
#[deprecated]
pub type RTDMessageVideoChatEndedBuilder = MessageVideoChatEndedBuilder;
impl MessageVideoChatEndedBuilder {
pub fn build(&self) -> MessageVideoChatEnded {
self.inner.clone()
}
pub fn duration(&mut self, duration: i32) -> &mut Self {
self.inner.duration = duration;
self
}
}
impl AsRef<MessageVideoChatEnded> for MessageVideoChatEnded {
fn as_ref(&self) -> &MessageVideoChatEnded {
self
}
}
impl AsRef<MessageVideoChatEnded> for MessageVideoChatEndedBuilder {
fn as_ref(&self) -> &MessageVideoChatEnded {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageVideoChatScheduled {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
group_call_id: i32,
#[serde(default)]
start_date: i32,
}
impl RObject for MessageVideoChatScheduled {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageVideoChatScheduled {}
impl MessageVideoChatScheduled {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageVideoChatScheduledBuilder {
let mut inner = MessageVideoChatScheduled::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageVideoChatScheduledBuilder { inner }
}
pub fn group_call_id(&self) -> i32 {
self.group_call_id
}
pub fn start_date(&self) -> i32 {
self.start_date
}
}
#[doc(hidden)]
pub struct MessageVideoChatScheduledBuilder {
inner: MessageVideoChatScheduled,
}
#[deprecated]
pub type RTDMessageVideoChatScheduledBuilder = MessageVideoChatScheduledBuilder;
impl MessageVideoChatScheduledBuilder {
pub fn build(&self) -> MessageVideoChatScheduled {
self.inner.clone()
}
pub fn group_call_id(&mut self, group_call_id: i32) -> &mut Self {
self.inner.group_call_id = group_call_id;
self
}
pub fn start_date(&mut self, start_date: i32) -> &mut Self {
self.inner.start_date = start_date;
self
}
}
impl AsRef<MessageVideoChatScheduled> for MessageVideoChatScheduled {
fn as_ref(&self) -> &MessageVideoChatScheduled {
self
}
}
impl AsRef<MessageVideoChatScheduled> for MessageVideoChatScheduledBuilder {
fn as_ref(&self) -> &MessageVideoChatScheduled {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageVideoChatStarted {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
group_call_id: i32,
}
impl RObject for MessageVideoChatStarted {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageVideoChatStarted {}
impl MessageVideoChatStarted {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageVideoChatStartedBuilder {
let mut inner = MessageVideoChatStarted::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageVideoChatStartedBuilder { inner }
}
pub fn group_call_id(&self) -> i32 {
self.group_call_id
}
}
#[doc(hidden)]
pub struct MessageVideoChatStartedBuilder {
inner: MessageVideoChatStarted,
}
#[deprecated]
pub type RTDMessageVideoChatStartedBuilder = MessageVideoChatStartedBuilder;
impl MessageVideoChatStartedBuilder {
pub fn build(&self) -> MessageVideoChatStarted {
self.inner.clone()
}
pub fn group_call_id(&mut self, group_call_id: i32) -> &mut Self {
self.inner.group_call_id = group_call_id;
self
}
}
impl AsRef<MessageVideoChatStarted> for MessageVideoChatStarted {
fn as_ref(&self) -> &MessageVideoChatStarted {
self
}
}
impl AsRef<MessageVideoChatStarted> for MessageVideoChatStartedBuilder {
fn as_ref(&self) -> &MessageVideoChatStarted {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageVideoNote {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
video_note: VideoNote,
#[serde(default)]
is_viewed: bool,
#[serde(default)]
is_secret: bool,
}
impl RObject for MessageVideoNote {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageVideoNote {}
impl MessageVideoNote {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageVideoNoteBuilder {
let mut inner = MessageVideoNote::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageVideoNoteBuilder { inner }
}
pub fn video_note(&self) -> &VideoNote {
&self.video_note
}
pub fn is_viewed(&self) -> bool {
self.is_viewed
}
pub fn is_secret(&self) -> bool {
self.is_secret
}
}
#[doc(hidden)]
pub struct MessageVideoNoteBuilder {
inner: MessageVideoNote,
}
#[deprecated]
pub type RTDMessageVideoNoteBuilder = MessageVideoNoteBuilder;
impl MessageVideoNoteBuilder {
pub fn build(&self) -> MessageVideoNote {
self.inner.clone()
}
pub fn video_note<T: AsRef<VideoNote>>(&mut self, video_note: T) -> &mut Self {
self.inner.video_note = video_note.as_ref().clone();
self
}
pub fn is_viewed(&mut self, is_viewed: bool) -> &mut Self {
self.inner.is_viewed = is_viewed;
self
}
pub fn is_secret(&mut self, is_secret: bool) -> &mut Self {
self.inner.is_secret = is_secret;
self
}
}
impl AsRef<MessageVideoNote> for MessageVideoNote {
fn as_ref(&self) -> &MessageVideoNote {
self
}
}
impl AsRef<MessageVideoNote> for MessageVideoNoteBuilder {
fn as_ref(&self) -> &MessageVideoNote {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageVoiceNote {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
voice_note: VoiceNote,
caption: FormattedText,
#[serde(default)]
is_listened: bool,
}
impl RObject for MessageVoiceNote {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageVoiceNote {}
impl MessageVoiceNote {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageVoiceNoteBuilder {
let mut inner = MessageVoiceNote::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageVoiceNoteBuilder { inner }
}
pub fn voice_note(&self) -> &VoiceNote {
&self.voice_note
}
pub fn caption(&self) -> &FormattedText {
&self.caption
}
pub fn is_listened(&self) -> bool {
self.is_listened
}
}
#[doc(hidden)]
pub struct MessageVoiceNoteBuilder {
inner: MessageVoiceNote,
}
#[deprecated]
pub type RTDMessageVoiceNoteBuilder = MessageVoiceNoteBuilder;
impl MessageVoiceNoteBuilder {
pub fn build(&self) -> MessageVoiceNote {
self.inner.clone()
}
pub fn voice_note<T: AsRef<VoiceNote>>(&mut self, voice_note: T) -> &mut Self {
self.inner.voice_note = voice_note.as_ref().clone();
self
}
pub fn caption<T: AsRef<FormattedText>>(&mut self, caption: T) -> &mut Self {
self.inner.caption = caption.as_ref().clone();
self
}
pub fn is_listened(&mut self, is_listened: bool) -> &mut Self {
self.inner.is_listened = is_listened;
self
}
}
impl AsRef<MessageVoiceNote> for MessageVoiceNote {
fn as_ref(&self) -> &MessageVoiceNote {
self
}
}
impl AsRef<MessageVoiceNote> for MessageVoiceNoteBuilder {
fn as_ref(&self) -> &MessageVoiceNote {
&self.inner
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MessageWebsiteConnected {
#[doc(hidden)]
#[serde(rename(serialize = "@extra", deserialize = "@extra"))]
extra: Option<String>,
#[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
client_id: Option<i32>,
#[serde(default)]
domain_name: String,
}
impl RObject for MessageWebsiteConnected {
#[doc(hidden)]
fn extra(&self) -> Option<&str> {
self.extra.as_deref()
}
#[doc(hidden)]
fn client_id(&self) -> Option<i32> {
self.client_id
}
}
impl TDMessageContent for MessageWebsiteConnected {}
impl MessageWebsiteConnected {
pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
Ok(serde_json::from_str(json.as_ref())?)
}
pub fn builder() -> MessageWebsiteConnectedBuilder {
let mut inner = MessageWebsiteConnected::default();
inner.extra = Some(Uuid::new_v4().to_string());
MessageWebsiteConnectedBuilder { inner }
}
pub fn domain_name(&self) -> &String {
&self.domain_name
}
}
#[doc(hidden)]
pub struct MessageWebsiteConnectedBuilder {
inner: MessageWebsiteConnected,
}
#[deprecated]
pub type RTDMessageWebsiteConnectedBuilder = MessageWebsiteConnectedBuilder;
impl MessageWebsiteConnectedBuilder {
pub fn build(&self) -> MessageWebsiteConnected {
self.inner.clone()
}
pub fn domain_name<T: AsRef<str>>(&mut self, domain_name: T) -> &mut Self {
self.inner.domain_name = domain_name.as_ref().to_string();
self
}
}
impl AsRef<MessageWebsiteConnected> for MessageWebsiteConnected {
fn as_ref(&self) -> &MessageWebsiteConnected {
self
}
}
impl AsRef<MessageWebsiteConnected> for MessageWebsiteConnectedBuilder {
fn as_ref(&self) -> &MessageWebsiteConnected {
&self.inner
}
}