use crate::types::*;
use crate::errors::*;
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetAuthorizationState {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetAuthorizationState {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getAuthorizationState" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl TDAuthorizationState for GetAuthorizationState {}
impl RFunction for GetAuthorizationState {}
impl GetAuthorizationState {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetAuthorizationStateBuilder {
let mut inner = GetAuthorizationState::default();
inner.td_name = "getAuthorizationState".to_string();
RTDGetAuthorizationStateBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetAuthorizationStateBuilder {
inner: GetAuthorizationState
}
impl RTDGetAuthorizationStateBuilder {
pub fn build(&self) -> GetAuthorizationState { self.inner.clone() }
}
impl AsRef<GetAuthorizationState> for GetAuthorizationState {
fn as_ref(&self) -> &GetAuthorizationState { self }
}
impl AsRef<GetAuthorizationState> for RTDGetAuthorizationStateBuilder {
fn as_ref(&self) -> &GetAuthorizationState { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetTdlibParameters {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
parameters: TdlibParameters,
}
impl RObject for SetTdlibParameters {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setTdlibParameters" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetTdlibParameters {}
impl SetTdlibParameters {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetTdlibParametersBuilder {
let mut inner = SetTdlibParameters::default();
inner.td_name = "setTdlibParameters".to_string();
RTDSetTdlibParametersBuilder { inner }
}
pub fn parameters(&self) -> &TdlibParameters { &self.parameters }
}
#[doc(hidden)]
pub struct RTDSetTdlibParametersBuilder {
inner: SetTdlibParameters
}
impl RTDSetTdlibParametersBuilder {
pub fn build(&self) -> SetTdlibParameters { self.inner.clone() }
pub fn parameters<T: AsRef<TdlibParameters>>(&mut self, parameters: T) -> &mut Self {
self.inner.parameters = parameters.as_ref().clone();
self
}
}
impl AsRef<SetTdlibParameters> for SetTdlibParameters {
fn as_ref(&self) -> &SetTdlibParameters { self }
}
impl AsRef<SetTdlibParameters> for RTDSetTdlibParametersBuilder {
fn as_ref(&self) -> &SetTdlibParameters { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckDatabaseEncryptionKey {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
encryption_key: String,
}
impl RObject for CheckDatabaseEncryptionKey {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkDatabaseEncryptionKey" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CheckDatabaseEncryptionKey {}
impl CheckDatabaseEncryptionKey {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckDatabaseEncryptionKeyBuilder {
let mut inner = CheckDatabaseEncryptionKey::default();
inner.td_name = "checkDatabaseEncryptionKey".to_string();
RTDCheckDatabaseEncryptionKeyBuilder { inner }
}
pub fn encryption_key(&self) -> &String { &self.encryption_key }
}
#[doc(hidden)]
pub struct RTDCheckDatabaseEncryptionKeyBuilder {
inner: CheckDatabaseEncryptionKey
}
impl RTDCheckDatabaseEncryptionKeyBuilder {
pub fn build(&self) -> CheckDatabaseEncryptionKey { self.inner.clone() }
pub fn encryption_key<T: AsRef<str>>(&mut self, encryption_key: T) -> &mut Self {
self.inner.encryption_key = encryption_key.as_ref().to_string();
self
}
}
impl AsRef<CheckDatabaseEncryptionKey> for CheckDatabaseEncryptionKey {
fn as_ref(&self) -> &CheckDatabaseEncryptionKey { self }
}
impl AsRef<CheckDatabaseEncryptionKey> for RTDCheckDatabaseEncryptionKeyBuilder {
fn as_ref(&self) -> &CheckDatabaseEncryptionKey { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetAuthenticationPhoneNumber {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
phone_number: String,
allow_flash_call: bool,
is_current_phone_number: bool,
}
impl RObject for SetAuthenticationPhoneNumber {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setAuthenticationPhoneNumber" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetAuthenticationPhoneNumber {}
impl SetAuthenticationPhoneNumber {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetAuthenticationPhoneNumberBuilder {
let mut inner = SetAuthenticationPhoneNumber::default();
inner.td_name = "setAuthenticationPhoneNumber".to_string();
RTDSetAuthenticationPhoneNumberBuilder { inner }
}
pub fn phone_number(&self) -> &String { &self.phone_number }
pub fn allow_flash_call(&self) -> bool { self.allow_flash_call }
pub fn is_current_phone_number(&self) -> bool { self.is_current_phone_number }
}
#[doc(hidden)]
pub struct RTDSetAuthenticationPhoneNumberBuilder {
inner: SetAuthenticationPhoneNumber
}
impl RTDSetAuthenticationPhoneNumberBuilder {
pub fn build(&self) -> SetAuthenticationPhoneNumber { self.inner.clone() }
pub fn phone_number<T: AsRef<str>>(&mut self, phone_number: T) -> &mut Self {
self.inner.phone_number = phone_number.as_ref().to_string();
self
}
pub fn allow_flash_call(&mut self, allow_flash_call: bool) -> &mut Self {
self.inner.allow_flash_call = allow_flash_call;
self
}
pub fn is_current_phone_number(&mut self, is_current_phone_number: bool) -> &mut Self {
self.inner.is_current_phone_number = is_current_phone_number;
self
}
}
impl AsRef<SetAuthenticationPhoneNumber> for SetAuthenticationPhoneNumber {
fn as_ref(&self) -> &SetAuthenticationPhoneNumber { self }
}
impl AsRef<SetAuthenticationPhoneNumber> for RTDSetAuthenticationPhoneNumberBuilder {
fn as_ref(&self) -> &SetAuthenticationPhoneNumber { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ResendAuthenticationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for ResendAuthenticationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "resendAuthenticationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ResendAuthenticationCode {}
impl ResendAuthenticationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDResendAuthenticationCodeBuilder {
let mut inner = ResendAuthenticationCode::default();
inner.td_name = "resendAuthenticationCode".to_string();
RTDResendAuthenticationCodeBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDResendAuthenticationCodeBuilder {
inner: ResendAuthenticationCode
}
impl RTDResendAuthenticationCodeBuilder {
pub fn build(&self) -> ResendAuthenticationCode { self.inner.clone() }
}
impl AsRef<ResendAuthenticationCode> for ResendAuthenticationCode {
fn as_ref(&self) -> &ResendAuthenticationCode { self }
}
impl AsRef<ResendAuthenticationCode> for RTDResendAuthenticationCodeBuilder {
fn as_ref(&self) -> &ResendAuthenticationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckAuthenticationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
code: String,
first_name: String,
last_name: String,
}
impl RObject for CheckAuthenticationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkAuthenticationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CheckAuthenticationCode {}
impl CheckAuthenticationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckAuthenticationCodeBuilder {
let mut inner = CheckAuthenticationCode::default();
inner.td_name = "checkAuthenticationCode".to_string();
RTDCheckAuthenticationCodeBuilder { inner }
}
pub fn code(&self) -> &String { &self.code }
pub fn first_name(&self) -> &String { &self.first_name }
pub fn last_name(&self) -> &String { &self.last_name }
}
#[doc(hidden)]
pub struct RTDCheckAuthenticationCodeBuilder {
inner: CheckAuthenticationCode
}
impl RTDCheckAuthenticationCodeBuilder {
pub fn build(&self) -> CheckAuthenticationCode { self.inner.clone() }
pub fn code<T: AsRef<str>>(&mut self, code: T) -> &mut Self {
self.inner.code = code.as_ref().to_string();
self
}
pub fn first_name<T: AsRef<str>>(&mut self, first_name: T) -> &mut Self {
self.inner.first_name = first_name.as_ref().to_string();
self
}
pub fn last_name<T: AsRef<str>>(&mut self, last_name: T) -> &mut Self {
self.inner.last_name = last_name.as_ref().to_string();
self
}
}
impl AsRef<CheckAuthenticationCode> for CheckAuthenticationCode {
fn as_ref(&self) -> &CheckAuthenticationCode { self }
}
impl AsRef<CheckAuthenticationCode> for RTDCheckAuthenticationCodeBuilder {
fn as_ref(&self) -> &CheckAuthenticationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckAuthenticationPassword {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
password: String,
}
impl RObject for CheckAuthenticationPassword {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkAuthenticationPassword" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CheckAuthenticationPassword {}
impl CheckAuthenticationPassword {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckAuthenticationPasswordBuilder {
let mut inner = CheckAuthenticationPassword::default();
inner.td_name = "checkAuthenticationPassword".to_string();
RTDCheckAuthenticationPasswordBuilder { inner }
}
pub fn password(&self) -> &String { &self.password }
}
#[doc(hidden)]
pub struct RTDCheckAuthenticationPasswordBuilder {
inner: CheckAuthenticationPassword
}
impl RTDCheckAuthenticationPasswordBuilder {
pub fn build(&self) -> CheckAuthenticationPassword { self.inner.clone() }
pub fn password<T: AsRef<str>>(&mut self, password: T) -> &mut Self {
self.inner.password = password.as_ref().to_string();
self
}
}
impl AsRef<CheckAuthenticationPassword> for CheckAuthenticationPassword {
fn as_ref(&self) -> &CheckAuthenticationPassword { self }
}
impl AsRef<CheckAuthenticationPassword> for RTDCheckAuthenticationPasswordBuilder {
fn as_ref(&self) -> &CheckAuthenticationPassword { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RequestAuthenticationPasswordRecovery {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for RequestAuthenticationPasswordRecovery {
#[doc(hidden)] fn td_name(&self) -> &'static str { "requestAuthenticationPasswordRecovery" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RequestAuthenticationPasswordRecovery {}
impl RequestAuthenticationPasswordRecovery {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRequestAuthenticationPasswordRecoveryBuilder {
let mut inner = RequestAuthenticationPasswordRecovery::default();
inner.td_name = "requestAuthenticationPasswordRecovery".to_string();
RTDRequestAuthenticationPasswordRecoveryBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDRequestAuthenticationPasswordRecoveryBuilder {
inner: RequestAuthenticationPasswordRecovery
}
impl RTDRequestAuthenticationPasswordRecoveryBuilder {
pub fn build(&self) -> RequestAuthenticationPasswordRecovery { self.inner.clone() }
}
impl AsRef<RequestAuthenticationPasswordRecovery> for RequestAuthenticationPasswordRecovery {
fn as_ref(&self) -> &RequestAuthenticationPasswordRecovery { self }
}
impl AsRef<RequestAuthenticationPasswordRecovery> for RTDRequestAuthenticationPasswordRecoveryBuilder {
fn as_ref(&self) -> &RequestAuthenticationPasswordRecovery { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RecoverAuthenticationPassword {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
recovery_code: String,
}
impl RObject for RecoverAuthenticationPassword {
#[doc(hidden)] fn td_name(&self) -> &'static str { "recoverAuthenticationPassword" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RecoverAuthenticationPassword {}
impl RecoverAuthenticationPassword {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRecoverAuthenticationPasswordBuilder {
let mut inner = RecoverAuthenticationPassword::default();
inner.td_name = "recoverAuthenticationPassword".to_string();
RTDRecoverAuthenticationPasswordBuilder { inner }
}
pub fn recovery_code(&self) -> &String { &self.recovery_code }
}
#[doc(hidden)]
pub struct RTDRecoverAuthenticationPasswordBuilder {
inner: RecoverAuthenticationPassword
}
impl RTDRecoverAuthenticationPasswordBuilder {
pub fn build(&self) -> RecoverAuthenticationPassword { self.inner.clone() }
pub fn recovery_code<T: AsRef<str>>(&mut self, recovery_code: T) -> &mut Self {
self.inner.recovery_code = recovery_code.as_ref().to_string();
self
}
}
impl AsRef<RecoverAuthenticationPassword> for RecoverAuthenticationPassword {
fn as_ref(&self) -> &RecoverAuthenticationPassword { self }
}
impl AsRef<RecoverAuthenticationPassword> for RTDRecoverAuthenticationPasswordBuilder {
fn as_ref(&self) -> &RecoverAuthenticationPassword { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckAuthenticationBotToken {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
token: String,
}
impl RObject for CheckAuthenticationBotToken {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkAuthenticationBotToken" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CheckAuthenticationBotToken {}
impl CheckAuthenticationBotToken {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckAuthenticationBotTokenBuilder {
let mut inner = CheckAuthenticationBotToken::default();
inner.td_name = "checkAuthenticationBotToken".to_string();
RTDCheckAuthenticationBotTokenBuilder { inner }
}
pub fn token(&self) -> &String { &self.token }
}
#[doc(hidden)]
pub struct RTDCheckAuthenticationBotTokenBuilder {
inner: CheckAuthenticationBotToken
}
impl RTDCheckAuthenticationBotTokenBuilder {
pub fn build(&self) -> CheckAuthenticationBotToken { self.inner.clone() }
pub fn token<T: AsRef<str>>(&mut self, token: T) -> &mut Self {
self.inner.token = token.as_ref().to_string();
self
}
}
impl AsRef<CheckAuthenticationBotToken> for CheckAuthenticationBotToken {
fn as_ref(&self) -> &CheckAuthenticationBotToken { self }
}
impl AsRef<CheckAuthenticationBotToken> for RTDCheckAuthenticationBotTokenBuilder {
fn as_ref(&self) -> &CheckAuthenticationBotToken { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct LogOut {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for LogOut {
#[doc(hidden)] fn td_name(&self) -> &'static str { "logOut" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for LogOut {}
impl LogOut {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDLogOutBuilder {
let mut inner = LogOut::default();
inner.td_name = "logOut".to_string();
RTDLogOutBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDLogOutBuilder {
inner: LogOut
}
impl RTDLogOutBuilder {
pub fn build(&self) -> LogOut { self.inner.clone() }
}
impl AsRef<LogOut> for LogOut {
fn as_ref(&self) -> &LogOut { self }
}
impl AsRef<LogOut> for RTDLogOutBuilder {
fn as_ref(&self) -> &LogOut { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Close {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for Close {
#[doc(hidden)] fn td_name(&self) -> &'static str { "close" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for Close {}
impl Close {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCloseBuilder {
let mut inner = Close::default();
inner.td_name = "close".to_string();
RTDCloseBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDCloseBuilder {
inner: Close
}
impl RTDCloseBuilder {
pub fn build(&self) -> Close { self.inner.clone() }
}
impl AsRef<Close> for Close {
fn as_ref(&self) -> &Close { self }
}
impl AsRef<Close> for RTDCloseBuilder {
fn as_ref(&self) -> &Close { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Destroy {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for Destroy {
#[doc(hidden)] fn td_name(&self) -> &'static str { "destroy" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for Destroy {}
impl Destroy {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDestroyBuilder {
let mut inner = Destroy::default();
inner.td_name = "destroy".to_string();
RTDDestroyBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDDestroyBuilder {
inner: Destroy
}
impl RTDDestroyBuilder {
pub fn build(&self) -> Destroy { self.inner.clone() }
}
impl AsRef<Destroy> for Destroy {
fn as_ref(&self) -> &Destroy { self }
}
impl AsRef<Destroy> for RTDDestroyBuilder {
fn as_ref(&self) -> &Destroy { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetDatabaseEncryptionKey {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
new_encryption_key: String,
}
impl RObject for SetDatabaseEncryptionKey {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setDatabaseEncryptionKey" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetDatabaseEncryptionKey {}
impl SetDatabaseEncryptionKey {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetDatabaseEncryptionKeyBuilder {
let mut inner = SetDatabaseEncryptionKey::default();
inner.td_name = "setDatabaseEncryptionKey".to_string();
RTDSetDatabaseEncryptionKeyBuilder { inner }
}
pub fn new_encryption_key(&self) -> &String { &self.new_encryption_key }
}
#[doc(hidden)]
pub struct RTDSetDatabaseEncryptionKeyBuilder {
inner: SetDatabaseEncryptionKey
}
impl RTDSetDatabaseEncryptionKeyBuilder {
pub fn build(&self) -> SetDatabaseEncryptionKey { self.inner.clone() }
pub fn new_encryption_key<T: AsRef<str>>(&mut self, new_encryption_key: T) -> &mut Self {
self.inner.new_encryption_key = new_encryption_key.as_ref().to_string();
self
}
}
impl AsRef<SetDatabaseEncryptionKey> for SetDatabaseEncryptionKey {
fn as_ref(&self) -> &SetDatabaseEncryptionKey { self }
}
impl AsRef<SetDatabaseEncryptionKey> for RTDSetDatabaseEncryptionKeyBuilder {
fn as_ref(&self) -> &SetDatabaseEncryptionKey { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetPasswordState {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetPasswordState {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getPasswordState" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetPasswordState {}
impl GetPasswordState {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetPasswordStateBuilder {
let mut inner = GetPasswordState::default();
inner.td_name = "getPasswordState".to_string();
RTDGetPasswordStateBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetPasswordStateBuilder {
inner: GetPasswordState
}
impl RTDGetPasswordStateBuilder {
pub fn build(&self) -> GetPasswordState { self.inner.clone() }
}
impl AsRef<GetPasswordState> for GetPasswordState {
fn as_ref(&self) -> &GetPasswordState { self }
}
impl AsRef<GetPasswordState> for RTDGetPasswordStateBuilder {
fn as_ref(&self) -> &GetPasswordState { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetPassword {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
old_password: String,
new_password: String,
new_hint: String,
set_recovery_email_address: bool,
new_recovery_email_address: String,
}
impl RObject for SetPassword {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setPassword" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetPassword {}
impl SetPassword {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetPasswordBuilder {
let mut inner = SetPassword::default();
inner.td_name = "setPassword".to_string();
RTDSetPasswordBuilder { inner }
}
pub fn old_password(&self) -> &String { &self.old_password }
pub fn new_password(&self) -> &String { &self.new_password }
pub fn new_hint(&self) -> &String { &self.new_hint }
pub fn set_recovery_email_address(&self) -> bool { self.set_recovery_email_address }
pub fn new_recovery_email_address(&self) -> &String { &self.new_recovery_email_address }
}
#[doc(hidden)]
pub struct RTDSetPasswordBuilder {
inner: SetPassword
}
impl RTDSetPasswordBuilder {
pub fn build(&self) -> SetPassword { self.inner.clone() }
pub fn old_password<T: AsRef<str>>(&mut self, old_password: T) -> &mut Self {
self.inner.old_password = old_password.as_ref().to_string();
self
}
pub fn new_password<T: AsRef<str>>(&mut self, new_password: T) -> &mut Self {
self.inner.new_password = new_password.as_ref().to_string();
self
}
pub fn new_hint<T: AsRef<str>>(&mut self, new_hint: T) -> &mut Self {
self.inner.new_hint = new_hint.as_ref().to_string();
self
}
pub fn set_recovery_email_address(&mut self, set_recovery_email_address: bool) -> &mut Self {
self.inner.set_recovery_email_address = set_recovery_email_address;
self
}
pub fn new_recovery_email_address<T: AsRef<str>>(&mut self, new_recovery_email_address: T) -> &mut Self {
self.inner.new_recovery_email_address = new_recovery_email_address.as_ref().to_string();
self
}
}
impl AsRef<SetPassword> for SetPassword {
fn as_ref(&self) -> &SetPassword { self }
}
impl AsRef<SetPassword> for RTDSetPasswordBuilder {
fn as_ref(&self) -> &SetPassword { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetRecoveryEmailAddress {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
password: String,
}
impl RObject for GetRecoveryEmailAddress {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getRecoveryEmailAddress" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetRecoveryEmailAddress {}
impl GetRecoveryEmailAddress {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetRecoveryEmailAddressBuilder {
let mut inner = GetRecoveryEmailAddress::default();
inner.td_name = "getRecoveryEmailAddress".to_string();
RTDGetRecoveryEmailAddressBuilder { inner }
}
pub fn password(&self) -> &String { &self.password }
}
#[doc(hidden)]
pub struct RTDGetRecoveryEmailAddressBuilder {
inner: GetRecoveryEmailAddress
}
impl RTDGetRecoveryEmailAddressBuilder {
pub fn build(&self) -> GetRecoveryEmailAddress { self.inner.clone() }
pub fn password<T: AsRef<str>>(&mut self, password: T) -> &mut Self {
self.inner.password = password.as_ref().to_string();
self
}
}
impl AsRef<GetRecoveryEmailAddress> for GetRecoveryEmailAddress {
fn as_ref(&self) -> &GetRecoveryEmailAddress { self }
}
impl AsRef<GetRecoveryEmailAddress> for RTDGetRecoveryEmailAddressBuilder {
fn as_ref(&self) -> &GetRecoveryEmailAddress { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetRecoveryEmailAddress {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
password: String,
new_recovery_email_address: String,
}
impl RObject for SetRecoveryEmailAddress {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setRecoveryEmailAddress" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetRecoveryEmailAddress {}
impl SetRecoveryEmailAddress {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetRecoveryEmailAddressBuilder {
let mut inner = SetRecoveryEmailAddress::default();
inner.td_name = "setRecoveryEmailAddress".to_string();
RTDSetRecoveryEmailAddressBuilder { inner }
}
pub fn password(&self) -> &String { &self.password }
pub fn new_recovery_email_address(&self) -> &String { &self.new_recovery_email_address }
}
#[doc(hidden)]
pub struct RTDSetRecoveryEmailAddressBuilder {
inner: SetRecoveryEmailAddress
}
impl RTDSetRecoveryEmailAddressBuilder {
pub fn build(&self) -> SetRecoveryEmailAddress { self.inner.clone() }
pub fn password<T: AsRef<str>>(&mut self, password: T) -> &mut Self {
self.inner.password = password.as_ref().to_string();
self
}
pub fn new_recovery_email_address<T: AsRef<str>>(&mut self, new_recovery_email_address: T) -> &mut Self {
self.inner.new_recovery_email_address = new_recovery_email_address.as_ref().to_string();
self
}
}
impl AsRef<SetRecoveryEmailAddress> for SetRecoveryEmailAddress {
fn as_ref(&self) -> &SetRecoveryEmailAddress { self }
}
impl AsRef<SetRecoveryEmailAddress> for RTDSetRecoveryEmailAddressBuilder {
fn as_ref(&self) -> &SetRecoveryEmailAddress { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RequestPasswordRecovery {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for RequestPasswordRecovery {
#[doc(hidden)] fn td_name(&self) -> &'static str { "requestPasswordRecovery" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RequestPasswordRecovery {}
impl RequestPasswordRecovery {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRequestPasswordRecoveryBuilder {
let mut inner = RequestPasswordRecovery::default();
inner.td_name = "requestPasswordRecovery".to_string();
RTDRequestPasswordRecoveryBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDRequestPasswordRecoveryBuilder {
inner: RequestPasswordRecovery
}
impl RTDRequestPasswordRecoveryBuilder {
pub fn build(&self) -> RequestPasswordRecovery { self.inner.clone() }
}
impl AsRef<RequestPasswordRecovery> for RequestPasswordRecovery {
fn as_ref(&self) -> &RequestPasswordRecovery { self }
}
impl AsRef<RequestPasswordRecovery> for RTDRequestPasswordRecoveryBuilder {
fn as_ref(&self) -> &RequestPasswordRecovery { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RecoverPassword {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
recovery_code: String,
}
impl RObject for RecoverPassword {
#[doc(hidden)] fn td_name(&self) -> &'static str { "recoverPassword" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RecoverPassword {}
impl RecoverPassword {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRecoverPasswordBuilder {
let mut inner = RecoverPassword::default();
inner.td_name = "recoverPassword".to_string();
RTDRecoverPasswordBuilder { inner }
}
pub fn recovery_code(&self) -> &String { &self.recovery_code }
}
#[doc(hidden)]
pub struct RTDRecoverPasswordBuilder {
inner: RecoverPassword
}
impl RTDRecoverPasswordBuilder {
pub fn build(&self) -> RecoverPassword { self.inner.clone() }
pub fn recovery_code<T: AsRef<str>>(&mut self, recovery_code: T) -> &mut Self {
self.inner.recovery_code = recovery_code.as_ref().to_string();
self
}
}
impl AsRef<RecoverPassword> for RecoverPassword {
fn as_ref(&self) -> &RecoverPassword { self }
}
impl AsRef<RecoverPassword> for RTDRecoverPasswordBuilder {
fn as_ref(&self) -> &RecoverPassword { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateTemporaryPassword {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
password: String,
valid_for: i64,
}
impl RObject for CreateTemporaryPassword {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createTemporaryPassword" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreateTemporaryPassword {}
impl CreateTemporaryPassword {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreateTemporaryPasswordBuilder {
let mut inner = CreateTemporaryPassword::default();
inner.td_name = "createTemporaryPassword".to_string();
RTDCreateTemporaryPasswordBuilder { inner }
}
pub fn password(&self) -> &String { &self.password }
pub fn valid_for(&self) -> i64 { self.valid_for }
}
#[doc(hidden)]
pub struct RTDCreateTemporaryPasswordBuilder {
inner: CreateTemporaryPassword
}
impl RTDCreateTemporaryPasswordBuilder {
pub fn build(&self) -> CreateTemporaryPassword { self.inner.clone() }
pub fn password<T: AsRef<str>>(&mut self, password: T) -> &mut Self {
self.inner.password = password.as_ref().to_string();
self
}
pub fn valid_for(&mut self, valid_for: i64) -> &mut Self {
self.inner.valid_for = valid_for;
self
}
}
impl AsRef<CreateTemporaryPassword> for CreateTemporaryPassword {
fn as_ref(&self) -> &CreateTemporaryPassword { self }
}
impl AsRef<CreateTemporaryPassword> for RTDCreateTemporaryPasswordBuilder {
fn as_ref(&self) -> &CreateTemporaryPassword { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetTemporaryPasswordState {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetTemporaryPasswordState {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getTemporaryPasswordState" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetTemporaryPasswordState {}
impl GetTemporaryPasswordState {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetTemporaryPasswordStateBuilder {
let mut inner = GetTemporaryPasswordState::default();
inner.td_name = "getTemporaryPasswordState".to_string();
RTDGetTemporaryPasswordStateBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetTemporaryPasswordStateBuilder {
inner: GetTemporaryPasswordState
}
impl RTDGetTemporaryPasswordStateBuilder {
pub fn build(&self) -> GetTemporaryPasswordState { self.inner.clone() }
}
impl AsRef<GetTemporaryPasswordState> for GetTemporaryPasswordState {
fn as_ref(&self) -> &GetTemporaryPasswordState { self }
}
impl AsRef<GetTemporaryPasswordState> for RTDGetTemporaryPasswordStateBuilder {
fn as_ref(&self) -> &GetTemporaryPasswordState { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ProcessDcUpdate {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
dc: String,
addr: String,
}
impl RObject for ProcessDcUpdate {
#[doc(hidden)] fn td_name(&self) -> &'static str { "processDcUpdate" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ProcessDcUpdate {}
impl ProcessDcUpdate {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDProcessDcUpdateBuilder {
let mut inner = ProcessDcUpdate::default();
inner.td_name = "processDcUpdate".to_string();
RTDProcessDcUpdateBuilder { inner }
}
pub fn dc(&self) -> &String { &self.dc }
pub fn addr(&self) -> &String { &self.addr }
}
#[doc(hidden)]
pub struct RTDProcessDcUpdateBuilder {
inner: ProcessDcUpdate
}
impl RTDProcessDcUpdateBuilder {
pub fn build(&self) -> ProcessDcUpdate { self.inner.clone() }
pub fn dc<T: AsRef<str>>(&mut self, dc: T) -> &mut Self {
self.inner.dc = dc.as_ref().to_string();
self
}
pub fn addr<T: AsRef<str>>(&mut self, addr: T) -> &mut Self {
self.inner.addr = addr.as_ref().to_string();
self
}
}
impl AsRef<ProcessDcUpdate> for ProcessDcUpdate {
fn as_ref(&self) -> &ProcessDcUpdate { self }
}
impl AsRef<ProcessDcUpdate> for RTDProcessDcUpdateBuilder {
fn as_ref(&self) -> &ProcessDcUpdate { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetMe {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetMe {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getMe" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetMe {}
impl GetMe {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetMeBuilder {
let mut inner = GetMe::default();
inner.td_name = "getMe".to_string();
RTDGetMeBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetMeBuilder {
inner: GetMe
}
impl RTDGetMeBuilder {
pub fn build(&self) -> GetMe { self.inner.clone() }
}
impl AsRef<GetMe> for GetMe {
fn as_ref(&self) -> &GetMe { self }
}
impl AsRef<GetMe> for RTDGetMeBuilder {
fn as_ref(&self) -> &GetMe { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetUser {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
}
impl RObject for GetUser {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getUser" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetUser {}
impl GetUser {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetUserBuilder {
let mut inner = GetUser::default();
inner.td_name = "getUser".to_string();
RTDGetUserBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
}
#[doc(hidden)]
pub struct RTDGetUserBuilder {
inner: GetUser
}
impl RTDGetUserBuilder {
pub fn build(&self) -> GetUser { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<GetUser> for GetUser {
fn as_ref(&self) -> &GetUser { self }
}
impl AsRef<GetUser> for RTDGetUserBuilder {
fn as_ref(&self) -> &GetUser { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetUserFullInfo {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
}
impl RObject for GetUserFullInfo {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getUserFullInfo" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetUserFullInfo {}
impl GetUserFullInfo {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetUserFullInfoBuilder {
let mut inner = GetUserFullInfo::default();
inner.td_name = "getUserFullInfo".to_string();
RTDGetUserFullInfoBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
}
#[doc(hidden)]
pub struct RTDGetUserFullInfoBuilder {
inner: GetUserFullInfo
}
impl RTDGetUserFullInfoBuilder {
pub fn build(&self) -> GetUserFullInfo { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<GetUserFullInfo> for GetUserFullInfo {
fn as_ref(&self) -> &GetUserFullInfo { self }
}
impl AsRef<GetUserFullInfo> for RTDGetUserFullInfoBuilder {
fn as_ref(&self) -> &GetUserFullInfo { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetBasicGroup {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
basic_group_id: i64,
}
impl RObject for GetBasicGroup {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getBasicGroup" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetBasicGroup {}
impl GetBasicGroup {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetBasicGroupBuilder {
let mut inner = GetBasicGroup::default();
inner.td_name = "getBasicGroup".to_string();
RTDGetBasicGroupBuilder { inner }
}
pub fn basic_group_id(&self) -> i64 { self.basic_group_id }
}
#[doc(hidden)]
pub struct RTDGetBasicGroupBuilder {
inner: GetBasicGroup
}
impl RTDGetBasicGroupBuilder {
pub fn build(&self) -> GetBasicGroup { self.inner.clone() }
pub fn basic_group_id(&mut self, basic_group_id: i64) -> &mut Self {
self.inner.basic_group_id = basic_group_id;
self
}
}
impl AsRef<GetBasicGroup> for GetBasicGroup {
fn as_ref(&self) -> &GetBasicGroup { self }
}
impl AsRef<GetBasicGroup> for RTDGetBasicGroupBuilder {
fn as_ref(&self) -> &GetBasicGroup { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetBasicGroupFullInfo {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
basic_group_id: i64,
}
impl RObject for GetBasicGroupFullInfo {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getBasicGroupFullInfo" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetBasicGroupFullInfo {}
impl GetBasicGroupFullInfo {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetBasicGroupFullInfoBuilder {
let mut inner = GetBasicGroupFullInfo::default();
inner.td_name = "getBasicGroupFullInfo".to_string();
RTDGetBasicGroupFullInfoBuilder { inner }
}
pub fn basic_group_id(&self) -> i64 { self.basic_group_id }
}
#[doc(hidden)]
pub struct RTDGetBasicGroupFullInfoBuilder {
inner: GetBasicGroupFullInfo
}
impl RTDGetBasicGroupFullInfoBuilder {
pub fn build(&self) -> GetBasicGroupFullInfo { self.inner.clone() }
pub fn basic_group_id(&mut self, basic_group_id: i64) -> &mut Self {
self.inner.basic_group_id = basic_group_id;
self
}
}
impl AsRef<GetBasicGroupFullInfo> for GetBasicGroupFullInfo {
fn as_ref(&self) -> &GetBasicGroupFullInfo { self }
}
impl AsRef<GetBasicGroupFullInfo> for RTDGetBasicGroupFullInfoBuilder {
fn as_ref(&self) -> &GetBasicGroupFullInfo { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetSupergroup {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
}
impl RObject for GetSupergroup {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getSupergroup" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetSupergroup {}
impl GetSupergroup {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetSupergroupBuilder {
let mut inner = GetSupergroup::default();
inner.td_name = "getSupergroup".to_string();
RTDGetSupergroupBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
}
#[doc(hidden)]
pub struct RTDGetSupergroupBuilder {
inner: GetSupergroup
}
impl RTDGetSupergroupBuilder {
pub fn build(&self) -> GetSupergroup { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
}
impl AsRef<GetSupergroup> for GetSupergroup {
fn as_ref(&self) -> &GetSupergroup { self }
}
impl AsRef<GetSupergroup> for RTDGetSupergroupBuilder {
fn as_ref(&self) -> &GetSupergroup { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetSupergroupFullInfo {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
}
impl RObject for GetSupergroupFullInfo {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getSupergroupFullInfo" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetSupergroupFullInfo {}
impl GetSupergroupFullInfo {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetSupergroupFullInfoBuilder {
let mut inner = GetSupergroupFullInfo::default();
inner.td_name = "getSupergroupFullInfo".to_string();
RTDGetSupergroupFullInfoBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
}
#[doc(hidden)]
pub struct RTDGetSupergroupFullInfoBuilder {
inner: GetSupergroupFullInfo
}
impl RTDGetSupergroupFullInfoBuilder {
pub fn build(&self) -> GetSupergroupFullInfo { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
}
impl AsRef<GetSupergroupFullInfo> for GetSupergroupFullInfo {
fn as_ref(&self) -> &GetSupergroupFullInfo { self }
}
impl AsRef<GetSupergroupFullInfo> for RTDGetSupergroupFullInfoBuilder {
fn as_ref(&self) -> &GetSupergroupFullInfo { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetSecretChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
secret_chat_id: i64,
}
impl RObject for GetSecretChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getSecretChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetSecretChat {}
impl GetSecretChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetSecretChatBuilder {
let mut inner = GetSecretChat::default();
inner.td_name = "getSecretChat".to_string();
RTDGetSecretChatBuilder { inner }
}
pub fn secret_chat_id(&self) -> i64 { self.secret_chat_id }
}
#[doc(hidden)]
pub struct RTDGetSecretChatBuilder {
inner: GetSecretChat
}
impl RTDGetSecretChatBuilder {
pub fn build(&self) -> GetSecretChat { self.inner.clone() }
pub fn secret_chat_id(&mut self, secret_chat_id: i64) -> &mut Self {
self.inner.secret_chat_id = secret_chat_id;
self
}
}
impl AsRef<GetSecretChat> for GetSecretChat {
fn as_ref(&self) -> &GetSecretChat { self }
}
impl AsRef<GetSecretChat> for RTDGetSecretChatBuilder {
fn as_ref(&self) -> &GetSecretChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for GetChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChat {}
impl GetChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatBuilder {
let mut inner = GetChat::default();
inner.td_name = "getChat".to_string();
RTDGetChatBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDGetChatBuilder {
inner: GetChat
}
impl RTDGetChatBuilder {
pub fn build(&self) -> GetChat { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<GetChat> for GetChat {
fn as_ref(&self) -> &GetChat { self }
}
impl AsRef<GetChat> for RTDGetChatBuilder {
fn as_ref(&self) -> &GetChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
}
impl RObject for GetMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetMessage {}
impl GetMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetMessageBuilder {
let mut inner = GetMessage::default();
inner.td_name = "getMessage".to_string();
RTDGetMessageBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
}
#[doc(hidden)]
pub struct RTDGetMessageBuilder {
inner: GetMessage
}
impl RTDGetMessageBuilder {
pub fn build(&self) -> GetMessage { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
}
impl AsRef<GetMessage> for GetMessage {
fn as_ref(&self) -> &GetMessage { self }
}
impl AsRef<GetMessage> for RTDGetMessageBuilder {
fn as_ref(&self) -> &GetMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetRepliedMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
}
impl RObject for GetRepliedMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getRepliedMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetRepliedMessage {}
impl GetRepliedMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetRepliedMessageBuilder {
let mut inner = GetRepliedMessage::default();
inner.td_name = "getRepliedMessage".to_string();
RTDGetRepliedMessageBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
}
#[doc(hidden)]
pub struct RTDGetRepliedMessageBuilder {
inner: GetRepliedMessage
}
impl RTDGetRepliedMessageBuilder {
pub fn build(&self) -> GetRepliedMessage { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
}
impl AsRef<GetRepliedMessage> for GetRepliedMessage {
fn as_ref(&self) -> &GetRepliedMessage { self }
}
impl AsRef<GetRepliedMessage> for RTDGetRepliedMessageBuilder {
fn as_ref(&self) -> &GetRepliedMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChatPinnedMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for GetChatPinnedMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChatPinnedMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChatPinnedMessage {}
impl GetChatPinnedMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatPinnedMessageBuilder {
let mut inner = GetChatPinnedMessage::default();
inner.td_name = "getChatPinnedMessage".to_string();
RTDGetChatPinnedMessageBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDGetChatPinnedMessageBuilder {
inner: GetChatPinnedMessage
}
impl RTDGetChatPinnedMessageBuilder {
pub fn build(&self) -> GetChatPinnedMessage { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<GetChatPinnedMessage> for GetChatPinnedMessage {
fn as_ref(&self) -> &GetChatPinnedMessage { self }
}
impl AsRef<GetChatPinnedMessage> for RTDGetChatPinnedMessageBuilder {
fn as_ref(&self) -> &GetChatPinnedMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_ids: Vec<i64>,
}
impl RObject for GetMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetMessages {}
impl GetMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetMessagesBuilder {
let mut inner = GetMessages::default();
inner.td_name = "getMessages".to_string();
RTDGetMessagesBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_ids(&self) -> &Vec<i64> { &self.message_ids }
}
#[doc(hidden)]
pub struct RTDGetMessagesBuilder {
inner: GetMessages
}
impl RTDGetMessagesBuilder {
pub fn build(&self) -> GetMessages { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_ids(&mut self, message_ids: Vec<i64>) -> &mut Self {
self.inner.message_ids = message_ids;
self
}
}
impl AsRef<GetMessages> for GetMessages {
fn as_ref(&self) -> &GetMessages { self }
}
impl AsRef<GetMessages> for RTDGetMessagesBuilder {
fn as_ref(&self) -> &GetMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetFile {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
file_id: i64,
}
impl RObject for GetFile {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getFile" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetFile {}
impl GetFile {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetFileBuilder {
let mut inner = GetFile::default();
inner.td_name = "getFile".to_string();
RTDGetFileBuilder { inner }
}
pub fn file_id(&self) -> i64 { self.file_id }
}
#[doc(hidden)]
pub struct RTDGetFileBuilder {
inner: GetFile
}
impl RTDGetFileBuilder {
pub fn build(&self) -> GetFile { self.inner.clone() }
pub fn file_id(&mut self, file_id: i64) -> &mut Self {
self.inner.file_id = file_id;
self
}
}
impl AsRef<GetFile> for GetFile {
fn as_ref(&self) -> &GetFile { self }
}
impl AsRef<GetFile> for RTDGetFileBuilder {
fn as_ref(&self) -> &GetFile { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetRemoteFile {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
remote_file_id: String,
file_type: FileType,
}
impl RObject for GetRemoteFile {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getRemoteFile" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetRemoteFile {}
impl GetRemoteFile {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetRemoteFileBuilder {
let mut inner = GetRemoteFile::default();
inner.td_name = "getRemoteFile".to_string();
RTDGetRemoteFileBuilder { inner }
}
pub fn remote_file_id(&self) -> &String { &self.remote_file_id }
pub fn file_type(&self) -> &FileType { &self.file_type }
}
#[doc(hidden)]
pub struct RTDGetRemoteFileBuilder {
inner: GetRemoteFile
}
impl RTDGetRemoteFileBuilder {
pub fn build(&self) -> GetRemoteFile { self.inner.clone() }
pub fn remote_file_id<T: AsRef<str>>(&mut self, remote_file_id: T) -> &mut Self {
self.inner.remote_file_id = remote_file_id.as_ref().to_string();
self
}
pub fn file_type<T: AsRef<FileType>>(&mut self, file_type: T) -> &mut Self {
self.inner.file_type = file_type.as_ref().clone();
self
}
}
impl AsRef<GetRemoteFile> for GetRemoteFile {
fn as_ref(&self) -> &GetRemoteFile { self }
}
impl AsRef<GetRemoteFile> for RTDGetRemoteFileBuilder {
fn as_ref(&self) -> &GetRemoteFile { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChats {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
offset_order: isize,
offset_chat_id: i64,
limit: i64,
}
impl RObject for GetChats {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChats" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChats {}
impl GetChats {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatsBuilder {
let mut inner = GetChats::default();
inner.td_name = "getChats".to_string();
RTDGetChatsBuilder { inner }
}
pub fn offset_order(&self) -> isize { self.offset_order }
pub fn offset_chat_id(&self) -> i64 { self.offset_chat_id }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDGetChatsBuilder {
inner: GetChats
}
impl RTDGetChatsBuilder {
pub fn build(&self) -> GetChats { self.inner.clone() }
pub fn offset_order(&mut self, offset_order: isize) -> &mut Self {
self.inner.offset_order = offset_order;
self
}
pub fn offset_chat_id(&mut self, offset_chat_id: i64) -> &mut Self {
self.inner.offset_chat_id = offset_chat_id;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<GetChats> for GetChats {
fn as_ref(&self) -> &GetChats { self }
}
impl AsRef<GetChats> for RTDGetChatsBuilder {
fn as_ref(&self) -> &GetChats { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchPublicChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
username: String,
}
impl RObject for SearchPublicChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchPublicChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchPublicChat {}
impl SearchPublicChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchPublicChatBuilder {
let mut inner = SearchPublicChat::default();
inner.td_name = "searchPublicChat".to_string();
RTDSearchPublicChatBuilder { inner }
}
pub fn username(&self) -> &String { &self.username }
}
#[doc(hidden)]
pub struct RTDSearchPublicChatBuilder {
inner: SearchPublicChat
}
impl RTDSearchPublicChatBuilder {
pub fn build(&self) -> SearchPublicChat { self.inner.clone() }
pub fn username<T: AsRef<str>>(&mut self, username: T) -> &mut Self {
self.inner.username = username.as_ref().to_string();
self
}
}
impl AsRef<SearchPublicChat> for SearchPublicChat {
fn as_ref(&self) -> &SearchPublicChat { self }
}
impl AsRef<SearchPublicChat> for RTDSearchPublicChatBuilder {
fn as_ref(&self) -> &SearchPublicChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchPublicChats {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
query: String,
}
impl RObject for SearchPublicChats {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchPublicChats" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchPublicChats {}
impl SearchPublicChats {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchPublicChatsBuilder {
let mut inner = SearchPublicChats::default();
inner.td_name = "searchPublicChats".to_string();
RTDSearchPublicChatsBuilder { inner }
}
pub fn query(&self) -> &String { &self.query }
}
#[doc(hidden)]
pub struct RTDSearchPublicChatsBuilder {
inner: SearchPublicChats
}
impl RTDSearchPublicChatsBuilder {
pub fn build(&self) -> SearchPublicChats { self.inner.clone() }
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
}
impl AsRef<SearchPublicChats> for SearchPublicChats {
fn as_ref(&self) -> &SearchPublicChats { self }
}
impl AsRef<SearchPublicChats> for RTDSearchPublicChatsBuilder {
fn as_ref(&self) -> &SearchPublicChats { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchChats {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
query: String,
limit: i64,
}
impl RObject for SearchChats {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchChats" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchChats {}
impl SearchChats {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchChatsBuilder {
let mut inner = SearchChats::default();
inner.td_name = "searchChats".to_string();
RTDSearchChatsBuilder { inner }
}
pub fn query(&self) -> &String { &self.query }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDSearchChatsBuilder {
inner: SearchChats
}
impl RTDSearchChatsBuilder {
pub fn build(&self) -> SearchChats { self.inner.clone() }
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<SearchChats> for SearchChats {
fn as_ref(&self) -> &SearchChats { self }
}
impl AsRef<SearchChats> for RTDSearchChatsBuilder {
fn as_ref(&self) -> &SearchChats { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchChatsOnServer {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
query: String,
limit: i64,
}
impl RObject for SearchChatsOnServer {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchChatsOnServer" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchChatsOnServer {}
impl SearchChatsOnServer {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchChatsOnServerBuilder {
let mut inner = SearchChatsOnServer::default();
inner.td_name = "searchChatsOnServer".to_string();
RTDSearchChatsOnServerBuilder { inner }
}
pub fn query(&self) -> &String { &self.query }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDSearchChatsOnServerBuilder {
inner: SearchChatsOnServer
}
impl RTDSearchChatsOnServerBuilder {
pub fn build(&self) -> SearchChatsOnServer { self.inner.clone() }
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<SearchChatsOnServer> for SearchChatsOnServer {
fn as_ref(&self) -> &SearchChatsOnServer { self }
}
impl AsRef<SearchChatsOnServer> for RTDSearchChatsOnServerBuilder {
fn as_ref(&self) -> &SearchChatsOnServer { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetTopChats {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
category: TopChatCategory,
limit: i64,
}
impl RObject for GetTopChats {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getTopChats" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetTopChats {}
impl GetTopChats {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetTopChatsBuilder {
let mut inner = GetTopChats::default();
inner.td_name = "getTopChats".to_string();
RTDGetTopChatsBuilder { inner }
}
pub fn category(&self) -> &TopChatCategory { &self.category }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDGetTopChatsBuilder {
inner: GetTopChats
}
impl RTDGetTopChatsBuilder {
pub fn build(&self) -> GetTopChats { self.inner.clone() }
pub fn category<T: AsRef<TopChatCategory>>(&mut self, category: T) -> &mut Self {
self.inner.category = category.as_ref().clone();
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<GetTopChats> for GetTopChats {
fn as_ref(&self) -> &GetTopChats { self }
}
impl AsRef<GetTopChats> for RTDGetTopChatsBuilder {
fn as_ref(&self) -> &GetTopChats { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RemoveTopChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
category: TopChatCategory,
chat_id: i64,
}
impl RObject for RemoveTopChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "removeTopChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RemoveTopChat {}
impl RemoveTopChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRemoveTopChatBuilder {
let mut inner = RemoveTopChat::default();
inner.td_name = "removeTopChat".to_string();
RTDRemoveTopChatBuilder { inner }
}
pub fn category(&self) -> &TopChatCategory { &self.category }
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDRemoveTopChatBuilder {
inner: RemoveTopChat
}
impl RTDRemoveTopChatBuilder {
pub fn build(&self) -> RemoveTopChat { self.inner.clone() }
pub fn category<T: AsRef<TopChatCategory>>(&mut self, category: T) -> &mut Self {
self.inner.category = category.as_ref().clone();
self
}
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<RemoveTopChat> for RemoveTopChat {
fn as_ref(&self) -> &RemoveTopChat { self }
}
impl AsRef<RemoveTopChat> for RTDRemoveTopChatBuilder {
fn as_ref(&self) -> &RemoveTopChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddRecentlyFoundChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for AddRecentlyFoundChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addRecentlyFoundChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddRecentlyFoundChat {}
impl AddRecentlyFoundChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddRecentlyFoundChatBuilder {
let mut inner = AddRecentlyFoundChat::default();
inner.td_name = "addRecentlyFoundChat".to_string();
RTDAddRecentlyFoundChatBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDAddRecentlyFoundChatBuilder {
inner: AddRecentlyFoundChat
}
impl RTDAddRecentlyFoundChatBuilder {
pub fn build(&self) -> AddRecentlyFoundChat { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<AddRecentlyFoundChat> for AddRecentlyFoundChat {
fn as_ref(&self) -> &AddRecentlyFoundChat { self }
}
impl AsRef<AddRecentlyFoundChat> for RTDAddRecentlyFoundChatBuilder {
fn as_ref(&self) -> &AddRecentlyFoundChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RemoveRecentlyFoundChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for RemoveRecentlyFoundChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "removeRecentlyFoundChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RemoveRecentlyFoundChat {}
impl RemoveRecentlyFoundChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRemoveRecentlyFoundChatBuilder {
let mut inner = RemoveRecentlyFoundChat::default();
inner.td_name = "removeRecentlyFoundChat".to_string();
RTDRemoveRecentlyFoundChatBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDRemoveRecentlyFoundChatBuilder {
inner: RemoveRecentlyFoundChat
}
impl RTDRemoveRecentlyFoundChatBuilder {
pub fn build(&self) -> RemoveRecentlyFoundChat { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<RemoveRecentlyFoundChat> for RemoveRecentlyFoundChat {
fn as_ref(&self) -> &RemoveRecentlyFoundChat { self }
}
impl AsRef<RemoveRecentlyFoundChat> for RTDRemoveRecentlyFoundChatBuilder {
fn as_ref(&self) -> &RemoveRecentlyFoundChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ClearRecentlyFoundChats {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for ClearRecentlyFoundChats {
#[doc(hidden)] fn td_name(&self) -> &'static str { "clearRecentlyFoundChats" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ClearRecentlyFoundChats {}
impl ClearRecentlyFoundChats {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDClearRecentlyFoundChatsBuilder {
let mut inner = ClearRecentlyFoundChats::default();
inner.td_name = "clearRecentlyFoundChats".to_string();
RTDClearRecentlyFoundChatsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDClearRecentlyFoundChatsBuilder {
inner: ClearRecentlyFoundChats
}
impl RTDClearRecentlyFoundChatsBuilder {
pub fn build(&self) -> ClearRecentlyFoundChats { self.inner.clone() }
}
impl AsRef<ClearRecentlyFoundChats> for ClearRecentlyFoundChats {
fn as_ref(&self) -> &ClearRecentlyFoundChats { self }
}
impl AsRef<ClearRecentlyFoundChats> for RTDClearRecentlyFoundChatsBuilder {
fn as_ref(&self) -> &ClearRecentlyFoundChats { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckChatUsername {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: isize,
username: String,
}
impl RObject for CheckChatUsername {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkChatUsername" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl TDCheckChatUsernameResult for CheckChatUsername {}
impl RFunction for CheckChatUsername {}
impl CheckChatUsername {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckChatUsernameBuilder {
let mut inner = CheckChatUsername::default();
inner.td_name = "checkChatUsername".to_string();
RTDCheckChatUsernameBuilder { inner }
}
pub fn chat_id(&self) -> isize { self.chat_id }
pub fn username(&self) -> &String { &self.username }
}
#[doc(hidden)]
pub struct RTDCheckChatUsernameBuilder {
inner: CheckChatUsername
}
impl RTDCheckChatUsernameBuilder {
pub fn build(&self) -> CheckChatUsername { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: isize) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn username<T: AsRef<str>>(&mut self, username: T) -> &mut Self {
self.inner.username = username.as_ref().to_string();
self
}
}
impl AsRef<CheckChatUsername> for CheckChatUsername {
fn as_ref(&self) -> &CheckChatUsername { self }
}
impl AsRef<CheckChatUsername> for RTDCheckChatUsernameBuilder {
fn as_ref(&self) -> &CheckChatUsername { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetCreatedPublicChats {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetCreatedPublicChats {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getCreatedPublicChats" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetCreatedPublicChats {}
impl GetCreatedPublicChats {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetCreatedPublicChatsBuilder {
let mut inner = GetCreatedPublicChats::default();
inner.td_name = "getCreatedPublicChats".to_string();
RTDGetCreatedPublicChatsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetCreatedPublicChatsBuilder {
inner: GetCreatedPublicChats
}
impl RTDGetCreatedPublicChatsBuilder {
pub fn build(&self) -> GetCreatedPublicChats { self.inner.clone() }
}
impl AsRef<GetCreatedPublicChats> for GetCreatedPublicChats {
fn as_ref(&self) -> &GetCreatedPublicChats { self }
}
impl AsRef<GetCreatedPublicChats> for RTDGetCreatedPublicChatsBuilder {
fn as_ref(&self) -> &GetCreatedPublicChats { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetGroupsInCommon {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
offset_chat_id: i64,
limit: i64,
}
impl RObject for GetGroupsInCommon {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getGroupsInCommon" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetGroupsInCommon {}
impl GetGroupsInCommon {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetGroupsInCommonBuilder {
let mut inner = GetGroupsInCommon::default();
inner.td_name = "getGroupsInCommon".to_string();
RTDGetGroupsInCommonBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
pub fn offset_chat_id(&self) -> i64 { self.offset_chat_id }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDGetGroupsInCommonBuilder {
inner: GetGroupsInCommon
}
impl RTDGetGroupsInCommonBuilder {
pub fn build(&self) -> GetGroupsInCommon { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn offset_chat_id(&mut self, offset_chat_id: i64) -> &mut Self {
self.inner.offset_chat_id = offset_chat_id;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<GetGroupsInCommon> for GetGroupsInCommon {
fn as_ref(&self) -> &GetGroupsInCommon { self }
}
impl AsRef<GetGroupsInCommon> for RTDGetGroupsInCommonBuilder {
fn as_ref(&self) -> &GetGroupsInCommon { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChatHistory {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
from_message_id: i64,
offset: i64,
limit: i64,
only_local: bool,
}
impl RObject for GetChatHistory {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChatHistory" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChatHistory {}
impl GetChatHistory {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatHistoryBuilder {
let mut inner = GetChatHistory::default();
inner.td_name = "getChatHistory".to_string();
RTDGetChatHistoryBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn from_message_id(&self) -> i64 { self.from_message_id }
pub fn offset(&self) -> i64 { self.offset }
pub fn limit(&self) -> i64 { self.limit }
pub fn only_local(&self) -> bool { self.only_local }
}
#[doc(hidden)]
pub struct RTDGetChatHistoryBuilder {
inner: GetChatHistory
}
impl RTDGetChatHistoryBuilder {
pub fn build(&self) -> GetChatHistory { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn from_message_id(&mut self, from_message_id: i64) -> &mut Self {
self.inner.from_message_id = from_message_id;
self
}
pub fn offset(&mut self, offset: i64) -> &mut Self {
self.inner.offset = offset;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
pub fn only_local(&mut self, only_local: bool) -> &mut Self {
self.inner.only_local = only_local;
self
}
}
impl AsRef<GetChatHistory> for GetChatHistory {
fn as_ref(&self) -> &GetChatHistory { self }
}
impl AsRef<GetChatHistory> for RTDGetChatHistoryBuilder {
fn as_ref(&self) -> &GetChatHistory { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteChatHistory {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
remove_from_chat_list: bool,
}
impl RObject for DeleteChatHistory {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteChatHistory" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteChatHistory {}
impl DeleteChatHistory {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteChatHistoryBuilder {
let mut inner = DeleteChatHistory::default();
inner.td_name = "deleteChatHistory".to_string();
RTDDeleteChatHistoryBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn remove_from_chat_list(&self) -> bool { self.remove_from_chat_list }
}
#[doc(hidden)]
pub struct RTDDeleteChatHistoryBuilder {
inner: DeleteChatHistory
}
impl RTDDeleteChatHistoryBuilder {
pub fn build(&self) -> DeleteChatHistory { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn remove_from_chat_list(&mut self, remove_from_chat_list: bool) -> &mut Self {
self.inner.remove_from_chat_list = remove_from_chat_list;
self
}
}
impl AsRef<DeleteChatHistory> for DeleteChatHistory {
fn as_ref(&self) -> &DeleteChatHistory { self }
}
impl AsRef<DeleteChatHistory> for RTDDeleteChatHistoryBuilder {
fn as_ref(&self) -> &DeleteChatHistory { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchChatMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
query: String,
sender_user_id: i64,
from_message_id: i64,
offset: i64,
limit: i64,
filter: SearchMessagesFilter,
}
impl RObject for SearchChatMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchChatMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchChatMessages {}
impl SearchChatMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchChatMessagesBuilder {
let mut inner = SearchChatMessages::default();
inner.td_name = "searchChatMessages".to_string();
RTDSearchChatMessagesBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn query(&self) -> &String { &self.query }
pub fn sender_user_id(&self) -> i64 { self.sender_user_id }
pub fn from_message_id(&self) -> i64 { self.from_message_id }
pub fn offset(&self) -> i64 { self.offset }
pub fn limit(&self) -> i64 { self.limit }
pub fn filter(&self) -> &SearchMessagesFilter { &self.filter }
}
#[doc(hidden)]
pub struct RTDSearchChatMessagesBuilder {
inner: SearchChatMessages
}
impl RTDSearchChatMessagesBuilder {
pub fn build(&self) -> SearchChatMessages { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn sender_user_id(&mut self, sender_user_id: i64) -> &mut Self {
self.inner.sender_user_id = sender_user_id;
self
}
pub fn from_message_id(&mut self, from_message_id: i64) -> &mut Self {
self.inner.from_message_id = from_message_id;
self
}
pub fn offset(&mut self, offset: i64) -> &mut Self {
self.inner.offset = offset;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
pub fn filter<T: AsRef<SearchMessagesFilter>>(&mut self, filter: T) -> &mut Self {
self.inner.filter = filter.as_ref().clone();
self
}
}
impl AsRef<SearchChatMessages> for SearchChatMessages {
fn as_ref(&self) -> &SearchChatMessages { self }
}
impl AsRef<SearchChatMessages> for RTDSearchChatMessagesBuilder {
fn as_ref(&self) -> &SearchChatMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
query: String,
offset_date: i64,
offset_chat_id: i64,
offset_message_id: i64,
limit: i64,
}
impl RObject for SearchMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchMessages {}
impl SearchMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchMessagesBuilder {
let mut inner = SearchMessages::default();
inner.td_name = "searchMessages".to_string();
RTDSearchMessagesBuilder { inner }
}
pub fn query(&self) -> &String { &self.query }
pub fn offset_date(&self) -> i64 { self.offset_date }
pub fn offset_chat_id(&self) -> i64 { self.offset_chat_id }
pub fn offset_message_id(&self) -> i64 { self.offset_message_id }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDSearchMessagesBuilder {
inner: SearchMessages
}
impl RTDSearchMessagesBuilder {
pub fn build(&self) -> SearchMessages { self.inner.clone() }
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn offset_date(&mut self, offset_date: i64) -> &mut Self {
self.inner.offset_date = offset_date;
self
}
pub fn offset_chat_id(&mut self, offset_chat_id: i64) -> &mut Self {
self.inner.offset_chat_id = offset_chat_id;
self
}
pub fn offset_message_id(&mut self, offset_message_id: i64) -> &mut Self {
self.inner.offset_message_id = offset_message_id;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<SearchMessages> for SearchMessages {
fn as_ref(&self) -> &SearchMessages { self }
}
impl AsRef<SearchMessages> for RTDSearchMessagesBuilder {
fn as_ref(&self) -> &SearchMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchSecretMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
query: String,
from_search_id: isize,
limit: i64,
filter: SearchMessagesFilter,
}
impl RObject for SearchSecretMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchSecretMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchSecretMessages {}
impl SearchSecretMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchSecretMessagesBuilder {
let mut inner = SearchSecretMessages::default();
inner.td_name = "searchSecretMessages".to_string();
RTDSearchSecretMessagesBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn query(&self) -> &String { &self.query }
pub fn from_search_id(&self) -> isize { self.from_search_id }
pub fn limit(&self) -> i64 { self.limit }
pub fn filter(&self) -> &SearchMessagesFilter { &self.filter }
}
#[doc(hidden)]
pub struct RTDSearchSecretMessagesBuilder {
inner: SearchSecretMessages
}
impl RTDSearchSecretMessagesBuilder {
pub fn build(&self) -> SearchSecretMessages { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn from_search_id(&mut self, from_search_id: isize) -> &mut Self {
self.inner.from_search_id = from_search_id;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
pub fn filter<T: AsRef<SearchMessagesFilter>>(&mut self, filter: T) -> &mut Self {
self.inner.filter = filter.as_ref().clone();
self
}
}
impl AsRef<SearchSecretMessages> for SearchSecretMessages {
fn as_ref(&self) -> &SearchSecretMessages { self }
}
impl AsRef<SearchSecretMessages> for RTDSearchSecretMessagesBuilder {
fn as_ref(&self) -> &SearchSecretMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchCallMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
from_message_id: i64,
limit: i64,
only_missed: bool,
}
impl RObject for SearchCallMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchCallMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchCallMessages {}
impl SearchCallMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchCallMessagesBuilder {
let mut inner = SearchCallMessages::default();
inner.td_name = "searchCallMessages".to_string();
RTDSearchCallMessagesBuilder { inner }
}
pub fn from_message_id(&self) -> i64 { self.from_message_id }
pub fn limit(&self) -> i64 { self.limit }
pub fn only_missed(&self) -> bool { self.only_missed }
}
#[doc(hidden)]
pub struct RTDSearchCallMessagesBuilder {
inner: SearchCallMessages
}
impl RTDSearchCallMessagesBuilder {
pub fn build(&self) -> SearchCallMessages { self.inner.clone() }
pub fn from_message_id(&mut self, from_message_id: i64) -> &mut Self {
self.inner.from_message_id = from_message_id;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
pub fn only_missed(&mut self, only_missed: bool) -> &mut Self {
self.inner.only_missed = only_missed;
self
}
}
impl AsRef<SearchCallMessages> for SearchCallMessages {
fn as_ref(&self) -> &SearchCallMessages { self }
}
impl AsRef<SearchCallMessages> for RTDSearchCallMessagesBuilder {
fn as_ref(&self) -> &SearchCallMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchChatRecentLocationMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
limit: i64,
}
impl RObject for SearchChatRecentLocationMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchChatRecentLocationMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchChatRecentLocationMessages {}
impl SearchChatRecentLocationMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchChatRecentLocationMessagesBuilder {
let mut inner = SearchChatRecentLocationMessages::default();
inner.td_name = "searchChatRecentLocationMessages".to_string();
RTDSearchChatRecentLocationMessagesBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDSearchChatRecentLocationMessagesBuilder {
inner: SearchChatRecentLocationMessages
}
impl RTDSearchChatRecentLocationMessagesBuilder {
pub fn build(&self) -> SearchChatRecentLocationMessages { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<SearchChatRecentLocationMessages> for SearchChatRecentLocationMessages {
fn as_ref(&self) -> &SearchChatRecentLocationMessages { self }
}
impl AsRef<SearchChatRecentLocationMessages> for RTDSearchChatRecentLocationMessagesBuilder {
fn as_ref(&self) -> &SearchChatRecentLocationMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetActiveLiveLocationMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetActiveLiveLocationMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getActiveLiveLocationMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetActiveLiveLocationMessages {}
impl GetActiveLiveLocationMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetActiveLiveLocationMessagesBuilder {
let mut inner = GetActiveLiveLocationMessages::default();
inner.td_name = "getActiveLiveLocationMessages".to_string();
RTDGetActiveLiveLocationMessagesBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetActiveLiveLocationMessagesBuilder {
inner: GetActiveLiveLocationMessages
}
impl RTDGetActiveLiveLocationMessagesBuilder {
pub fn build(&self) -> GetActiveLiveLocationMessages { self.inner.clone() }
}
impl AsRef<GetActiveLiveLocationMessages> for GetActiveLiveLocationMessages {
fn as_ref(&self) -> &GetActiveLiveLocationMessages { self }
}
impl AsRef<GetActiveLiveLocationMessages> for RTDGetActiveLiveLocationMessagesBuilder {
fn as_ref(&self) -> &GetActiveLiveLocationMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChatMessageByDate {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
date: i64,
}
impl RObject for GetChatMessageByDate {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChatMessageByDate" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChatMessageByDate {}
impl GetChatMessageByDate {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatMessageByDateBuilder {
let mut inner = GetChatMessageByDate::default();
inner.td_name = "getChatMessageByDate".to_string();
RTDGetChatMessageByDateBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn date(&self) -> i64 { self.date }
}
#[doc(hidden)]
pub struct RTDGetChatMessageByDateBuilder {
inner: GetChatMessageByDate
}
impl RTDGetChatMessageByDateBuilder {
pub fn build(&self) -> GetChatMessageByDate { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn date(&mut self, date: i64) -> &mut Self {
self.inner.date = date;
self
}
}
impl AsRef<GetChatMessageByDate> for GetChatMessageByDate {
fn as_ref(&self) -> &GetChatMessageByDate { self }
}
impl AsRef<GetChatMessageByDate> for RTDGetChatMessageByDateBuilder {
fn as_ref(&self) -> &GetChatMessageByDate { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChatMessageCount {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
filter: SearchMessagesFilter,
return_local: bool,
}
impl RObject for GetChatMessageCount {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChatMessageCount" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChatMessageCount {}
impl GetChatMessageCount {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatMessageCountBuilder {
let mut inner = GetChatMessageCount::default();
inner.td_name = "getChatMessageCount".to_string();
RTDGetChatMessageCountBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn filter(&self) -> &SearchMessagesFilter { &self.filter }
pub fn return_local(&self) -> bool { self.return_local }
}
#[doc(hidden)]
pub struct RTDGetChatMessageCountBuilder {
inner: GetChatMessageCount
}
impl RTDGetChatMessageCountBuilder {
pub fn build(&self) -> GetChatMessageCount { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn filter<T: AsRef<SearchMessagesFilter>>(&mut self, filter: T) -> &mut Self {
self.inner.filter = filter.as_ref().clone();
self
}
pub fn return_local(&mut self, return_local: bool) -> &mut Self {
self.inner.return_local = return_local;
self
}
}
impl AsRef<GetChatMessageCount> for GetChatMessageCount {
fn as_ref(&self) -> &GetChatMessageCount { self }
}
impl AsRef<GetChatMessageCount> for RTDGetChatMessageCountBuilder {
fn as_ref(&self) -> &GetChatMessageCount { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetPublicMessageLink {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
for_album: bool,
}
impl RObject for GetPublicMessageLink {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getPublicMessageLink" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetPublicMessageLink {}
impl GetPublicMessageLink {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetPublicMessageLinkBuilder {
let mut inner = GetPublicMessageLink::default();
inner.td_name = "getPublicMessageLink".to_string();
RTDGetPublicMessageLinkBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn for_album(&self) -> bool { self.for_album }
}
#[doc(hidden)]
pub struct RTDGetPublicMessageLinkBuilder {
inner: GetPublicMessageLink
}
impl RTDGetPublicMessageLinkBuilder {
pub fn build(&self) -> GetPublicMessageLink { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn for_album(&mut self, for_album: bool) -> &mut Self {
self.inner.for_album = for_album;
self
}
}
impl AsRef<GetPublicMessageLink> for GetPublicMessageLink {
fn as_ref(&self) -> &GetPublicMessageLink { self }
}
impl AsRef<GetPublicMessageLink> for RTDGetPublicMessageLinkBuilder {
fn as_ref(&self) -> &GetPublicMessageLink { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
reply_to_message_id: i64,
disable_notification: bool,
from_background: bool,
reply_markup: ReplyMarkup,
input_message_content: InputMessageContent,
}
impl RObject for SendMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendMessage {}
impl SendMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendMessageBuilder {
let mut inner = SendMessage::default();
inner.td_name = "sendMessage".to_string();
RTDSendMessageBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn reply_to_message_id(&self) -> i64 { self.reply_to_message_id }
pub fn disable_notification(&self) -> bool { self.disable_notification }
pub fn from_background(&self) -> bool { self.from_background }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
pub fn input_message_content(&self) -> &InputMessageContent { &self.input_message_content }
}
#[doc(hidden)]
pub struct RTDSendMessageBuilder {
inner: SendMessage
}
impl RTDSendMessageBuilder {
pub fn build(&self) -> SendMessage { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn reply_to_message_id(&mut self, reply_to_message_id: i64) -> &mut Self {
self.inner.reply_to_message_id = reply_to_message_id;
self
}
pub fn disable_notification(&mut self, disable_notification: bool) -> &mut Self {
self.inner.disable_notification = disable_notification;
self
}
pub fn from_background(&mut self, from_background: bool) -> &mut Self {
self.inner.from_background = from_background;
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.as_ref().clone();
self
}
pub fn input_message_content<T: AsRef<InputMessageContent>>(&mut self, input_message_content: T) -> &mut Self {
self.inner.input_message_content = input_message_content.as_ref().clone();
self
}
}
impl AsRef<SendMessage> for SendMessage {
fn as_ref(&self) -> &SendMessage { self }
}
impl AsRef<SendMessage> for RTDSendMessageBuilder {
fn as_ref(&self) -> &SendMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendMessageAlbum {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
reply_to_message_id: i64,
disable_notification: bool,
from_background: bool,
input_message_contents: Vec<InputMessageContent>,
}
impl RObject for SendMessageAlbum {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendMessageAlbum" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendMessageAlbum {}
impl SendMessageAlbum {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendMessageAlbumBuilder {
let mut inner = SendMessageAlbum::default();
inner.td_name = "sendMessageAlbum".to_string();
RTDSendMessageAlbumBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn reply_to_message_id(&self) -> i64 { self.reply_to_message_id }
pub fn disable_notification(&self) -> bool { self.disable_notification }
pub fn from_background(&self) -> bool { self.from_background }
pub fn input_message_contents(&self) -> &Vec<InputMessageContent> { &self.input_message_contents }
}
#[doc(hidden)]
pub struct RTDSendMessageAlbumBuilder {
inner: SendMessageAlbum
}
impl RTDSendMessageAlbumBuilder {
pub fn build(&self) -> SendMessageAlbum { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn reply_to_message_id(&mut self, reply_to_message_id: i64) -> &mut Self {
self.inner.reply_to_message_id = reply_to_message_id;
self
}
pub fn disable_notification(&mut self, disable_notification: bool) -> &mut Self {
self.inner.disable_notification = disable_notification;
self
}
pub fn from_background(&mut self, from_background: bool) -> &mut Self {
self.inner.from_background = from_background;
self
}
pub fn input_message_contents(&mut self, input_message_contents: Vec<InputMessageContent>) -> &mut Self {
self.inner.input_message_contents = input_message_contents;
self
}
}
impl AsRef<SendMessageAlbum> for SendMessageAlbum {
fn as_ref(&self) -> &SendMessageAlbum { self }
}
impl AsRef<SendMessageAlbum> for RTDSendMessageAlbumBuilder {
fn as_ref(&self) -> &SendMessageAlbum { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendBotStartMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
bot_user_id: i64,
chat_id: i64,
parameter: String,
}
impl RObject for SendBotStartMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendBotStartMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendBotStartMessage {}
impl SendBotStartMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendBotStartMessageBuilder {
let mut inner = SendBotStartMessage::default();
inner.td_name = "sendBotStartMessage".to_string();
RTDSendBotStartMessageBuilder { inner }
}
pub fn bot_user_id(&self) -> i64 { self.bot_user_id }
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn parameter(&self) -> &String { &self.parameter }
}
#[doc(hidden)]
pub struct RTDSendBotStartMessageBuilder {
inner: SendBotStartMessage
}
impl RTDSendBotStartMessageBuilder {
pub fn build(&self) -> SendBotStartMessage { self.inner.clone() }
pub fn bot_user_id(&mut self, bot_user_id: i64) -> &mut Self {
self.inner.bot_user_id = bot_user_id;
self
}
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn parameter<T: AsRef<str>>(&mut self, parameter: T) -> &mut Self {
self.inner.parameter = parameter.as_ref().to_string();
self
}
}
impl AsRef<SendBotStartMessage> for SendBotStartMessage {
fn as_ref(&self) -> &SendBotStartMessage { self }
}
impl AsRef<SendBotStartMessage> for RTDSendBotStartMessageBuilder {
fn as_ref(&self) -> &SendBotStartMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendInlineQueryResultMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
reply_to_message_id: i64,
disable_notification: bool,
from_background: bool,
query_id: isize,
result_id: String,
}
impl RObject for SendInlineQueryResultMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendInlineQueryResultMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendInlineQueryResultMessage {}
impl SendInlineQueryResultMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendInlineQueryResultMessageBuilder {
let mut inner = SendInlineQueryResultMessage::default();
inner.td_name = "sendInlineQueryResultMessage".to_string();
RTDSendInlineQueryResultMessageBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn reply_to_message_id(&self) -> i64 { self.reply_to_message_id }
pub fn disable_notification(&self) -> bool { self.disable_notification }
pub fn from_background(&self) -> bool { self.from_background }
pub fn query_id(&self) -> isize { self.query_id }
pub fn result_id(&self) -> &String { &self.result_id }
}
#[doc(hidden)]
pub struct RTDSendInlineQueryResultMessageBuilder {
inner: SendInlineQueryResultMessage
}
impl RTDSendInlineQueryResultMessageBuilder {
pub fn build(&self) -> SendInlineQueryResultMessage { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn reply_to_message_id(&mut self, reply_to_message_id: i64) -> &mut Self {
self.inner.reply_to_message_id = reply_to_message_id;
self
}
pub fn disable_notification(&mut self, disable_notification: bool) -> &mut Self {
self.inner.disable_notification = disable_notification;
self
}
pub fn from_background(&mut self, from_background: bool) -> &mut Self {
self.inner.from_background = from_background;
self
}
pub fn query_id(&mut self, query_id: isize) -> &mut Self {
self.inner.query_id = query_id;
self
}
pub fn result_id<T: AsRef<str>>(&mut self, result_id: T) -> &mut Self {
self.inner.result_id = result_id.as_ref().to_string();
self
}
}
impl AsRef<SendInlineQueryResultMessage> for SendInlineQueryResultMessage {
fn as_ref(&self) -> &SendInlineQueryResultMessage { self }
}
impl AsRef<SendInlineQueryResultMessage> for RTDSendInlineQueryResultMessageBuilder {
fn as_ref(&self) -> &SendInlineQueryResultMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ForwardMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
from_chat_id: i64,
message_ids: Vec<i64>,
disable_notification: bool,
from_background: bool,
as_album: bool,
}
impl RObject for ForwardMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "forwardMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ForwardMessages {}
impl ForwardMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDForwardMessagesBuilder {
let mut inner = ForwardMessages::default();
inner.td_name = "forwardMessages".to_string();
RTDForwardMessagesBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn from_chat_id(&self) -> i64 { self.from_chat_id }
pub fn message_ids(&self) -> &Vec<i64> { &self.message_ids }
pub fn disable_notification(&self) -> bool { self.disable_notification }
pub fn from_background(&self) -> bool { self.from_background }
pub fn as_album(&self) -> bool { self.as_album }
}
#[doc(hidden)]
pub struct RTDForwardMessagesBuilder {
inner: ForwardMessages
}
impl RTDForwardMessagesBuilder {
pub fn build(&self) -> ForwardMessages { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn from_chat_id(&mut self, from_chat_id: i64) -> &mut Self {
self.inner.from_chat_id = from_chat_id;
self
}
pub fn message_ids(&mut self, message_ids: Vec<i64>) -> &mut Self {
self.inner.message_ids = message_ids;
self
}
pub fn disable_notification(&mut self, disable_notification: bool) -> &mut Self {
self.inner.disable_notification = disable_notification;
self
}
pub fn from_background(&mut self, from_background: bool) -> &mut Self {
self.inner.from_background = from_background;
self
}
pub fn as_album(&mut self, as_album: bool) -> &mut Self {
self.inner.as_album = as_album;
self
}
}
impl AsRef<ForwardMessages> for ForwardMessages {
fn as_ref(&self) -> &ForwardMessages { self }
}
impl AsRef<ForwardMessages> for RTDForwardMessagesBuilder {
fn as_ref(&self) -> &ForwardMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendChatSetTtlMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
ttl: i64,
}
impl RObject for SendChatSetTtlMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendChatSetTtlMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendChatSetTtlMessage {}
impl SendChatSetTtlMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendChatSetTtlMessageBuilder {
let mut inner = SendChatSetTtlMessage::default();
inner.td_name = "sendChatSetTtlMessage".to_string();
RTDSendChatSetTtlMessageBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn ttl(&self) -> i64 { self.ttl }
}
#[doc(hidden)]
pub struct RTDSendChatSetTtlMessageBuilder {
inner: SendChatSetTtlMessage
}
impl RTDSendChatSetTtlMessageBuilder {
pub fn build(&self) -> SendChatSetTtlMessage { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn ttl(&mut self, ttl: i64) -> &mut Self {
self.inner.ttl = ttl;
self
}
}
impl AsRef<SendChatSetTtlMessage> for SendChatSetTtlMessage {
fn as_ref(&self) -> &SendChatSetTtlMessage { self }
}
impl AsRef<SendChatSetTtlMessage> for RTDSendChatSetTtlMessageBuilder {
fn as_ref(&self) -> &SendChatSetTtlMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendChatScreenshotTakenNotification {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for SendChatScreenshotTakenNotification {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendChatScreenshotTakenNotification" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendChatScreenshotTakenNotification {}
impl SendChatScreenshotTakenNotification {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendChatScreenshotTakenNotificationBuilder {
let mut inner = SendChatScreenshotTakenNotification::default();
inner.td_name = "sendChatScreenshotTakenNotification".to_string();
RTDSendChatScreenshotTakenNotificationBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDSendChatScreenshotTakenNotificationBuilder {
inner: SendChatScreenshotTakenNotification
}
impl RTDSendChatScreenshotTakenNotificationBuilder {
pub fn build(&self) -> SendChatScreenshotTakenNotification { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<SendChatScreenshotTakenNotification> for SendChatScreenshotTakenNotification {
fn as_ref(&self) -> &SendChatScreenshotTakenNotification { self }
}
impl AsRef<SendChatScreenshotTakenNotification> for RTDSendChatScreenshotTakenNotificationBuilder {
fn as_ref(&self) -> &SendChatScreenshotTakenNotification { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddLocalMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
sender_user_id: i64,
reply_to_message_id: i64,
disable_notification: bool,
input_message_content: InputMessageContent,
}
impl RObject for AddLocalMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addLocalMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddLocalMessage {}
impl AddLocalMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddLocalMessageBuilder {
let mut inner = AddLocalMessage::default();
inner.td_name = "addLocalMessage".to_string();
RTDAddLocalMessageBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn sender_user_id(&self) -> i64 { self.sender_user_id }
pub fn reply_to_message_id(&self) -> i64 { self.reply_to_message_id }
pub fn disable_notification(&self) -> bool { self.disable_notification }
pub fn input_message_content(&self) -> &InputMessageContent { &self.input_message_content }
}
#[doc(hidden)]
pub struct RTDAddLocalMessageBuilder {
inner: AddLocalMessage
}
impl RTDAddLocalMessageBuilder {
pub fn build(&self) -> AddLocalMessage { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn sender_user_id(&mut self, sender_user_id: i64) -> &mut Self {
self.inner.sender_user_id = sender_user_id;
self
}
pub fn reply_to_message_id(&mut self, reply_to_message_id: i64) -> &mut Self {
self.inner.reply_to_message_id = reply_to_message_id;
self
}
pub fn disable_notification(&mut self, disable_notification: bool) -> &mut Self {
self.inner.disable_notification = disable_notification;
self
}
pub fn input_message_content<T: AsRef<InputMessageContent>>(&mut self, input_message_content: T) -> &mut Self {
self.inner.input_message_content = input_message_content.as_ref().clone();
self
}
}
impl AsRef<AddLocalMessage> for AddLocalMessage {
fn as_ref(&self) -> &AddLocalMessage { self }
}
impl AsRef<AddLocalMessage> for RTDAddLocalMessageBuilder {
fn as_ref(&self) -> &AddLocalMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_ids: Vec<i64>,
revoke: bool,
}
impl RObject for DeleteMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteMessages {}
impl DeleteMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteMessagesBuilder {
let mut inner = DeleteMessages::default();
inner.td_name = "deleteMessages".to_string();
RTDDeleteMessagesBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_ids(&self) -> &Vec<i64> { &self.message_ids }
pub fn revoke(&self) -> bool { self.revoke }
}
#[doc(hidden)]
pub struct RTDDeleteMessagesBuilder {
inner: DeleteMessages
}
impl RTDDeleteMessagesBuilder {
pub fn build(&self) -> DeleteMessages { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_ids(&mut self, message_ids: Vec<i64>) -> &mut Self {
self.inner.message_ids = message_ids;
self
}
pub fn revoke(&mut self, revoke: bool) -> &mut Self {
self.inner.revoke = revoke;
self
}
}
impl AsRef<DeleteMessages> for DeleteMessages {
fn as_ref(&self) -> &DeleteMessages { self }
}
impl AsRef<DeleteMessages> for RTDDeleteMessagesBuilder {
fn as_ref(&self) -> &DeleteMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteChatMessagesFromUser {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
user_id: i64,
}
impl RObject for DeleteChatMessagesFromUser {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteChatMessagesFromUser" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteChatMessagesFromUser {}
impl DeleteChatMessagesFromUser {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteChatMessagesFromUserBuilder {
let mut inner = DeleteChatMessagesFromUser::default();
inner.td_name = "deleteChatMessagesFromUser".to_string();
RTDDeleteChatMessagesFromUserBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn user_id(&self) -> i64 { self.user_id }
}
#[doc(hidden)]
pub struct RTDDeleteChatMessagesFromUserBuilder {
inner: DeleteChatMessagesFromUser
}
impl RTDDeleteChatMessagesFromUserBuilder {
pub fn build(&self) -> DeleteChatMessagesFromUser { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<DeleteChatMessagesFromUser> for DeleteChatMessagesFromUser {
fn as_ref(&self) -> &DeleteChatMessagesFromUser { self }
}
impl AsRef<DeleteChatMessagesFromUser> for RTDDeleteChatMessagesFromUserBuilder {
fn as_ref(&self) -> &DeleteChatMessagesFromUser { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditMessageText {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
reply_markup: ReplyMarkup,
input_message_content: InputMessageContent,
}
impl RObject for EditMessageText {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editMessageText" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditMessageText {}
impl EditMessageText {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditMessageTextBuilder {
let mut inner = EditMessageText::default();
inner.td_name = "editMessageText".to_string();
RTDEditMessageTextBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
pub fn input_message_content(&self) -> &InputMessageContent { &self.input_message_content }
}
#[doc(hidden)]
pub struct RTDEditMessageTextBuilder {
inner: EditMessageText
}
impl RTDEditMessageTextBuilder {
pub fn build(&self) -> EditMessageText { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.as_ref().clone();
self
}
pub fn input_message_content<T: AsRef<InputMessageContent>>(&mut self, input_message_content: T) -> &mut Self {
self.inner.input_message_content = input_message_content.as_ref().clone();
self
}
}
impl AsRef<EditMessageText> for EditMessageText {
fn as_ref(&self) -> &EditMessageText { self }
}
impl AsRef<EditMessageText> for RTDEditMessageTextBuilder {
fn as_ref(&self) -> &EditMessageText { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditMessageLiveLocation {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
reply_markup: ReplyMarkup,
location: Option<Location>,
}
impl RObject for EditMessageLiveLocation {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editMessageLiveLocation" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditMessageLiveLocation {}
impl EditMessageLiveLocation {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditMessageLiveLocationBuilder {
let mut inner = EditMessageLiveLocation::default();
inner.td_name = "editMessageLiveLocation".to_string();
RTDEditMessageLiveLocationBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
pub fn location(&self) -> &Option<Location> { &self.location }
}
#[doc(hidden)]
pub struct RTDEditMessageLiveLocationBuilder {
inner: EditMessageLiveLocation
}
impl RTDEditMessageLiveLocationBuilder {
pub fn build(&self) -> EditMessageLiveLocation { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.as_ref().clone();
self
}
pub fn location<T: AsRef<Location>>(&mut self, location: T) -> &mut Self {
self.inner.location = Some(location.as_ref().clone());
self
}
}
impl AsRef<EditMessageLiveLocation> for EditMessageLiveLocation {
fn as_ref(&self) -> &EditMessageLiveLocation { self }
}
impl AsRef<EditMessageLiveLocation> for RTDEditMessageLiveLocationBuilder {
fn as_ref(&self) -> &EditMessageLiveLocation { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditMessageMedia {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
reply_markup: ReplyMarkup,
input_message_content: InputMessageContent,
}
impl RObject for EditMessageMedia {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editMessageMedia" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditMessageMedia {}
impl EditMessageMedia {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditMessageMediaBuilder {
let mut inner = EditMessageMedia::default();
inner.td_name = "editMessageMedia".to_string();
RTDEditMessageMediaBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
pub fn input_message_content(&self) -> &InputMessageContent { &self.input_message_content }
}
#[doc(hidden)]
pub struct RTDEditMessageMediaBuilder {
inner: EditMessageMedia
}
impl RTDEditMessageMediaBuilder {
pub fn build(&self) -> EditMessageMedia { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.as_ref().clone();
self
}
pub fn input_message_content<T: AsRef<InputMessageContent>>(&mut self, input_message_content: T) -> &mut Self {
self.inner.input_message_content = input_message_content.as_ref().clone();
self
}
}
impl AsRef<EditMessageMedia> for EditMessageMedia {
fn as_ref(&self) -> &EditMessageMedia { self }
}
impl AsRef<EditMessageMedia> for RTDEditMessageMediaBuilder {
fn as_ref(&self) -> &EditMessageMedia { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditMessageCaption {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
reply_markup: ReplyMarkup,
caption: FormattedText,
}
impl RObject for EditMessageCaption {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editMessageCaption" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditMessageCaption {}
impl EditMessageCaption {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditMessageCaptionBuilder {
let mut inner = EditMessageCaption::default();
inner.td_name = "editMessageCaption".to_string();
RTDEditMessageCaptionBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
pub fn caption(&self) -> &FormattedText { &self.caption }
}
#[doc(hidden)]
pub struct RTDEditMessageCaptionBuilder {
inner: EditMessageCaption
}
impl RTDEditMessageCaptionBuilder {
pub fn build(&self) -> EditMessageCaption { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.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<EditMessageCaption> for EditMessageCaption {
fn as_ref(&self) -> &EditMessageCaption { self }
}
impl AsRef<EditMessageCaption> for RTDEditMessageCaptionBuilder {
fn as_ref(&self) -> &EditMessageCaption { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditMessageReplyMarkup {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
reply_markup: ReplyMarkup,
}
impl RObject for EditMessageReplyMarkup {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editMessageReplyMarkup" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditMessageReplyMarkup {}
impl EditMessageReplyMarkup {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditMessageReplyMarkupBuilder {
let mut inner = EditMessageReplyMarkup::default();
inner.td_name = "editMessageReplyMarkup".to_string();
RTDEditMessageReplyMarkupBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
}
#[doc(hidden)]
pub struct RTDEditMessageReplyMarkupBuilder {
inner: EditMessageReplyMarkup
}
impl RTDEditMessageReplyMarkupBuilder {
pub fn build(&self) -> EditMessageReplyMarkup { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.as_ref().clone();
self
}
}
impl AsRef<EditMessageReplyMarkup> for EditMessageReplyMarkup {
fn as_ref(&self) -> &EditMessageReplyMarkup { self }
}
impl AsRef<EditMessageReplyMarkup> for RTDEditMessageReplyMarkupBuilder {
fn as_ref(&self) -> &EditMessageReplyMarkup { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditInlineMessageText {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
inline_message_id: String,
reply_markup: ReplyMarkup,
input_message_content: InputMessageContent,
}
impl RObject for EditInlineMessageText {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editInlineMessageText" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditInlineMessageText {}
impl EditInlineMessageText {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditInlineMessageTextBuilder {
let mut inner = EditInlineMessageText::default();
inner.td_name = "editInlineMessageText".to_string();
RTDEditInlineMessageTextBuilder { inner }
}
pub fn inline_message_id(&self) -> &String { &self.inline_message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
pub fn input_message_content(&self) -> &InputMessageContent { &self.input_message_content }
}
#[doc(hidden)]
pub struct RTDEditInlineMessageTextBuilder {
inner: EditInlineMessageText
}
impl RTDEditInlineMessageTextBuilder {
pub fn build(&self) -> EditInlineMessageText { self.inner.clone() }
pub fn inline_message_id<T: AsRef<str>>(&mut self, inline_message_id: T) -> &mut Self {
self.inner.inline_message_id = inline_message_id.as_ref().to_string();
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.as_ref().clone();
self
}
pub fn input_message_content<T: AsRef<InputMessageContent>>(&mut self, input_message_content: T) -> &mut Self {
self.inner.input_message_content = input_message_content.as_ref().clone();
self
}
}
impl AsRef<EditInlineMessageText> for EditInlineMessageText {
fn as_ref(&self) -> &EditInlineMessageText { self }
}
impl AsRef<EditInlineMessageText> for RTDEditInlineMessageTextBuilder {
fn as_ref(&self) -> &EditInlineMessageText { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditInlineMessageLiveLocation {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
inline_message_id: String,
reply_markup: ReplyMarkup,
location: Option<Location>,
}
impl RObject for EditInlineMessageLiveLocation {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editInlineMessageLiveLocation" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditInlineMessageLiveLocation {}
impl EditInlineMessageLiveLocation {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditInlineMessageLiveLocationBuilder {
let mut inner = EditInlineMessageLiveLocation::default();
inner.td_name = "editInlineMessageLiveLocation".to_string();
RTDEditInlineMessageLiveLocationBuilder { inner }
}
pub fn inline_message_id(&self) -> &String { &self.inline_message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
pub fn location(&self) -> &Option<Location> { &self.location }
}
#[doc(hidden)]
pub struct RTDEditInlineMessageLiveLocationBuilder {
inner: EditInlineMessageLiveLocation
}
impl RTDEditInlineMessageLiveLocationBuilder {
pub fn build(&self) -> EditInlineMessageLiveLocation { self.inner.clone() }
pub fn inline_message_id<T: AsRef<str>>(&mut self, inline_message_id: T) -> &mut Self {
self.inner.inline_message_id = inline_message_id.as_ref().to_string();
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.as_ref().clone();
self
}
pub fn location<T: AsRef<Location>>(&mut self, location: T) -> &mut Self {
self.inner.location = Some(location.as_ref().clone());
self
}
}
impl AsRef<EditInlineMessageLiveLocation> for EditInlineMessageLiveLocation {
fn as_ref(&self) -> &EditInlineMessageLiveLocation { self }
}
impl AsRef<EditInlineMessageLiveLocation> for RTDEditInlineMessageLiveLocationBuilder {
fn as_ref(&self) -> &EditInlineMessageLiveLocation { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditInlineMessageMedia {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
inline_message_id: String,
reply_markup: ReplyMarkup,
input_message_content: InputMessageContent,
}
impl RObject for EditInlineMessageMedia {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editInlineMessageMedia" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditInlineMessageMedia {}
impl EditInlineMessageMedia {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditInlineMessageMediaBuilder {
let mut inner = EditInlineMessageMedia::default();
inner.td_name = "editInlineMessageMedia".to_string();
RTDEditInlineMessageMediaBuilder { inner }
}
pub fn inline_message_id(&self) -> &String { &self.inline_message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
pub fn input_message_content(&self) -> &InputMessageContent { &self.input_message_content }
}
#[doc(hidden)]
pub struct RTDEditInlineMessageMediaBuilder {
inner: EditInlineMessageMedia
}
impl RTDEditInlineMessageMediaBuilder {
pub fn build(&self) -> EditInlineMessageMedia { self.inner.clone() }
pub fn inline_message_id<T: AsRef<str>>(&mut self, inline_message_id: T) -> &mut Self {
self.inner.inline_message_id = inline_message_id.as_ref().to_string();
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.as_ref().clone();
self
}
pub fn input_message_content<T: AsRef<InputMessageContent>>(&mut self, input_message_content: T) -> &mut Self {
self.inner.input_message_content = input_message_content.as_ref().clone();
self
}
}
impl AsRef<EditInlineMessageMedia> for EditInlineMessageMedia {
fn as_ref(&self) -> &EditInlineMessageMedia { self }
}
impl AsRef<EditInlineMessageMedia> for RTDEditInlineMessageMediaBuilder {
fn as_ref(&self) -> &EditInlineMessageMedia { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditInlineMessageCaption {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
inline_message_id: String,
reply_markup: ReplyMarkup,
caption: FormattedText,
}
impl RObject for EditInlineMessageCaption {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editInlineMessageCaption" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditInlineMessageCaption {}
impl EditInlineMessageCaption {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditInlineMessageCaptionBuilder {
let mut inner = EditInlineMessageCaption::default();
inner.td_name = "editInlineMessageCaption".to_string();
RTDEditInlineMessageCaptionBuilder { inner }
}
pub fn inline_message_id(&self) -> &String { &self.inline_message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
pub fn caption(&self) -> &FormattedText { &self.caption }
}
#[doc(hidden)]
pub struct RTDEditInlineMessageCaptionBuilder {
inner: EditInlineMessageCaption
}
impl RTDEditInlineMessageCaptionBuilder {
pub fn build(&self) -> EditInlineMessageCaption { self.inner.clone() }
pub fn inline_message_id<T: AsRef<str>>(&mut self, inline_message_id: T) -> &mut Self {
self.inner.inline_message_id = inline_message_id.as_ref().to_string();
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.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<EditInlineMessageCaption> for EditInlineMessageCaption {
fn as_ref(&self) -> &EditInlineMessageCaption { self }
}
impl AsRef<EditInlineMessageCaption> for RTDEditInlineMessageCaptionBuilder {
fn as_ref(&self) -> &EditInlineMessageCaption { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditInlineMessageReplyMarkup {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
inline_message_id: String,
reply_markup: ReplyMarkup,
}
impl RObject for EditInlineMessageReplyMarkup {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editInlineMessageReplyMarkup" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditInlineMessageReplyMarkup {}
impl EditInlineMessageReplyMarkup {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditInlineMessageReplyMarkupBuilder {
let mut inner = EditInlineMessageReplyMarkup::default();
inner.td_name = "editInlineMessageReplyMarkup".to_string();
RTDEditInlineMessageReplyMarkupBuilder { inner }
}
pub fn inline_message_id(&self) -> &String { &self.inline_message_id }
pub fn reply_markup(&self) -> &ReplyMarkup { &self.reply_markup }
}
#[doc(hidden)]
pub struct RTDEditInlineMessageReplyMarkupBuilder {
inner: EditInlineMessageReplyMarkup
}
impl RTDEditInlineMessageReplyMarkupBuilder {
pub fn build(&self) -> EditInlineMessageReplyMarkup { self.inner.clone() }
pub fn inline_message_id<T: AsRef<str>>(&mut self, inline_message_id: T) -> &mut Self {
self.inner.inline_message_id = inline_message_id.as_ref().to_string();
self
}
pub fn reply_markup<T: AsRef<ReplyMarkup>>(&mut self, reply_markup: T) -> &mut Self {
self.inner.reply_markup = reply_markup.as_ref().clone();
self
}
}
impl AsRef<EditInlineMessageReplyMarkup> for EditInlineMessageReplyMarkup {
fn as_ref(&self) -> &EditInlineMessageReplyMarkup { self }
}
impl AsRef<EditInlineMessageReplyMarkup> for RTDEditInlineMessageReplyMarkupBuilder {
fn as_ref(&self) -> &EditInlineMessageReplyMarkup { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetTextEntities {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
text: String,
}
impl RObject for GetTextEntities {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getTextEntities" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetTextEntities {}
impl GetTextEntities {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetTextEntitiesBuilder {
let mut inner = GetTextEntities::default();
inner.td_name = "getTextEntities".to_string();
RTDGetTextEntitiesBuilder { inner }
}
pub fn text(&self) -> &String { &self.text }
}
#[doc(hidden)]
pub struct RTDGetTextEntitiesBuilder {
inner: GetTextEntities
}
impl RTDGetTextEntitiesBuilder {
pub fn build(&self) -> GetTextEntities { 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<GetTextEntities> for GetTextEntities {
fn as_ref(&self) -> &GetTextEntities { self }
}
impl AsRef<GetTextEntities> for RTDGetTextEntitiesBuilder {
fn as_ref(&self) -> &GetTextEntities { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ParseTextEntities {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
text: String,
parse_mode: TextParseMode,
}
impl RObject for ParseTextEntities {
#[doc(hidden)] fn td_name(&self) -> &'static str { "parseTextEntities" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ParseTextEntities {}
impl ParseTextEntities {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDParseTextEntitiesBuilder {
let mut inner = ParseTextEntities::default();
inner.td_name = "parseTextEntities".to_string();
RTDParseTextEntitiesBuilder { inner }
}
pub fn text(&self) -> &String { &self.text }
pub fn parse_mode(&self) -> &TextParseMode { &self.parse_mode }
}
#[doc(hidden)]
pub struct RTDParseTextEntitiesBuilder {
inner: ParseTextEntities
}
impl RTDParseTextEntitiesBuilder {
pub fn build(&self) -> ParseTextEntities { self.inner.clone() }
pub fn text<T: AsRef<str>>(&mut self, text: T) -> &mut Self {
self.inner.text = text.as_ref().to_string();
self
}
pub fn parse_mode<T: AsRef<TextParseMode>>(&mut self, parse_mode: T) -> &mut Self {
self.inner.parse_mode = parse_mode.as_ref().clone();
self
}
}
impl AsRef<ParseTextEntities> for ParseTextEntities {
fn as_ref(&self) -> &ParseTextEntities { self }
}
impl AsRef<ParseTextEntities> for RTDParseTextEntitiesBuilder {
fn as_ref(&self) -> &ParseTextEntities { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetFileMimeType {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
file_name: String,
}
impl RObject for GetFileMimeType {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getFileMimeType" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetFileMimeType {}
impl GetFileMimeType {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetFileMimeTypeBuilder {
let mut inner = GetFileMimeType::default();
inner.td_name = "getFileMimeType".to_string();
RTDGetFileMimeTypeBuilder { inner }
}
pub fn file_name(&self) -> &String { &self.file_name }
}
#[doc(hidden)]
pub struct RTDGetFileMimeTypeBuilder {
inner: GetFileMimeType
}
impl RTDGetFileMimeTypeBuilder {
pub fn build(&self) -> GetFileMimeType { self.inner.clone() }
pub fn file_name<T: AsRef<str>>(&mut self, file_name: T) -> &mut Self {
self.inner.file_name = file_name.as_ref().to_string();
self
}
}
impl AsRef<GetFileMimeType> for GetFileMimeType {
fn as_ref(&self) -> &GetFileMimeType { self }
}
impl AsRef<GetFileMimeType> for RTDGetFileMimeTypeBuilder {
fn as_ref(&self) -> &GetFileMimeType { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetFileExtension {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
mime_type: String,
}
impl RObject for GetFileExtension {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getFileExtension" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetFileExtension {}
impl GetFileExtension {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetFileExtensionBuilder {
let mut inner = GetFileExtension::default();
inner.td_name = "getFileExtension".to_string();
RTDGetFileExtensionBuilder { inner }
}
pub fn mime_type(&self) -> &String { &self.mime_type }
}
#[doc(hidden)]
pub struct RTDGetFileExtensionBuilder {
inner: GetFileExtension
}
impl RTDGetFileExtensionBuilder {
pub fn build(&self) -> GetFileExtension { self.inner.clone() }
pub fn mime_type<T: AsRef<str>>(&mut self, mime_type: T) -> &mut Self {
self.inner.mime_type = mime_type.as_ref().to_string();
self
}
}
impl AsRef<GetFileExtension> for GetFileExtension {
fn as_ref(&self) -> &GetFileExtension { self }
}
impl AsRef<GetFileExtension> for RTDGetFileExtensionBuilder {
fn as_ref(&self) -> &GetFileExtension { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CleanFileName {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
file_name: String,
}
impl RObject for CleanFileName {
#[doc(hidden)] fn td_name(&self) -> &'static str { "cleanFileName" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CleanFileName {}
impl CleanFileName {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCleanFileNameBuilder {
let mut inner = CleanFileName::default();
inner.td_name = "cleanFileName".to_string();
RTDCleanFileNameBuilder { inner }
}
pub fn file_name(&self) -> &String { &self.file_name }
}
#[doc(hidden)]
pub struct RTDCleanFileNameBuilder {
inner: CleanFileName
}
impl RTDCleanFileNameBuilder {
pub fn build(&self) -> CleanFileName { self.inner.clone() }
pub fn file_name<T: AsRef<str>>(&mut self, file_name: T) -> &mut Self {
self.inner.file_name = file_name.as_ref().to_string();
self
}
}
impl AsRef<CleanFileName> for CleanFileName {
fn as_ref(&self) -> &CleanFileName { self }
}
impl AsRef<CleanFileName> for RTDCleanFileNameBuilder {
fn as_ref(&self) -> &CleanFileName { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetLanguagePackString {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
language_pack_database_path: String,
localization_target: String,
language_pack_id: String,
key: String,
}
impl RObject for GetLanguagePackString {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getLanguagePackString" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl TDLanguagePackStringValue for GetLanguagePackString {}
impl RFunction for GetLanguagePackString {}
impl GetLanguagePackString {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetLanguagePackStringBuilder {
let mut inner = GetLanguagePackString::default();
inner.td_name = "getLanguagePackString".to_string();
RTDGetLanguagePackStringBuilder { inner }
}
pub fn language_pack_database_path(&self) -> &String { &self.language_pack_database_path }
pub fn localization_target(&self) -> &String { &self.localization_target }
pub fn language_pack_id(&self) -> &String { &self.language_pack_id }
pub fn key(&self) -> &String { &self.key }
}
#[doc(hidden)]
pub struct RTDGetLanguagePackStringBuilder {
inner: GetLanguagePackString
}
impl RTDGetLanguagePackStringBuilder {
pub fn build(&self) -> GetLanguagePackString { self.inner.clone() }
pub fn language_pack_database_path<T: AsRef<str>>(&mut self, language_pack_database_path: T) -> &mut Self {
self.inner.language_pack_database_path = language_pack_database_path.as_ref().to_string();
self
}
pub fn localization_target<T: AsRef<str>>(&mut self, localization_target: T) -> &mut Self {
self.inner.localization_target = localization_target.as_ref().to_string();
self
}
pub fn language_pack_id<T: AsRef<str>>(&mut self, language_pack_id: T) -> &mut Self {
self.inner.language_pack_id = language_pack_id.as_ref().to_string();
self
}
pub fn key<T: AsRef<str>>(&mut self, key: T) -> &mut Self {
self.inner.key = key.as_ref().to_string();
self
}
}
impl AsRef<GetLanguagePackString> for GetLanguagePackString {
fn as_ref(&self) -> &GetLanguagePackString { self }
}
impl AsRef<GetLanguagePackString> for RTDGetLanguagePackStringBuilder {
fn as_ref(&self) -> &GetLanguagePackString { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetInlineQueryResults {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
bot_user_id: i64,
chat_id: i64,
user_location: Location,
query: String,
offset: String,
}
impl RObject for GetInlineQueryResults {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getInlineQueryResults" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetInlineQueryResults {}
impl GetInlineQueryResults {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetInlineQueryResultsBuilder {
let mut inner = GetInlineQueryResults::default();
inner.td_name = "getInlineQueryResults".to_string();
RTDGetInlineQueryResultsBuilder { inner }
}
pub fn bot_user_id(&self) -> i64 { self.bot_user_id }
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn user_location(&self) -> &Location { &self.user_location }
pub fn query(&self) -> &String { &self.query }
pub fn offset(&self) -> &String { &self.offset }
}
#[doc(hidden)]
pub struct RTDGetInlineQueryResultsBuilder {
inner: GetInlineQueryResults
}
impl RTDGetInlineQueryResultsBuilder {
pub fn build(&self) -> GetInlineQueryResults { self.inner.clone() }
pub fn bot_user_id(&mut self, bot_user_id: i64) -> &mut Self {
self.inner.bot_user_id = bot_user_id;
self
}
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn user_location<T: AsRef<Location>>(&mut self, user_location: T) -> &mut Self {
self.inner.user_location = user_location.as_ref().clone();
self
}
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn offset<T: AsRef<str>>(&mut self, offset: T) -> &mut Self {
self.inner.offset = offset.as_ref().to_string();
self
}
}
impl AsRef<GetInlineQueryResults> for GetInlineQueryResults {
fn as_ref(&self) -> &GetInlineQueryResults { self }
}
impl AsRef<GetInlineQueryResults> for RTDGetInlineQueryResultsBuilder {
fn as_ref(&self) -> &GetInlineQueryResults { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AnswerInlineQuery {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
inline_query_id: isize,
is_personal: bool,
results: Vec<InputInlineQueryResult>,
cache_time: i64,
next_offset: String,
switch_pm_text: String,
switch_pm_parameter: String,
}
impl RObject for AnswerInlineQuery {
#[doc(hidden)] fn td_name(&self) -> &'static str { "answerInlineQuery" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AnswerInlineQuery {}
impl AnswerInlineQuery {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAnswerInlineQueryBuilder {
let mut inner = AnswerInlineQuery::default();
inner.td_name = "answerInlineQuery".to_string();
RTDAnswerInlineQueryBuilder { inner }
}
pub fn inline_query_id(&self) -> isize { self.inline_query_id }
pub fn is_personal(&self) -> bool { self.is_personal }
pub fn results(&self) -> &Vec<InputInlineQueryResult> { &self.results }
pub fn cache_time(&self) -> i64 { self.cache_time }
pub fn next_offset(&self) -> &String { &self.next_offset }
pub fn switch_pm_text(&self) -> &String { &self.switch_pm_text }
pub fn switch_pm_parameter(&self) -> &String { &self.switch_pm_parameter }
}
#[doc(hidden)]
pub struct RTDAnswerInlineQueryBuilder {
inner: AnswerInlineQuery
}
impl RTDAnswerInlineQueryBuilder {
pub fn build(&self) -> AnswerInlineQuery { self.inner.clone() }
pub fn inline_query_id(&mut self, inline_query_id: isize) -> &mut Self {
self.inner.inline_query_id = inline_query_id;
self
}
pub fn is_personal(&mut self, is_personal: bool) -> &mut Self {
self.inner.is_personal = is_personal;
self
}
pub fn results(&mut self, results: Vec<InputInlineQueryResult>) -> &mut Self {
self.inner.results = results;
self
}
pub fn cache_time(&mut self, cache_time: i64) -> &mut Self {
self.inner.cache_time = cache_time;
self
}
pub fn next_offset<T: AsRef<str>>(&mut self, next_offset: T) -> &mut Self {
self.inner.next_offset = next_offset.as_ref().to_string();
self
}
pub fn switch_pm_text<T: AsRef<str>>(&mut self, switch_pm_text: T) -> &mut Self {
self.inner.switch_pm_text = switch_pm_text.as_ref().to_string();
self
}
pub fn switch_pm_parameter<T: AsRef<str>>(&mut self, switch_pm_parameter: T) -> &mut Self {
self.inner.switch_pm_parameter = switch_pm_parameter.as_ref().to_string();
self
}
}
impl AsRef<AnswerInlineQuery> for AnswerInlineQuery {
fn as_ref(&self) -> &AnswerInlineQuery { self }
}
impl AsRef<AnswerInlineQuery> for RTDAnswerInlineQueryBuilder {
fn as_ref(&self) -> &AnswerInlineQuery { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetCallbackQueryAnswer {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
payload: CallbackQueryPayload,
}
impl RObject for GetCallbackQueryAnswer {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getCallbackQueryAnswer" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetCallbackQueryAnswer {}
impl GetCallbackQueryAnswer {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetCallbackQueryAnswerBuilder {
let mut inner = GetCallbackQueryAnswer::default();
inner.td_name = "getCallbackQueryAnswer".to_string();
RTDGetCallbackQueryAnswerBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn payload(&self) -> &CallbackQueryPayload { &self.payload }
}
#[doc(hidden)]
pub struct RTDGetCallbackQueryAnswerBuilder {
inner: GetCallbackQueryAnswer
}
impl RTDGetCallbackQueryAnswerBuilder {
pub fn build(&self) -> GetCallbackQueryAnswer { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn payload<T: AsRef<CallbackQueryPayload>>(&mut self, payload: T) -> &mut Self {
self.inner.payload = payload.as_ref().clone();
self
}
}
impl AsRef<GetCallbackQueryAnswer> for GetCallbackQueryAnswer {
fn as_ref(&self) -> &GetCallbackQueryAnswer { self }
}
impl AsRef<GetCallbackQueryAnswer> for RTDGetCallbackQueryAnswerBuilder {
fn as_ref(&self) -> &GetCallbackQueryAnswer { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AnswerCallbackQuery {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
callback_query_id: isize,
text: String,
show_alert: bool,
url: String,
cache_time: i64,
}
impl RObject for AnswerCallbackQuery {
#[doc(hidden)] fn td_name(&self) -> &'static str { "answerCallbackQuery" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AnswerCallbackQuery {}
impl AnswerCallbackQuery {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAnswerCallbackQueryBuilder {
let mut inner = AnswerCallbackQuery::default();
inner.td_name = "answerCallbackQuery".to_string();
RTDAnswerCallbackQueryBuilder { inner }
}
pub fn callback_query_id(&self) -> isize { self.callback_query_id }
pub fn text(&self) -> &String { &self.text }
pub fn show_alert(&self) -> bool { self.show_alert }
pub fn url(&self) -> &String { &self.url }
pub fn cache_time(&self) -> i64 { self.cache_time }
}
#[doc(hidden)]
pub struct RTDAnswerCallbackQueryBuilder {
inner: AnswerCallbackQuery
}
impl RTDAnswerCallbackQueryBuilder {
pub fn build(&self) -> AnswerCallbackQuery { self.inner.clone() }
pub fn callback_query_id(&mut self, callback_query_id: isize) -> &mut Self {
self.inner.callback_query_id = callback_query_id;
self
}
pub fn text<T: AsRef<str>>(&mut self, text: T) -> &mut Self {
self.inner.text = text.as_ref().to_string();
self
}
pub fn show_alert(&mut self, show_alert: bool) -> &mut Self {
self.inner.show_alert = show_alert;
self
}
pub fn url<T: AsRef<str>>(&mut self, url: T) -> &mut Self {
self.inner.url = url.as_ref().to_string();
self
}
pub fn cache_time(&mut self, cache_time: i64) -> &mut Self {
self.inner.cache_time = cache_time;
self
}
}
impl AsRef<AnswerCallbackQuery> for AnswerCallbackQuery {
fn as_ref(&self) -> &AnswerCallbackQuery { self }
}
impl AsRef<AnswerCallbackQuery> for RTDAnswerCallbackQueryBuilder {
fn as_ref(&self) -> &AnswerCallbackQuery { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AnswerShippingQuery {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
shipping_query_id: isize,
shipping_options: Vec<ShippingOption>,
error_message: String,
}
impl RObject for AnswerShippingQuery {
#[doc(hidden)] fn td_name(&self) -> &'static str { "answerShippingQuery" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AnswerShippingQuery {}
impl AnswerShippingQuery {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAnswerShippingQueryBuilder {
let mut inner = AnswerShippingQuery::default();
inner.td_name = "answerShippingQuery".to_string();
RTDAnswerShippingQueryBuilder { inner }
}
pub fn shipping_query_id(&self) -> isize { self.shipping_query_id }
pub fn shipping_options(&self) -> &Vec<ShippingOption> { &self.shipping_options }
pub fn error_message(&self) -> &String { &self.error_message }
}
#[doc(hidden)]
pub struct RTDAnswerShippingQueryBuilder {
inner: AnswerShippingQuery
}
impl RTDAnswerShippingQueryBuilder {
pub fn build(&self) -> AnswerShippingQuery { self.inner.clone() }
pub fn shipping_query_id(&mut self, shipping_query_id: isize) -> &mut Self {
self.inner.shipping_query_id = shipping_query_id;
self
}
pub fn shipping_options(&mut self, shipping_options: Vec<ShippingOption>) -> &mut Self {
self.inner.shipping_options = shipping_options;
self
}
pub fn error_message<T: AsRef<str>>(&mut self, error_message: T) -> &mut Self {
self.inner.error_message = error_message.as_ref().to_string();
self
}
}
impl AsRef<AnswerShippingQuery> for AnswerShippingQuery {
fn as_ref(&self) -> &AnswerShippingQuery { self }
}
impl AsRef<AnswerShippingQuery> for RTDAnswerShippingQueryBuilder {
fn as_ref(&self) -> &AnswerShippingQuery { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AnswerPreCheckoutQuery {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
pre_checkout_query_id: isize,
error_message: String,
}
impl RObject for AnswerPreCheckoutQuery {
#[doc(hidden)] fn td_name(&self) -> &'static str { "answerPreCheckoutQuery" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AnswerPreCheckoutQuery {}
impl AnswerPreCheckoutQuery {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAnswerPreCheckoutQueryBuilder {
let mut inner = AnswerPreCheckoutQuery::default();
inner.td_name = "answerPreCheckoutQuery".to_string();
RTDAnswerPreCheckoutQueryBuilder { inner }
}
pub fn pre_checkout_query_id(&self) -> isize { self.pre_checkout_query_id }
pub fn error_message(&self) -> &String { &self.error_message }
}
#[doc(hidden)]
pub struct RTDAnswerPreCheckoutQueryBuilder {
inner: AnswerPreCheckoutQuery
}
impl RTDAnswerPreCheckoutQueryBuilder {
pub fn build(&self) -> AnswerPreCheckoutQuery { self.inner.clone() }
pub fn pre_checkout_query_id(&mut self, pre_checkout_query_id: isize) -> &mut Self {
self.inner.pre_checkout_query_id = pre_checkout_query_id;
self
}
pub fn error_message<T: AsRef<str>>(&mut self, error_message: T) -> &mut Self {
self.inner.error_message = error_message.as_ref().to_string();
self
}
}
impl AsRef<AnswerPreCheckoutQuery> for AnswerPreCheckoutQuery {
fn as_ref(&self) -> &AnswerPreCheckoutQuery { self }
}
impl AsRef<AnswerPreCheckoutQuery> for RTDAnswerPreCheckoutQueryBuilder {
fn as_ref(&self) -> &AnswerPreCheckoutQuery { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetGameScore {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
edit_message: bool,
user_id: i64,
score: i64,
force: bool,
}
impl RObject for SetGameScore {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setGameScore" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetGameScore {}
impl SetGameScore {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetGameScoreBuilder {
let mut inner = SetGameScore::default();
inner.td_name = "setGameScore".to_string();
RTDSetGameScoreBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn edit_message(&self) -> bool { self.edit_message }
pub fn user_id(&self) -> i64 { self.user_id }
pub fn score(&self) -> i64 { self.score }
pub fn force(&self) -> bool { self.force }
}
#[doc(hidden)]
pub struct RTDSetGameScoreBuilder {
inner: SetGameScore
}
impl RTDSetGameScoreBuilder {
pub fn build(&self) -> SetGameScore { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn edit_message(&mut self, edit_message: bool) -> &mut Self {
self.inner.edit_message = edit_message;
self
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn score(&mut self, score: i64) -> &mut Self {
self.inner.score = score;
self
}
pub fn force(&mut self, force: bool) -> &mut Self {
self.inner.force = force;
self
}
}
impl AsRef<SetGameScore> for SetGameScore {
fn as_ref(&self) -> &SetGameScore { self }
}
impl AsRef<SetGameScore> for RTDSetGameScoreBuilder {
fn as_ref(&self) -> &SetGameScore { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetInlineGameScore {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
inline_message_id: String,
edit_message: bool,
user_id: i64,
score: i64,
force: bool,
}
impl RObject for SetInlineGameScore {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setInlineGameScore" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetInlineGameScore {}
impl SetInlineGameScore {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetInlineGameScoreBuilder {
let mut inner = SetInlineGameScore::default();
inner.td_name = "setInlineGameScore".to_string();
RTDSetInlineGameScoreBuilder { inner }
}
pub fn inline_message_id(&self) -> &String { &self.inline_message_id }
pub fn edit_message(&self) -> bool { self.edit_message }
pub fn user_id(&self) -> i64 { self.user_id }
pub fn score(&self) -> i64 { self.score }
pub fn force(&self) -> bool { self.force }
}
#[doc(hidden)]
pub struct RTDSetInlineGameScoreBuilder {
inner: SetInlineGameScore
}
impl RTDSetInlineGameScoreBuilder {
pub fn build(&self) -> SetInlineGameScore { self.inner.clone() }
pub fn inline_message_id<T: AsRef<str>>(&mut self, inline_message_id: T) -> &mut Self {
self.inner.inline_message_id = inline_message_id.as_ref().to_string();
self
}
pub fn edit_message(&mut self, edit_message: bool) -> &mut Self {
self.inner.edit_message = edit_message;
self
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn score(&mut self, score: i64) -> &mut Self {
self.inner.score = score;
self
}
pub fn force(&mut self, force: bool) -> &mut Self {
self.inner.force = force;
self
}
}
impl AsRef<SetInlineGameScore> for SetInlineGameScore {
fn as_ref(&self) -> &SetInlineGameScore { self }
}
impl AsRef<SetInlineGameScore> for RTDSetInlineGameScoreBuilder {
fn as_ref(&self) -> &SetInlineGameScore { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetGameHighScores {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
user_id: i64,
}
impl RObject for GetGameHighScores {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getGameHighScores" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetGameHighScores {}
impl GetGameHighScores {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetGameHighScoresBuilder {
let mut inner = GetGameHighScores::default();
inner.td_name = "getGameHighScores".to_string();
RTDGetGameHighScoresBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn user_id(&self) -> i64 { self.user_id }
}
#[doc(hidden)]
pub struct RTDGetGameHighScoresBuilder {
inner: GetGameHighScores
}
impl RTDGetGameHighScoresBuilder {
pub fn build(&self) -> GetGameHighScores { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<GetGameHighScores> for GetGameHighScores {
fn as_ref(&self) -> &GetGameHighScores { self }
}
impl AsRef<GetGameHighScores> for RTDGetGameHighScoresBuilder {
fn as_ref(&self) -> &GetGameHighScores { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetInlineGameHighScores {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
inline_message_id: String,
user_id: i64,
}
impl RObject for GetInlineGameHighScores {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getInlineGameHighScores" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetInlineGameHighScores {}
impl GetInlineGameHighScores {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetInlineGameHighScoresBuilder {
let mut inner = GetInlineGameHighScores::default();
inner.td_name = "getInlineGameHighScores".to_string();
RTDGetInlineGameHighScoresBuilder { inner }
}
pub fn inline_message_id(&self) -> &String { &self.inline_message_id }
pub fn user_id(&self) -> i64 { self.user_id }
}
#[doc(hidden)]
pub struct RTDGetInlineGameHighScoresBuilder {
inner: GetInlineGameHighScores
}
impl RTDGetInlineGameHighScoresBuilder {
pub fn build(&self) -> GetInlineGameHighScores { self.inner.clone() }
pub fn inline_message_id<T: AsRef<str>>(&mut self, inline_message_id: T) -> &mut Self {
self.inner.inline_message_id = inline_message_id.as_ref().to_string();
self
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<GetInlineGameHighScores> for GetInlineGameHighScores {
fn as_ref(&self) -> &GetInlineGameHighScores { self }
}
impl AsRef<GetInlineGameHighScores> for RTDGetInlineGameHighScoresBuilder {
fn as_ref(&self) -> &GetInlineGameHighScores { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteChatReplyMarkup {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
}
impl RObject for DeleteChatReplyMarkup {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteChatReplyMarkup" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteChatReplyMarkup {}
impl DeleteChatReplyMarkup {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteChatReplyMarkupBuilder {
let mut inner = DeleteChatReplyMarkup::default();
inner.td_name = "deleteChatReplyMarkup".to_string();
RTDDeleteChatReplyMarkupBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
}
#[doc(hidden)]
pub struct RTDDeleteChatReplyMarkupBuilder {
inner: DeleteChatReplyMarkup
}
impl RTDDeleteChatReplyMarkupBuilder {
pub fn build(&self) -> DeleteChatReplyMarkup { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
}
impl AsRef<DeleteChatReplyMarkup> for DeleteChatReplyMarkup {
fn as_ref(&self) -> &DeleteChatReplyMarkup { self }
}
impl AsRef<DeleteChatReplyMarkup> for RTDDeleteChatReplyMarkupBuilder {
fn as_ref(&self) -> &DeleteChatReplyMarkup { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendChatAction {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
action: ChatAction,
}
impl RObject for SendChatAction {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendChatAction" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendChatAction {}
impl SendChatAction {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendChatActionBuilder {
let mut inner = SendChatAction::default();
inner.td_name = "sendChatAction".to_string();
RTDSendChatActionBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn action(&self) -> &ChatAction { &self.action }
}
#[doc(hidden)]
pub struct RTDSendChatActionBuilder {
inner: SendChatAction
}
impl RTDSendChatActionBuilder {
pub fn build(&self) -> SendChatAction { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn action<T: AsRef<ChatAction>>(&mut self, action: T) -> &mut Self {
self.inner.action = action.as_ref().clone();
self
}
}
impl AsRef<SendChatAction> for SendChatAction {
fn as_ref(&self) -> &SendChatAction { self }
}
impl AsRef<SendChatAction> for RTDSendChatActionBuilder {
fn as_ref(&self) -> &SendChatAction { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct OpenChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for OpenChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "openChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for OpenChat {}
impl OpenChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDOpenChatBuilder {
let mut inner = OpenChat::default();
inner.td_name = "openChat".to_string();
RTDOpenChatBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDOpenChatBuilder {
inner: OpenChat
}
impl RTDOpenChatBuilder {
pub fn build(&self) -> OpenChat { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<OpenChat> for OpenChat {
fn as_ref(&self) -> &OpenChat { self }
}
impl AsRef<OpenChat> for RTDOpenChatBuilder {
fn as_ref(&self) -> &OpenChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CloseChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for CloseChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "closeChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CloseChat {}
impl CloseChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCloseChatBuilder {
let mut inner = CloseChat::default();
inner.td_name = "closeChat".to_string();
RTDCloseChatBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDCloseChatBuilder {
inner: CloseChat
}
impl RTDCloseChatBuilder {
pub fn build(&self) -> CloseChat { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<CloseChat> for CloseChat {
fn as_ref(&self) -> &CloseChat { self }
}
impl AsRef<CloseChat> for RTDCloseChatBuilder {
fn as_ref(&self) -> &CloseChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ViewMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_ids: Vec<i64>,
force_read: bool,
}
impl RObject for ViewMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "viewMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ViewMessages {}
impl ViewMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDViewMessagesBuilder {
let mut inner = ViewMessages::default();
inner.td_name = "viewMessages".to_string();
RTDViewMessagesBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_ids(&self) -> &Vec<i64> { &self.message_ids }
pub fn force_read(&self) -> bool { self.force_read }
}
#[doc(hidden)]
pub struct RTDViewMessagesBuilder {
inner: ViewMessages
}
impl RTDViewMessagesBuilder {
pub fn build(&self) -> ViewMessages { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_ids(&mut self, message_ids: Vec<i64>) -> &mut Self {
self.inner.message_ids = message_ids;
self
}
pub fn force_read(&mut self, force_read: bool) -> &mut Self {
self.inner.force_read = force_read;
self
}
}
impl AsRef<ViewMessages> for ViewMessages {
fn as_ref(&self) -> &ViewMessages { self }
}
impl AsRef<ViewMessages> for RTDViewMessagesBuilder {
fn as_ref(&self) -> &ViewMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct OpenMessageContent {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
}
impl RObject for OpenMessageContent {
#[doc(hidden)] fn td_name(&self) -> &'static str { "openMessageContent" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for OpenMessageContent {}
impl OpenMessageContent {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDOpenMessageContentBuilder {
let mut inner = OpenMessageContent::default();
inner.td_name = "openMessageContent".to_string();
RTDOpenMessageContentBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
}
#[doc(hidden)]
pub struct RTDOpenMessageContentBuilder {
inner: OpenMessageContent
}
impl RTDOpenMessageContentBuilder {
pub fn build(&self) -> OpenMessageContent { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
}
impl AsRef<OpenMessageContent> for OpenMessageContent {
fn as_ref(&self) -> &OpenMessageContent { self }
}
impl AsRef<OpenMessageContent> for RTDOpenMessageContentBuilder {
fn as_ref(&self) -> &OpenMessageContent { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ReadAllChatMentions {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for ReadAllChatMentions {
#[doc(hidden)] fn td_name(&self) -> &'static str { "readAllChatMentions" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ReadAllChatMentions {}
impl ReadAllChatMentions {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDReadAllChatMentionsBuilder {
let mut inner = ReadAllChatMentions::default();
inner.td_name = "readAllChatMentions".to_string();
RTDReadAllChatMentionsBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDReadAllChatMentionsBuilder {
inner: ReadAllChatMentions
}
impl RTDReadAllChatMentionsBuilder {
pub fn build(&self) -> ReadAllChatMentions { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<ReadAllChatMentions> for ReadAllChatMentions {
fn as_ref(&self) -> &ReadAllChatMentions { self }
}
impl AsRef<ReadAllChatMentions> for RTDReadAllChatMentionsBuilder {
fn as_ref(&self) -> &ReadAllChatMentions { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreatePrivateChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
force: bool,
}
impl RObject for CreatePrivateChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createPrivateChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreatePrivateChat {}
impl CreatePrivateChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreatePrivateChatBuilder {
let mut inner = CreatePrivateChat::default();
inner.td_name = "createPrivateChat".to_string();
RTDCreatePrivateChatBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
pub fn force(&self) -> bool { self.force }
}
#[doc(hidden)]
pub struct RTDCreatePrivateChatBuilder {
inner: CreatePrivateChat
}
impl RTDCreatePrivateChatBuilder {
pub fn build(&self) -> CreatePrivateChat { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn force(&mut self, force: bool) -> &mut Self {
self.inner.force = force;
self
}
}
impl AsRef<CreatePrivateChat> for CreatePrivateChat {
fn as_ref(&self) -> &CreatePrivateChat { self }
}
impl AsRef<CreatePrivateChat> for RTDCreatePrivateChatBuilder {
fn as_ref(&self) -> &CreatePrivateChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateBasicGroupChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
basic_group_id: i64,
force: bool,
}
impl RObject for CreateBasicGroupChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createBasicGroupChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreateBasicGroupChat {}
impl CreateBasicGroupChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreateBasicGroupChatBuilder {
let mut inner = CreateBasicGroupChat::default();
inner.td_name = "createBasicGroupChat".to_string();
RTDCreateBasicGroupChatBuilder { inner }
}
pub fn basic_group_id(&self) -> i64 { self.basic_group_id }
pub fn force(&self) -> bool { self.force }
}
#[doc(hidden)]
pub struct RTDCreateBasicGroupChatBuilder {
inner: CreateBasicGroupChat
}
impl RTDCreateBasicGroupChatBuilder {
pub fn build(&self) -> CreateBasicGroupChat { self.inner.clone() }
pub fn basic_group_id(&mut self, basic_group_id: i64) -> &mut Self {
self.inner.basic_group_id = basic_group_id;
self
}
pub fn force(&mut self, force: bool) -> &mut Self {
self.inner.force = force;
self
}
}
impl AsRef<CreateBasicGroupChat> for CreateBasicGroupChat {
fn as_ref(&self) -> &CreateBasicGroupChat { self }
}
impl AsRef<CreateBasicGroupChat> for RTDCreateBasicGroupChatBuilder {
fn as_ref(&self) -> &CreateBasicGroupChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateSupergroupChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
force: bool,
}
impl RObject for CreateSupergroupChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createSupergroupChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreateSupergroupChat {}
impl CreateSupergroupChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreateSupergroupChatBuilder {
let mut inner = CreateSupergroupChat::default();
inner.td_name = "createSupergroupChat".to_string();
RTDCreateSupergroupChatBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn force(&self) -> bool { self.force }
}
#[doc(hidden)]
pub struct RTDCreateSupergroupChatBuilder {
inner: CreateSupergroupChat
}
impl RTDCreateSupergroupChatBuilder {
pub fn build(&self) -> CreateSupergroupChat { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn force(&mut self, force: bool) -> &mut Self {
self.inner.force = force;
self
}
}
impl AsRef<CreateSupergroupChat> for CreateSupergroupChat {
fn as_ref(&self) -> &CreateSupergroupChat { self }
}
impl AsRef<CreateSupergroupChat> for RTDCreateSupergroupChatBuilder {
fn as_ref(&self) -> &CreateSupergroupChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateSecretChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
secret_chat_id: i64,
}
impl RObject for CreateSecretChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createSecretChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreateSecretChat {}
impl CreateSecretChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreateSecretChatBuilder {
let mut inner = CreateSecretChat::default();
inner.td_name = "createSecretChat".to_string();
RTDCreateSecretChatBuilder { inner }
}
pub fn secret_chat_id(&self) -> i64 { self.secret_chat_id }
}
#[doc(hidden)]
pub struct RTDCreateSecretChatBuilder {
inner: CreateSecretChat
}
impl RTDCreateSecretChatBuilder {
pub fn build(&self) -> CreateSecretChat { self.inner.clone() }
pub fn secret_chat_id(&mut self, secret_chat_id: i64) -> &mut Self {
self.inner.secret_chat_id = secret_chat_id;
self
}
}
impl AsRef<CreateSecretChat> for CreateSecretChat {
fn as_ref(&self) -> &CreateSecretChat { self }
}
impl AsRef<CreateSecretChat> for RTDCreateSecretChatBuilder {
fn as_ref(&self) -> &CreateSecretChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateNewBasicGroupChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_ids: Vec<i64>,
title: String,
}
impl RObject for CreateNewBasicGroupChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createNewBasicGroupChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreateNewBasicGroupChat {}
impl CreateNewBasicGroupChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreateNewBasicGroupChatBuilder {
let mut inner = CreateNewBasicGroupChat::default();
inner.td_name = "createNewBasicGroupChat".to_string();
RTDCreateNewBasicGroupChatBuilder { inner }
}
pub fn user_ids(&self) -> &Vec<i64> { &self.user_ids }
pub fn title(&self) -> &String { &self.title }
}
#[doc(hidden)]
pub struct RTDCreateNewBasicGroupChatBuilder {
inner: CreateNewBasicGroupChat
}
impl RTDCreateNewBasicGroupChatBuilder {
pub fn build(&self) -> CreateNewBasicGroupChat { self.inner.clone() }
pub fn user_ids(&mut self, user_ids: Vec<i64>) -> &mut Self {
self.inner.user_ids = user_ids;
self
}
pub fn title<T: AsRef<str>>(&mut self, title: T) -> &mut Self {
self.inner.title = title.as_ref().to_string();
self
}
}
impl AsRef<CreateNewBasicGroupChat> for CreateNewBasicGroupChat {
fn as_ref(&self) -> &CreateNewBasicGroupChat { self }
}
impl AsRef<CreateNewBasicGroupChat> for RTDCreateNewBasicGroupChatBuilder {
fn as_ref(&self) -> &CreateNewBasicGroupChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateNewSupergroupChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
title: String,
is_channel: bool,
description: String,
}
impl RObject for CreateNewSupergroupChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createNewSupergroupChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreateNewSupergroupChat {}
impl CreateNewSupergroupChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreateNewSupergroupChatBuilder {
let mut inner = CreateNewSupergroupChat::default();
inner.td_name = "createNewSupergroupChat".to_string();
RTDCreateNewSupergroupChatBuilder { inner }
}
pub fn title(&self) -> &String { &self.title }
pub fn is_channel(&self) -> bool { self.is_channel }
pub fn description(&self) -> &String { &self.description }
}
#[doc(hidden)]
pub struct RTDCreateNewSupergroupChatBuilder {
inner: CreateNewSupergroupChat
}
impl RTDCreateNewSupergroupChatBuilder {
pub fn build(&self) -> CreateNewSupergroupChat { 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 is_channel(&mut self, is_channel: bool) -> &mut Self {
self.inner.is_channel = is_channel;
self
}
pub fn description<T: AsRef<str>>(&mut self, description: T) -> &mut Self {
self.inner.description = description.as_ref().to_string();
self
}
}
impl AsRef<CreateNewSupergroupChat> for CreateNewSupergroupChat {
fn as_ref(&self) -> &CreateNewSupergroupChat { self }
}
impl AsRef<CreateNewSupergroupChat> for RTDCreateNewSupergroupChatBuilder {
fn as_ref(&self) -> &CreateNewSupergroupChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateNewSecretChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
}
impl RObject for CreateNewSecretChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createNewSecretChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreateNewSecretChat {}
impl CreateNewSecretChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreateNewSecretChatBuilder {
let mut inner = CreateNewSecretChat::default();
inner.td_name = "createNewSecretChat".to_string();
RTDCreateNewSecretChatBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
}
#[doc(hidden)]
pub struct RTDCreateNewSecretChatBuilder {
inner: CreateNewSecretChat
}
impl RTDCreateNewSecretChatBuilder {
pub fn build(&self) -> CreateNewSecretChat { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<CreateNewSecretChat> for CreateNewSecretChat {
fn as_ref(&self) -> &CreateNewSecretChat { self }
}
impl AsRef<CreateNewSecretChat> for RTDCreateNewSecretChatBuilder {
fn as_ref(&self) -> &CreateNewSecretChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UpgradeBasicGroupChatToSupergroupChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for UpgradeBasicGroupChatToSupergroupChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "upgradeBasicGroupChatToSupergroupChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for UpgradeBasicGroupChatToSupergroupChat {}
impl UpgradeBasicGroupChatToSupergroupChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDUpgradeBasicGroupChatToSupergroupChatBuilder {
let mut inner = UpgradeBasicGroupChatToSupergroupChat::default();
inner.td_name = "upgradeBasicGroupChatToSupergroupChat".to_string();
RTDUpgradeBasicGroupChatToSupergroupChatBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDUpgradeBasicGroupChatToSupergroupChatBuilder {
inner: UpgradeBasicGroupChatToSupergroupChat
}
impl RTDUpgradeBasicGroupChatToSupergroupChatBuilder {
pub fn build(&self) -> UpgradeBasicGroupChatToSupergroupChat { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<UpgradeBasicGroupChatToSupergroupChat> for UpgradeBasicGroupChatToSupergroupChat {
fn as_ref(&self) -> &UpgradeBasicGroupChatToSupergroupChat { self }
}
impl AsRef<UpgradeBasicGroupChatToSupergroupChat> for RTDUpgradeBasicGroupChatToSupergroupChatBuilder {
fn as_ref(&self) -> &UpgradeBasicGroupChatToSupergroupChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetChatTitle {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
title: String,
}
impl RObject for SetChatTitle {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setChatTitle" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetChatTitle {}
impl SetChatTitle {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetChatTitleBuilder {
let mut inner = SetChatTitle::default();
inner.td_name = "setChatTitle".to_string();
RTDSetChatTitleBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn title(&self) -> &String { &self.title }
}
#[doc(hidden)]
pub struct RTDSetChatTitleBuilder {
inner: SetChatTitle
}
impl RTDSetChatTitleBuilder {
pub fn build(&self) -> SetChatTitle { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn title<T: AsRef<str>>(&mut self, title: T) -> &mut Self {
self.inner.title = title.as_ref().to_string();
self
}
}
impl AsRef<SetChatTitle> for SetChatTitle {
fn as_ref(&self) -> &SetChatTitle { self }
}
impl AsRef<SetChatTitle> for RTDSetChatTitleBuilder {
fn as_ref(&self) -> &SetChatTitle { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetChatPhoto {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
photo: InputFile,
}
impl RObject for SetChatPhoto {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setChatPhoto" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetChatPhoto {}
impl SetChatPhoto {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetChatPhotoBuilder {
let mut inner = SetChatPhoto::default();
inner.td_name = "setChatPhoto".to_string();
RTDSetChatPhotoBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn photo(&self) -> &InputFile { &self.photo }
}
#[doc(hidden)]
pub struct RTDSetChatPhotoBuilder {
inner: SetChatPhoto
}
impl RTDSetChatPhotoBuilder {
pub fn build(&self) -> SetChatPhoto { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn photo<T: AsRef<InputFile>>(&mut self, photo: T) -> &mut Self {
self.inner.photo = photo.as_ref().clone();
self
}
}
impl AsRef<SetChatPhoto> for SetChatPhoto {
fn as_ref(&self) -> &SetChatPhoto { self }
}
impl AsRef<SetChatPhoto> for RTDSetChatPhotoBuilder {
fn as_ref(&self) -> &SetChatPhoto { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetChatDraftMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
draft_message: Option<DraftMessage>,
}
impl RObject for SetChatDraftMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setChatDraftMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetChatDraftMessage {}
impl SetChatDraftMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetChatDraftMessageBuilder {
let mut inner = SetChatDraftMessage::default();
inner.td_name = "setChatDraftMessage".to_string();
RTDSetChatDraftMessageBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn draft_message(&self) -> &Option<DraftMessage> { &self.draft_message }
}
#[doc(hidden)]
pub struct RTDSetChatDraftMessageBuilder {
inner: SetChatDraftMessage
}
impl RTDSetChatDraftMessageBuilder {
pub fn build(&self) -> SetChatDraftMessage { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn draft_message<T: AsRef<DraftMessage>>(&mut self, draft_message: T) -> &mut Self {
self.inner.draft_message = Some(draft_message.as_ref().clone());
self
}
}
impl AsRef<SetChatDraftMessage> for SetChatDraftMessage {
fn as_ref(&self) -> &SetChatDraftMessage { self }
}
impl AsRef<SetChatDraftMessage> for RTDSetChatDraftMessageBuilder {
fn as_ref(&self) -> &SetChatDraftMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetChatNotificationSettings {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
notification_settings: ChatNotificationSettings,
}
impl RObject for SetChatNotificationSettings {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setChatNotificationSettings" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetChatNotificationSettings {}
impl SetChatNotificationSettings {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetChatNotificationSettingsBuilder {
let mut inner = SetChatNotificationSettings::default();
inner.td_name = "setChatNotificationSettings".to_string();
RTDSetChatNotificationSettingsBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn notification_settings(&self) -> &ChatNotificationSettings { &self.notification_settings }
}
#[doc(hidden)]
pub struct RTDSetChatNotificationSettingsBuilder {
inner: SetChatNotificationSettings
}
impl RTDSetChatNotificationSettingsBuilder {
pub fn build(&self) -> SetChatNotificationSettings { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn notification_settings<T: AsRef<ChatNotificationSettings>>(&mut self, notification_settings: T) -> &mut Self {
self.inner.notification_settings = notification_settings.as_ref().clone();
self
}
}
impl AsRef<SetChatNotificationSettings> for SetChatNotificationSettings {
fn as_ref(&self) -> &SetChatNotificationSettings { self }
}
impl AsRef<SetChatNotificationSettings> for RTDSetChatNotificationSettingsBuilder {
fn as_ref(&self) -> &SetChatNotificationSettings { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ToggleChatIsPinned {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
is_pinned: bool,
}
impl RObject for ToggleChatIsPinned {
#[doc(hidden)] fn td_name(&self) -> &'static str { "toggleChatIsPinned" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ToggleChatIsPinned {}
impl ToggleChatIsPinned {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDToggleChatIsPinnedBuilder {
let mut inner = ToggleChatIsPinned::default();
inner.td_name = "toggleChatIsPinned".to_string();
RTDToggleChatIsPinnedBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn is_pinned(&self) -> bool { self.is_pinned }
}
#[doc(hidden)]
pub struct RTDToggleChatIsPinnedBuilder {
inner: ToggleChatIsPinned
}
impl RTDToggleChatIsPinnedBuilder {
pub fn build(&self) -> ToggleChatIsPinned { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn is_pinned(&mut self, is_pinned: bool) -> &mut Self {
self.inner.is_pinned = is_pinned;
self
}
}
impl AsRef<ToggleChatIsPinned> for ToggleChatIsPinned {
fn as_ref(&self) -> &ToggleChatIsPinned { self }
}
impl AsRef<ToggleChatIsPinned> for RTDToggleChatIsPinnedBuilder {
fn as_ref(&self) -> &ToggleChatIsPinned { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ToggleChatIsMarkedAsUnread {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
is_marked_as_unread: bool,
}
impl RObject for ToggleChatIsMarkedAsUnread {
#[doc(hidden)] fn td_name(&self) -> &'static str { "toggleChatIsMarkedAsUnread" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ToggleChatIsMarkedAsUnread {}
impl ToggleChatIsMarkedAsUnread {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDToggleChatIsMarkedAsUnreadBuilder {
let mut inner = ToggleChatIsMarkedAsUnread::default();
inner.td_name = "toggleChatIsMarkedAsUnread".to_string();
RTDToggleChatIsMarkedAsUnreadBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn is_marked_as_unread(&self) -> bool { self.is_marked_as_unread }
}
#[doc(hidden)]
pub struct RTDToggleChatIsMarkedAsUnreadBuilder {
inner: ToggleChatIsMarkedAsUnread
}
impl RTDToggleChatIsMarkedAsUnreadBuilder {
pub fn build(&self) -> ToggleChatIsMarkedAsUnread { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn is_marked_as_unread(&mut self, is_marked_as_unread: bool) -> &mut Self {
self.inner.is_marked_as_unread = is_marked_as_unread;
self
}
}
impl AsRef<ToggleChatIsMarkedAsUnread> for ToggleChatIsMarkedAsUnread {
fn as_ref(&self) -> &ToggleChatIsMarkedAsUnread { self }
}
impl AsRef<ToggleChatIsMarkedAsUnread> for RTDToggleChatIsMarkedAsUnreadBuilder {
fn as_ref(&self) -> &ToggleChatIsMarkedAsUnread { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ToggleChatDefaultDisableNotification {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
default_disable_notification: bool,
}
impl RObject for ToggleChatDefaultDisableNotification {
#[doc(hidden)] fn td_name(&self) -> &'static str { "toggleChatDefaultDisableNotification" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ToggleChatDefaultDisableNotification {}
impl ToggleChatDefaultDisableNotification {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDToggleChatDefaultDisableNotificationBuilder {
let mut inner = ToggleChatDefaultDisableNotification::default();
inner.td_name = "toggleChatDefaultDisableNotification".to_string();
RTDToggleChatDefaultDisableNotificationBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn default_disable_notification(&self) -> bool { self.default_disable_notification }
}
#[doc(hidden)]
pub struct RTDToggleChatDefaultDisableNotificationBuilder {
inner: ToggleChatDefaultDisableNotification
}
impl RTDToggleChatDefaultDisableNotificationBuilder {
pub fn build(&self) -> ToggleChatDefaultDisableNotification { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn default_disable_notification(&mut self, default_disable_notification: bool) -> &mut Self {
self.inner.default_disable_notification = default_disable_notification;
self
}
}
impl AsRef<ToggleChatDefaultDisableNotification> for ToggleChatDefaultDisableNotification {
fn as_ref(&self) -> &ToggleChatDefaultDisableNotification { self }
}
impl AsRef<ToggleChatDefaultDisableNotification> for RTDToggleChatDefaultDisableNotificationBuilder {
fn as_ref(&self) -> &ToggleChatDefaultDisableNotification { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetChatClientData {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
client_data: String,
}
impl RObject for SetChatClientData {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setChatClientData" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetChatClientData {}
impl SetChatClientData {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetChatClientDataBuilder {
let mut inner = SetChatClientData::default();
inner.td_name = "setChatClientData".to_string();
RTDSetChatClientDataBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn client_data(&self) -> &String { &self.client_data }
}
#[doc(hidden)]
pub struct RTDSetChatClientDataBuilder {
inner: SetChatClientData
}
impl RTDSetChatClientDataBuilder {
pub fn build(&self) -> SetChatClientData { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn client_data<T: AsRef<str>>(&mut self, client_data: T) -> &mut Self {
self.inner.client_data = client_data.as_ref().to_string();
self
}
}
impl AsRef<SetChatClientData> for SetChatClientData {
fn as_ref(&self) -> &SetChatClientData { self }
}
impl AsRef<SetChatClientData> for RTDSetChatClientDataBuilder {
fn as_ref(&self) -> &SetChatClientData { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct JoinChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for JoinChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "joinChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for JoinChat {}
impl JoinChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDJoinChatBuilder {
let mut inner = JoinChat::default();
inner.td_name = "joinChat".to_string();
RTDJoinChatBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDJoinChatBuilder {
inner: JoinChat
}
impl RTDJoinChatBuilder {
pub fn build(&self) -> JoinChat { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<JoinChat> for JoinChat {
fn as_ref(&self) -> &JoinChat { self }
}
impl AsRef<JoinChat> for RTDJoinChatBuilder {
fn as_ref(&self) -> &JoinChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct LeaveChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for LeaveChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "leaveChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for LeaveChat {}
impl LeaveChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDLeaveChatBuilder {
let mut inner = LeaveChat::default();
inner.td_name = "leaveChat".to_string();
RTDLeaveChatBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDLeaveChatBuilder {
inner: LeaveChat
}
impl RTDLeaveChatBuilder {
pub fn build(&self) -> LeaveChat { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<LeaveChat> for LeaveChat {
fn as_ref(&self) -> &LeaveChat { self }
}
impl AsRef<LeaveChat> for RTDLeaveChatBuilder {
fn as_ref(&self) -> &LeaveChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddChatMember {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
user_id: i64,
forward_limit: i64,
}
impl RObject for AddChatMember {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addChatMember" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddChatMember {}
impl AddChatMember {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddChatMemberBuilder {
let mut inner = AddChatMember::default();
inner.td_name = "addChatMember".to_string();
RTDAddChatMemberBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn user_id(&self) -> i64 { self.user_id }
pub fn forward_limit(&self) -> i64 { self.forward_limit }
}
#[doc(hidden)]
pub struct RTDAddChatMemberBuilder {
inner: AddChatMember
}
impl RTDAddChatMemberBuilder {
pub fn build(&self) -> AddChatMember { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn forward_limit(&mut self, forward_limit: i64) -> &mut Self {
self.inner.forward_limit = forward_limit;
self
}
}
impl AsRef<AddChatMember> for AddChatMember {
fn as_ref(&self) -> &AddChatMember { self }
}
impl AsRef<AddChatMember> for RTDAddChatMemberBuilder {
fn as_ref(&self) -> &AddChatMember { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddChatMembers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
user_ids: Vec<i64>,
}
impl RObject for AddChatMembers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addChatMembers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddChatMembers {}
impl AddChatMembers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddChatMembersBuilder {
let mut inner = AddChatMembers::default();
inner.td_name = "addChatMembers".to_string();
RTDAddChatMembersBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn user_ids(&self) -> &Vec<i64> { &self.user_ids }
}
#[doc(hidden)]
pub struct RTDAddChatMembersBuilder {
inner: AddChatMembers
}
impl RTDAddChatMembersBuilder {
pub fn build(&self) -> AddChatMembers { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn user_ids(&mut self, user_ids: Vec<i64>) -> &mut Self {
self.inner.user_ids = user_ids;
self
}
}
impl AsRef<AddChatMembers> for AddChatMembers {
fn as_ref(&self) -> &AddChatMembers { self }
}
impl AsRef<AddChatMembers> for RTDAddChatMembersBuilder {
fn as_ref(&self) -> &AddChatMembers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetChatMemberStatus {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
user_id: i64,
status: ChatMemberStatus,
}
impl RObject for SetChatMemberStatus {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setChatMemberStatus" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetChatMemberStatus {}
impl SetChatMemberStatus {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetChatMemberStatusBuilder {
let mut inner = SetChatMemberStatus::default();
inner.td_name = "setChatMemberStatus".to_string();
RTDSetChatMemberStatusBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn user_id(&self) -> i64 { self.user_id }
pub fn status(&self) -> &ChatMemberStatus { &self.status }
}
#[doc(hidden)]
pub struct RTDSetChatMemberStatusBuilder {
inner: SetChatMemberStatus
}
impl RTDSetChatMemberStatusBuilder {
pub fn build(&self) -> SetChatMemberStatus { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn status<T: AsRef<ChatMemberStatus>>(&mut self, status: T) -> &mut Self {
self.inner.status = status.as_ref().clone();
self
}
}
impl AsRef<SetChatMemberStatus> for SetChatMemberStatus {
fn as_ref(&self) -> &SetChatMemberStatus { self }
}
impl AsRef<SetChatMemberStatus> for RTDSetChatMemberStatusBuilder {
fn as_ref(&self) -> &SetChatMemberStatus { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChatMember {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
user_id: i64,
}
impl RObject for GetChatMember {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChatMember" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChatMember {}
impl GetChatMember {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatMemberBuilder {
let mut inner = GetChatMember::default();
inner.td_name = "getChatMember".to_string();
RTDGetChatMemberBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn user_id(&self) -> i64 { self.user_id }
}
#[doc(hidden)]
pub struct RTDGetChatMemberBuilder {
inner: GetChatMember
}
impl RTDGetChatMemberBuilder {
pub fn build(&self) -> GetChatMember { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<GetChatMember> for GetChatMember {
fn as_ref(&self) -> &GetChatMember { self }
}
impl AsRef<GetChatMember> for RTDGetChatMemberBuilder {
fn as_ref(&self) -> &GetChatMember { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchChatMembers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
query: String,
limit: i64,
filter: ChatMembersFilter,
}
impl RObject for SearchChatMembers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchChatMembers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchChatMembers {}
impl SearchChatMembers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchChatMembersBuilder {
let mut inner = SearchChatMembers::default();
inner.td_name = "searchChatMembers".to_string();
RTDSearchChatMembersBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn query(&self) -> &String { &self.query }
pub fn limit(&self) -> i64 { self.limit }
pub fn filter(&self) -> &ChatMembersFilter { &self.filter }
}
#[doc(hidden)]
pub struct RTDSearchChatMembersBuilder {
inner: SearchChatMembers
}
impl RTDSearchChatMembersBuilder {
pub fn build(&self) -> SearchChatMembers { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
pub fn filter<T: AsRef<ChatMembersFilter>>(&mut self, filter: T) -> &mut Self {
self.inner.filter = filter.as_ref().clone();
self
}
}
impl AsRef<SearchChatMembers> for SearchChatMembers {
fn as_ref(&self) -> &SearchChatMembers { self }
}
impl AsRef<SearchChatMembers> for RTDSearchChatMembersBuilder {
fn as_ref(&self) -> &SearchChatMembers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChatAdministrators {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for GetChatAdministrators {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChatAdministrators" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChatAdministrators {}
impl GetChatAdministrators {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatAdministratorsBuilder {
let mut inner = GetChatAdministrators::default();
inner.td_name = "getChatAdministrators".to_string();
RTDGetChatAdministratorsBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDGetChatAdministratorsBuilder {
inner: GetChatAdministrators
}
impl RTDGetChatAdministratorsBuilder {
pub fn build(&self) -> GetChatAdministrators { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<GetChatAdministrators> for GetChatAdministrators {
fn as_ref(&self) -> &GetChatAdministrators { self }
}
impl AsRef<GetChatAdministrators> for RTDGetChatAdministratorsBuilder {
fn as_ref(&self) -> &GetChatAdministrators { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ClearAllDraftMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
exclude_secret_chats: bool,
}
impl RObject for ClearAllDraftMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "clearAllDraftMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ClearAllDraftMessages {}
impl ClearAllDraftMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDClearAllDraftMessagesBuilder {
let mut inner = ClearAllDraftMessages::default();
inner.td_name = "clearAllDraftMessages".to_string();
RTDClearAllDraftMessagesBuilder { inner }
}
pub fn exclude_secret_chats(&self) -> bool { self.exclude_secret_chats }
}
#[doc(hidden)]
pub struct RTDClearAllDraftMessagesBuilder {
inner: ClearAllDraftMessages
}
impl RTDClearAllDraftMessagesBuilder {
pub fn build(&self) -> ClearAllDraftMessages { self.inner.clone() }
pub fn exclude_secret_chats(&mut self, exclude_secret_chats: bool) -> &mut Self {
self.inner.exclude_secret_chats = exclude_secret_chats;
self
}
}
impl AsRef<ClearAllDraftMessages> for ClearAllDraftMessages {
fn as_ref(&self) -> &ClearAllDraftMessages { self }
}
impl AsRef<ClearAllDraftMessages> for RTDClearAllDraftMessagesBuilder {
fn as_ref(&self) -> &ClearAllDraftMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetScopeNotificationSettings {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
scope: NotificationSettingsScope,
}
impl RObject for GetScopeNotificationSettings {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getScopeNotificationSettings" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetScopeNotificationSettings {}
impl GetScopeNotificationSettings {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetScopeNotificationSettingsBuilder {
let mut inner = GetScopeNotificationSettings::default();
inner.td_name = "getScopeNotificationSettings".to_string();
RTDGetScopeNotificationSettingsBuilder { inner }
}
pub fn scope(&self) -> &NotificationSettingsScope { &self.scope }
}
#[doc(hidden)]
pub struct RTDGetScopeNotificationSettingsBuilder {
inner: GetScopeNotificationSettings
}
impl RTDGetScopeNotificationSettingsBuilder {
pub fn build(&self) -> GetScopeNotificationSettings { self.inner.clone() }
pub fn scope<T: AsRef<NotificationSettingsScope>>(&mut self, scope: T) -> &mut Self {
self.inner.scope = scope.as_ref().clone();
self
}
}
impl AsRef<GetScopeNotificationSettings> for GetScopeNotificationSettings {
fn as_ref(&self) -> &GetScopeNotificationSettings { self }
}
impl AsRef<GetScopeNotificationSettings> for RTDGetScopeNotificationSettingsBuilder {
fn as_ref(&self) -> &GetScopeNotificationSettings { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetScopeNotificationSettings {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
scope: NotificationSettingsScope,
notification_settings: ScopeNotificationSettings,
}
impl RObject for SetScopeNotificationSettings {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setScopeNotificationSettings" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetScopeNotificationSettings {}
impl SetScopeNotificationSettings {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetScopeNotificationSettingsBuilder {
let mut inner = SetScopeNotificationSettings::default();
inner.td_name = "setScopeNotificationSettings".to_string();
RTDSetScopeNotificationSettingsBuilder { inner }
}
pub fn scope(&self) -> &NotificationSettingsScope { &self.scope }
pub fn notification_settings(&self) -> &ScopeNotificationSettings { &self.notification_settings }
}
#[doc(hidden)]
pub struct RTDSetScopeNotificationSettingsBuilder {
inner: SetScopeNotificationSettings
}
impl RTDSetScopeNotificationSettingsBuilder {
pub fn build(&self) -> SetScopeNotificationSettings { self.inner.clone() }
pub fn scope<T: AsRef<NotificationSettingsScope>>(&mut self, scope: T) -> &mut Self {
self.inner.scope = scope.as_ref().clone();
self
}
pub fn notification_settings<T: AsRef<ScopeNotificationSettings>>(&mut self, notification_settings: T) -> &mut Self {
self.inner.notification_settings = notification_settings.as_ref().clone();
self
}
}
impl AsRef<SetScopeNotificationSettings> for SetScopeNotificationSettings {
fn as_ref(&self) -> &SetScopeNotificationSettings { self }
}
impl AsRef<SetScopeNotificationSettings> for RTDSetScopeNotificationSettingsBuilder {
fn as_ref(&self) -> &SetScopeNotificationSettings { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ResetAllNotificationSettings {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for ResetAllNotificationSettings {
#[doc(hidden)] fn td_name(&self) -> &'static str { "resetAllNotificationSettings" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ResetAllNotificationSettings {}
impl ResetAllNotificationSettings {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDResetAllNotificationSettingsBuilder {
let mut inner = ResetAllNotificationSettings::default();
inner.td_name = "resetAllNotificationSettings".to_string();
RTDResetAllNotificationSettingsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDResetAllNotificationSettingsBuilder {
inner: ResetAllNotificationSettings
}
impl RTDResetAllNotificationSettingsBuilder {
pub fn build(&self) -> ResetAllNotificationSettings { self.inner.clone() }
}
impl AsRef<ResetAllNotificationSettings> for ResetAllNotificationSettings {
fn as_ref(&self) -> &ResetAllNotificationSettings { self }
}
impl AsRef<ResetAllNotificationSettings> for RTDResetAllNotificationSettingsBuilder {
fn as_ref(&self) -> &ResetAllNotificationSettings { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetPinnedChats {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_ids: Vec<i64>,
}
impl RObject for SetPinnedChats {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setPinnedChats" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetPinnedChats {}
impl SetPinnedChats {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetPinnedChatsBuilder {
let mut inner = SetPinnedChats::default();
inner.td_name = "setPinnedChats".to_string();
RTDSetPinnedChatsBuilder { inner }
}
pub fn chat_ids(&self) -> &Vec<i64> { &self.chat_ids }
}
#[doc(hidden)]
pub struct RTDSetPinnedChatsBuilder {
inner: SetPinnedChats
}
impl RTDSetPinnedChatsBuilder {
pub fn build(&self) -> SetPinnedChats { self.inner.clone() }
pub fn chat_ids(&mut self, chat_ids: Vec<i64>) -> &mut Self {
self.inner.chat_ids = chat_ids;
self
}
}
impl AsRef<SetPinnedChats> for SetPinnedChats {
fn as_ref(&self) -> &SetPinnedChats { self }
}
impl AsRef<SetPinnedChats> for RTDSetPinnedChatsBuilder {
fn as_ref(&self) -> &SetPinnedChats { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DownloadFile {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
file_id: i64,
priority: i64,
}
impl RObject for DownloadFile {
#[doc(hidden)] fn td_name(&self) -> &'static str { "downloadFile" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DownloadFile {}
impl DownloadFile {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDownloadFileBuilder {
let mut inner = DownloadFile::default();
inner.td_name = "downloadFile".to_string();
RTDDownloadFileBuilder { inner }
}
pub fn file_id(&self) -> i64 { self.file_id }
pub fn priority(&self) -> i64 { self.priority }
}
#[doc(hidden)]
pub struct RTDDownloadFileBuilder {
inner: DownloadFile
}
impl RTDDownloadFileBuilder {
pub fn build(&self) -> DownloadFile { self.inner.clone() }
pub fn file_id(&mut self, file_id: i64) -> &mut Self {
self.inner.file_id = file_id;
self
}
pub fn priority(&mut self, priority: i64) -> &mut Self {
self.inner.priority = priority;
self
}
}
impl AsRef<DownloadFile> for DownloadFile {
fn as_ref(&self) -> &DownloadFile { self }
}
impl AsRef<DownloadFile> for RTDDownloadFileBuilder {
fn as_ref(&self) -> &DownloadFile { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CancelDownloadFile {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
file_id: i64,
only_if_pending: bool,
}
impl RObject for CancelDownloadFile {
#[doc(hidden)] fn td_name(&self) -> &'static str { "cancelDownloadFile" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CancelDownloadFile {}
impl CancelDownloadFile {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCancelDownloadFileBuilder {
let mut inner = CancelDownloadFile::default();
inner.td_name = "cancelDownloadFile".to_string();
RTDCancelDownloadFileBuilder { inner }
}
pub fn file_id(&self) -> i64 { self.file_id }
pub fn only_if_pending(&self) -> bool { self.only_if_pending }
}
#[doc(hidden)]
pub struct RTDCancelDownloadFileBuilder {
inner: CancelDownloadFile
}
impl RTDCancelDownloadFileBuilder {
pub fn build(&self) -> CancelDownloadFile { self.inner.clone() }
pub fn file_id(&mut self, file_id: i64) -> &mut Self {
self.inner.file_id = file_id;
self
}
pub fn only_if_pending(&mut self, only_if_pending: bool) -> &mut Self {
self.inner.only_if_pending = only_if_pending;
self
}
}
impl AsRef<CancelDownloadFile> for CancelDownloadFile {
fn as_ref(&self) -> &CancelDownloadFile { self }
}
impl AsRef<CancelDownloadFile> for RTDCancelDownloadFileBuilder {
fn as_ref(&self) -> &CancelDownloadFile { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UploadFile {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
file: InputFile,
file_type: FileType,
priority: i64,
}
impl RObject for UploadFile {
#[doc(hidden)] fn td_name(&self) -> &'static str { "uploadFile" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for UploadFile {}
impl UploadFile {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDUploadFileBuilder {
let mut inner = UploadFile::default();
inner.td_name = "uploadFile".to_string();
RTDUploadFileBuilder { inner }
}
pub fn file(&self) -> &InputFile { &self.file }
pub fn file_type(&self) -> &FileType { &self.file_type }
pub fn priority(&self) -> i64 { self.priority }
}
#[doc(hidden)]
pub struct RTDUploadFileBuilder {
inner: UploadFile
}
impl RTDUploadFileBuilder {
pub fn build(&self) -> UploadFile { self.inner.clone() }
pub fn file<T: AsRef<InputFile>>(&mut self, file: T) -> &mut Self {
self.inner.file = file.as_ref().clone();
self
}
pub fn file_type<T: AsRef<FileType>>(&mut self, file_type: T) -> &mut Self {
self.inner.file_type = file_type.as_ref().clone();
self
}
pub fn priority(&mut self, priority: i64) -> &mut Self {
self.inner.priority = priority;
self
}
}
impl AsRef<UploadFile> for UploadFile {
fn as_ref(&self) -> &UploadFile { self }
}
impl AsRef<UploadFile> for RTDUploadFileBuilder {
fn as_ref(&self) -> &UploadFile { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CancelUploadFile {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
file_id: i64,
}
impl RObject for CancelUploadFile {
#[doc(hidden)] fn td_name(&self) -> &'static str { "cancelUploadFile" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CancelUploadFile {}
impl CancelUploadFile {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCancelUploadFileBuilder {
let mut inner = CancelUploadFile::default();
inner.td_name = "cancelUploadFile".to_string();
RTDCancelUploadFileBuilder { inner }
}
pub fn file_id(&self) -> i64 { self.file_id }
}
#[doc(hidden)]
pub struct RTDCancelUploadFileBuilder {
inner: CancelUploadFile
}
impl RTDCancelUploadFileBuilder {
pub fn build(&self) -> CancelUploadFile { self.inner.clone() }
pub fn file_id(&mut self, file_id: i64) -> &mut Self {
self.inner.file_id = file_id;
self
}
}
impl AsRef<CancelUploadFile> for CancelUploadFile {
fn as_ref(&self) -> &CancelUploadFile { self }
}
impl AsRef<CancelUploadFile> for RTDCancelUploadFileBuilder {
fn as_ref(&self) -> &CancelUploadFile { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetFileGenerationProgress {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
generation_id: isize,
expected_size: i64,
local_prefix_size: i64,
}
impl RObject for SetFileGenerationProgress {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setFileGenerationProgress" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetFileGenerationProgress {}
impl SetFileGenerationProgress {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetFileGenerationProgressBuilder {
let mut inner = SetFileGenerationProgress::default();
inner.td_name = "setFileGenerationProgress".to_string();
RTDSetFileGenerationProgressBuilder { inner }
}
pub fn generation_id(&self) -> isize { self.generation_id }
pub fn expected_size(&self) -> i64 { self.expected_size }
pub fn local_prefix_size(&self) -> i64 { self.local_prefix_size }
}
#[doc(hidden)]
pub struct RTDSetFileGenerationProgressBuilder {
inner: SetFileGenerationProgress
}
impl RTDSetFileGenerationProgressBuilder {
pub fn build(&self) -> SetFileGenerationProgress { self.inner.clone() }
pub fn generation_id(&mut self, generation_id: isize) -> &mut Self {
self.inner.generation_id = generation_id;
self
}
pub fn expected_size(&mut self, expected_size: i64) -> &mut Self {
self.inner.expected_size = expected_size;
self
}
pub fn local_prefix_size(&mut self, local_prefix_size: i64) -> &mut Self {
self.inner.local_prefix_size = local_prefix_size;
self
}
}
impl AsRef<SetFileGenerationProgress> for SetFileGenerationProgress {
fn as_ref(&self) -> &SetFileGenerationProgress { self }
}
impl AsRef<SetFileGenerationProgress> for RTDSetFileGenerationProgressBuilder {
fn as_ref(&self) -> &SetFileGenerationProgress { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct FinishFileGeneration {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
generation_id: isize,
error: Error,
}
impl RObject for FinishFileGeneration {
#[doc(hidden)] fn td_name(&self) -> &'static str { "finishFileGeneration" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for FinishFileGeneration {}
impl FinishFileGeneration {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDFinishFileGenerationBuilder {
let mut inner = FinishFileGeneration::default();
inner.td_name = "finishFileGeneration".to_string();
RTDFinishFileGenerationBuilder { inner }
}
pub fn generation_id(&self) -> isize { self.generation_id }
pub fn error(&self) -> &Error { &self.error }
}
#[doc(hidden)]
pub struct RTDFinishFileGenerationBuilder {
inner: FinishFileGeneration
}
impl RTDFinishFileGenerationBuilder {
pub fn build(&self) -> FinishFileGeneration { self.inner.clone() }
pub fn generation_id(&mut self, generation_id: isize) -> &mut Self {
self.inner.generation_id = generation_id;
self
}
pub fn error<T: AsRef<Error>>(&mut self, error: T) -> &mut Self {
self.inner.error = error.as_ref().clone();
self
}
}
impl AsRef<FinishFileGeneration> for FinishFileGeneration {
fn as_ref(&self) -> &FinishFileGeneration { self }
}
impl AsRef<FinishFileGeneration> for RTDFinishFileGenerationBuilder {
fn as_ref(&self) -> &FinishFileGeneration { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteFile {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
file_id: i64,
}
impl RObject for DeleteFile {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteFile" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteFile {}
impl DeleteFile {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteFileBuilder {
let mut inner = DeleteFile::default();
inner.td_name = "deleteFile".to_string();
RTDDeleteFileBuilder { inner }
}
pub fn file_id(&self) -> i64 { self.file_id }
}
#[doc(hidden)]
pub struct RTDDeleteFileBuilder {
inner: DeleteFile
}
impl RTDDeleteFileBuilder {
pub fn build(&self) -> DeleteFile { self.inner.clone() }
pub fn file_id(&mut self, file_id: i64) -> &mut Self {
self.inner.file_id = file_id;
self
}
}
impl AsRef<DeleteFile> for DeleteFile {
fn as_ref(&self) -> &DeleteFile { self }
}
impl AsRef<DeleteFile> for RTDDeleteFileBuilder {
fn as_ref(&self) -> &DeleteFile { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GenerateChatInviteLink {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for GenerateChatInviteLink {
#[doc(hidden)] fn td_name(&self) -> &'static str { "generateChatInviteLink" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GenerateChatInviteLink {}
impl GenerateChatInviteLink {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGenerateChatInviteLinkBuilder {
let mut inner = GenerateChatInviteLink::default();
inner.td_name = "generateChatInviteLink".to_string();
RTDGenerateChatInviteLinkBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDGenerateChatInviteLinkBuilder {
inner: GenerateChatInviteLink
}
impl RTDGenerateChatInviteLinkBuilder {
pub fn build(&self) -> GenerateChatInviteLink { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<GenerateChatInviteLink> for GenerateChatInviteLink {
fn as_ref(&self) -> &GenerateChatInviteLink { self }
}
impl AsRef<GenerateChatInviteLink> for RTDGenerateChatInviteLinkBuilder {
fn as_ref(&self) -> &GenerateChatInviteLink { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckChatInviteLink {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
invite_link: String,
}
impl RObject for CheckChatInviteLink {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkChatInviteLink" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CheckChatInviteLink {}
impl CheckChatInviteLink {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckChatInviteLinkBuilder {
let mut inner = CheckChatInviteLink::default();
inner.td_name = "checkChatInviteLink".to_string();
RTDCheckChatInviteLinkBuilder { inner }
}
pub fn invite_link(&self) -> &String { &self.invite_link }
}
#[doc(hidden)]
pub struct RTDCheckChatInviteLinkBuilder {
inner: CheckChatInviteLink
}
impl RTDCheckChatInviteLinkBuilder {
pub fn build(&self) -> CheckChatInviteLink { self.inner.clone() }
pub fn invite_link<T: AsRef<str>>(&mut self, invite_link: T) -> &mut Self {
self.inner.invite_link = invite_link.as_ref().to_string();
self
}
}
impl AsRef<CheckChatInviteLink> for CheckChatInviteLink {
fn as_ref(&self) -> &CheckChatInviteLink { self }
}
impl AsRef<CheckChatInviteLink> for RTDCheckChatInviteLinkBuilder {
fn as_ref(&self) -> &CheckChatInviteLink { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct JoinChatByInviteLink {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
invite_link: String,
}
impl RObject for JoinChatByInviteLink {
#[doc(hidden)] fn td_name(&self) -> &'static str { "joinChatByInviteLink" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for JoinChatByInviteLink {}
impl JoinChatByInviteLink {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDJoinChatByInviteLinkBuilder {
let mut inner = JoinChatByInviteLink::default();
inner.td_name = "joinChatByInviteLink".to_string();
RTDJoinChatByInviteLinkBuilder { inner }
}
pub fn invite_link(&self) -> &String { &self.invite_link }
}
#[doc(hidden)]
pub struct RTDJoinChatByInviteLinkBuilder {
inner: JoinChatByInviteLink
}
impl RTDJoinChatByInviteLinkBuilder {
pub fn build(&self) -> JoinChatByInviteLink { self.inner.clone() }
pub fn invite_link<T: AsRef<str>>(&mut self, invite_link: T) -> &mut Self {
self.inner.invite_link = invite_link.as_ref().to_string();
self
}
}
impl AsRef<JoinChatByInviteLink> for JoinChatByInviteLink {
fn as_ref(&self) -> &JoinChatByInviteLink { self }
}
impl AsRef<JoinChatByInviteLink> for RTDJoinChatByInviteLinkBuilder {
fn as_ref(&self) -> &JoinChatByInviteLink { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateCall {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
protocol: CallProtocol,
}
impl RObject for CreateCall {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createCall" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreateCall {}
impl CreateCall {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreateCallBuilder {
let mut inner = CreateCall::default();
inner.td_name = "createCall".to_string();
RTDCreateCallBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
pub fn protocol(&self) -> &CallProtocol { &self.protocol }
}
#[doc(hidden)]
pub struct RTDCreateCallBuilder {
inner: CreateCall
}
impl RTDCreateCallBuilder {
pub fn build(&self) -> CreateCall { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn protocol<T: AsRef<CallProtocol>>(&mut self, protocol: T) -> &mut Self {
self.inner.protocol = protocol.as_ref().clone();
self
}
}
impl AsRef<CreateCall> for CreateCall {
fn as_ref(&self) -> &CreateCall { self }
}
impl AsRef<CreateCall> for RTDCreateCallBuilder {
fn as_ref(&self) -> &CreateCall { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AcceptCall {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
call_id: i64,
protocol: CallProtocol,
}
impl RObject for AcceptCall {
#[doc(hidden)] fn td_name(&self) -> &'static str { "acceptCall" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AcceptCall {}
impl AcceptCall {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAcceptCallBuilder {
let mut inner = AcceptCall::default();
inner.td_name = "acceptCall".to_string();
RTDAcceptCallBuilder { inner }
}
pub fn call_id(&self) -> i64 { self.call_id }
pub fn protocol(&self) -> &CallProtocol { &self.protocol }
}
#[doc(hidden)]
pub struct RTDAcceptCallBuilder {
inner: AcceptCall
}
impl RTDAcceptCallBuilder {
pub fn build(&self) -> AcceptCall { self.inner.clone() }
pub fn call_id(&mut self, call_id: i64) -> &mut Self {
self.inner.call_id = call_id;
self
}
pub fn protocol<T: AsRef<CallProtocol>>(&mut self, protocol: T) -> &mut Self {
self.inner.protocol = protocol.as_ref().clone();
self
}
}
impl AsRef<AcceptCall> for AcceptCall {
fn as_ref(&self) -> &AcceptCall { self }
}
impl AsRef<AcceptCall> for RTDAcceptCallBuilder {
fn as_ref(&self) -> &AcceptCall { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DiscardCall {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
call_id: i64,
is_disconnected: bool,
duration: i64,
connection_id: isize,
}
impl RObject for DiscardCall {
#[doc(hidden)] fn td_name(&self) -> &'static str { "discardCall" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DiscardCall {}
impl DiscardCall {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDiscardCallBuilder {
let mut inner = DiscardCall::default();
inner.td_name = "discardCall".to_string();
RTDDiscardCallBuilder { inner }
}
pub fn call_id(&self) -> i64 { self.call_id }
pub fn is_disconnected(&self) -> bool { self.is_disconnected }
pub fn duration(&self) -> i64 { self.duration }
pub fn connection_id(&self) -> isize { self.connection_id }
}
#[doc(hidden)]
pub struct RTDDiscardCallBuilder {
inner: DiscardCall
}
impl RTDDiscardCallBuilder {
pub fn build(&self) -> DiscardCall { self.inner.clone() }
pub fn call_id(&mut self, call_id: i64) -> &mut Self {
self.inner.call_id = call_id;
self
}
pub fn is_disconnected(&mut self, is_disconnected: bool) -> &mut Self {
self.inner.is_disconnected = is_disconnected;
self
}
pub fn duration(&mut self, duration: i64) -> &mut Self {
self.inner.duration = duration;
self
}
pub fn connection_id(&mut self, connection_id: isize) -> &mut Self {
self.inner.connection_id = connection_id;
self
}
}
impl AsRef<DiscardCall> for DiscardCall {
fn as_ref(&self) -> &DiscardCall { self }
}
impl AsRef<DiscardCall> for RTDDiscardCallBuilder {
fn as_ref(&self) -> &DiscardCall { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendCallRating {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
call_id: i64,
rating: i64,
comment: String,
}
impl RObject for SendCallRating {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendCallRating" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendCallRating {}
impl SendCallRating {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendCallRatingBuilder {
let mut inner = SendCallRating::default();
inner.td_name = "sendCallRating".to_string();
RTDSendCallRatingBuilder { inner }
}
pub fn call_id(&self) -> i64 { self.call_id }
pub fn rating(&self) -> i64 { self.rating }
pub fn comment(&self) -> &String { &self.comment }
}
#[doc(hidden)]
pub struct RTDSendCallRatingBuilder {
inner: SendCallRating
}
impl RTDSendCallRatingBuilder {
pub fn build(&self) -> SendCallRating { self.inner.clone() }
pub fn call_id(&mut self, call_id: i64) -> &mut Self {
self.inner.call_id = call_id;
self
}
pub fn rating(&mut self, rating: i64) -> &mut Self {
self.inner.rating = rating;
self
}
pub fn comment<T: AsRef<str>>(&mut self, comment: T) -> &mut Self {
self.inner.comment = comment.as_ref().to_string();
self
}
}
impl AsRef<SendCallRating> for SendCallRating {
fn as_ref(&self) -> &SendCallRating { self }
}
impl AsRef<SendCallRating> for RTDSendCallRatingBuilder {
fn as_ref(&self) -> &SendCallRating { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendCallDebugInformation {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
call_id: i64,
debug_information: String,
}
impl RObject for SendCallDebugInformation {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendCallDebugInformation" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendCallDebugInformation {}
impl SendCallDebugInformation {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendCallDebugInformationBuilder {
let mut inner = SendCallDebugInformation::default();
inner.td_name = "sendCallDebugInformation".to_string();
RTDSendCallDebugInformationBuilder { inner }
}
pub fn call_id(&self) -> i64 { self.call_id }
pub fn debug_information(&self) -> &String { &self.debug_information }
}
#[doc(hidden)]
pub struct RTDSendCallDebugInformationBuilder {
inner: SendCallDebugInformation
}
impl RTDSendCallDebugInformationBuilder {
pub fn build(&self) -> SendCallDebugInformation { self.inner.clone() }
pub fn call_id(&mut self, call_id: i64) -> &mut Self {
self.inner.call_id = call_id;
self
}
pub fn debug_information<T: AsRef<str>>(&mut self, debug_information: T) -> &mut Self {
self.inner.debug_information = debug_information.as_ref().to_string();
self
}
}
impl AsRef<SendCallDebugInformation> for SendCallDebugInformation {
fn as_ref(&self) -> &SendCallDebugInformation { self }
}
impl AsRef<SendCallDebugInformation> for RTDSendCallDebugInformationBuilder {
fn as_ref(&self) -> &SendCallDebugInformation { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct BlockUser {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
}
impl RObject for BlockUser {
#[doc(hidden)] fn td_name(&self) -> &'static str { "blockUser" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for BlockUser {}
impl BlockUser {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDBlockUserBuilder {
let mut inner = BlockUser::default();
inner.td_name = "blockUser".to_string();
RTDBlockUserBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
}
#[doc(hidden)]
pub struct RTDBlockUserBuilder {
inner: BlockUser
}
impl RTDBlockUserBuilder {
pub fn build(&self) -> BlockUser { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<BlockUser> for BlockUser {
fn as_ref(&self) -> &BlockUser { self }
}
impl AsRef<BlockUser> for RTDBlockUserBuilder {
fn as_ref(&self) -> &BlockUser { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UnblockUser {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
}
impl RObject for UnblockUser {
#[doc(hidden)] fn td_name(&self) -> &'static str { "unblockUser" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for UnblockUser {}
impl UnblockUser {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDUnblockUserBuilder {
let mut inner = UnblockUser::default();
inner.td_name = "unblockUser".to_string();
RTDUnblockUserBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
}
#[doc(hidden)]
pub struct RTDUnblockUserBuilder {
inner: UnblockUser
}
impl RTDUnblockUserBuilder {
pub fn build(&self) -> UnblockUser { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
}
impl AsRef<UnblockUser> for UnblockUser {
fn as_ref(&self) -> &UnblockUser { self }
}
impl AsRef<UnblockUser> for RTDUnblockUserBuilder {
fn as_ref(&self) -> &UnblockUser { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetBlockedUsers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
offset: i64,
limit: i64,
}
impl RObject for GetBlockedUsers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getBlockedUsers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetBlockedUsers {}
impl GetBlockedUsers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetBlockedUsersBuilder {
let mut inner = GetBlockedUsers::default();
inner.td_name = "getBlockedUsers".to_string();
RTDGetBlockedUsersBuilder { inner }
}
pub fn offset(&self) -> i64 { self.offset }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDGetBlockedUsersBuilder {
inner: GetBlockedUsers
}
impl RTDGetBlockedUsersBuilder {
pub fn build(&self) -> GetBlockedUsers { self.inner.clone() }
pub fn offset(&mut self, offset: i64) -> &mut Self {
self.inner.offset = offset;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<GetBlockedUsers> for GetBlockedUsers {
fn as_ref(&self) -> &GetBlockedUsers { self }
}
impl AsRef<GetBlockedUsers> for RTDGetBlockedUsersBuilder {
fn as_ref(&self) -> &GetBlockedUsers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ImportContacts {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
contacts: Vec<Contact>,
}
impl RObject for ImportContacts {
#[doc(hidden)] fn td_name(&self) -> &'static str { "importContacts" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ImportContacts {}
impl ImportContacts {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDImportContactsBuilder {
let mut inner = ImportContacts::default();
inner.td_name = "importContacts".to_string();
RTDImportContactsBuilder { inner }
}
pub fn contacts(&self) -> &Vec<Contact> { &self.contacts }
}
#[doc(hidden)]
pub struct RTDImportContactsBuilder {
inner: ImportContacts
}
impl RTDImportContactsBuilder {
pub fn build(&self) -> ImportContacts { self.inner.clone() }
pub fn contacts(&mut self, contacts: Vec<Contact>) -> &mut Self {
self.inner.contacts = contacts;
self
}
}
impl AsRef<ImportContacts> for ImportContacts {
fn as_ref(&self) -> &ImportContacts { self }
}
impl AsRef<ImportContacts> for RTDImportContactsBuilder {
fn as_ref(&self) -> &ImportContacts { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetContacts {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetContacts {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getContacts" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetContacts {}
impl GetContacts {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetContactsBuilder {
let mut inner = GetContacts::default();
inner.td_name = "getContacts".to_string();
RTDGetContactsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetContactsBuilder {
inner: GetContacts
}
impl RTDGetContactsBuilder {
pub fn build(&self) -> GetContacts { self.inner.clone() }
}
impl AsRef<GetContacts> for GetContacts {
fn as_ref(&self) -> &GetContacts { self }
}
impl AsRef<GetContacts> for RTDGetContactsBuilder {
fn as_ref(&self) -> &GetContacts { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchContacts {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
query: String,
limit: i64,
}
impl RObject for SearchContacts {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchContacts" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchContacts {}
impl SearchContacts {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchContactsBuilder {
let mut inner = SearchContacts::default();
inner.td_name = "searchContacts".to_string();
RTDSearchContactsBuilder { inner }
}
pub fn query(&self) -> &String { &self.query }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDSearchContactsBuilder {
inner: SearchContacts
}
impl RTDSearchContactsBuilder {
pub fn build(&self) -> SearchContacts { self.inner.clone() }
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<SearchContacts> for SearchContacts {
fn as_ref(&self) -> &SearchContacts { self }
}
impl AsRef<SearchContacts> for RTDSearchContactsBuilder {
fn as_ref(&self) -> &SearchContacts { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RemoveContacts {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_ids: Vec<i64>,
}
impl RObject for RemoveContacts {
#[doc(hidden)] fn td_name(&self) -> &'static str { "removeContacts" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RemoveContacts {}
impl RemoveContacts {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRemoveContactsBuilder {
let mut inner = RemoveContacts::default();
inner.td_name = "removeContacts".to_string();
RTDRemoveContactsBuilder { inner }
}
pub fn user_ids(&self) -> &Vec<i64> { &self.user_ids }
}
#[doc(hidden)]
pub struct RTDRemoveContactsBuilder {
inner: RemoveContacts
}
impl RTDRemoveContactsBuilder {
pub fn build(&self) -> RemoveContacts { self.inner.clone() }
pub fn user_ids(&mut self, user_ids: Vec<i64>) -> &mut Self {
self.inner.user_ids = user_ids;
self
}
}
impl AsRef<RemoveContacts> for RemoveContacts {
fn as_ref(&self) -> &RemoveContacts { self }
}
impl AsRef<RemoveContacts> for RTDRemoveContactsBuilder {
fn as_ref(&self) -> &RemoveContacts { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetImportedContactCount {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetImportedContactCount {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getImportedContactCount" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetImportedContactCount {}
impl GetImportedContactCount {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetImportedContactCountBuilder {
let mut inner = GetImportedContactCount::default();
inner.td_name = "getImportedContactCount".to_string();
RTDGetImportedContactCountBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetImportedContactCountBuilder {
inner: GetImportedContactCount
}
impl RTDGetImportedContactCountBuilder {
pub fn build(&self) -> GetImportedContactCount { self.inner.clone() }
}
impl AsRef<GetImportedContactCount> for GetImportedContactCount {
fn as_ref(&self) -> &GetImportedContactCount { self }
}
impl AsRef<GetImportedContactCount> for RTDGetImportedContactCountBuilder {
fn as_ref(&self) -> &GetImportedContactCount { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ChangeImportedContacts {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
contacts: Vec<Contact>,
}
impl RObject for ChangeImportedContacts {
#[doc(hidden)] fn td_name(&self) -> &'static str { "changeImportedContacts" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ChangeImportedContacts {}
impl ChangeImportedContacts {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDChangeImportedContactsBuilder {
let mut inner = ChangeImportedContacts::default();
inner.td_name = "changeImportedContacts".to_string();
RTDChangeImportedContactsBuilder { inner }
}
pub fn contacts(&self) -> &Vec<Contact> { &self.contacts }
}
#[doc(hidden)]
pub struct RTDChangeImportedContactsBuilder {
inner: ChangeImportedContacts
}
impl RTDChangeImportedContactsBuilder {
pub fn build(&self) -> ChangeImportedContacts { self.inner.clone() }
pub fn contacts(&mut self, contacts: Vec<Contact>) -> &mut Self {
self.inner.contacts = contacts;
self
}
}
impl AsRef<ChangeImportedContacts> for ChangeImportedContacts {
fn as_ref(&self) -> &ChangeImportedContacts { self }
}
impl AsRef<ChangeImportedContacts> for RTDChangeImportedContactsBuilder {
fn as_ref(&self) -> &ChangeImportedContacts { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ClearImportedContacts {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for ClearImportedContacts {
#[doc(hidden)] fn td_name(&self) -> &'static str { "clearImportedContacts" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ClearImportedContacts {}
impl ClearImportedContacts {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDClearImportedContactsBuilder {
let mut inner = ClearImportedContacts::default();
inner.td_name = "clearImportedContacts".to_string();
RTDClearImportedContactsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDClearImportedContactsBuilder {
inner: ClearImportedContacts
}
impl RTDClearImportedContactsBuilder {
pub fn build(&self) -> ClearImportedContacts { self.inner.clone() }
}
impl AsRef<ClearImportedContacts> for ClearImportedContacts {
fn as_ref(&self) -> &ClearImportedContacts { self }
}
impl AsRef<ClearImportedContacts> for RTDClearImportedContactsBuilder {
fn as_ref(&self) -> &ClearImportedContacts { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetUserProfilePhotos {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
offset: i64,
limit: i64,
}
impl RObject for GetUserProfilePhotos {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getUserProfilePhotos" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetUserProfilePhotos {}
impl GetUserProfilePhotos {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetUserProfilePhotosBuilder {
let mut inner = GetUserProfilePhotos::default();
inner.td_name = "getUserProfilePhotos".to_string();
RTDGetUserProfilePhotosBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
pub fn offset(&self) -> i64 { self.offset }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDGetUserProfilePhotosBuilder {
inner: GetUserProfilePhotos
}
impl RTDGetUserProfilePhotosBuilder {
pub fn build(&self) -> GetUserProfilePhotos { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn offset(&mut self, offset: i64) -> &mut Self {
self.inner.offset = offset;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<GetUserProfilePhotos> for GetUserProfilePhotos {
fn as_ref(&self) -> &GetUserProfilePhotos { self }
}
impl AsRef<GetUserProfilePhotos> for RTDGetUserProfilePhotosBuilder {
fn as_ref(&self) -> &GetUserProfilePhotos { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetStickers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
emoji: String,
limit: i64,
}
impl RObject for GetStickers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getStickers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetStickers {}
impl GetStickers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetStickersBuilder {
let mut inner = GetStickers::default();
inner.td_name = "getStickers".to_string();
RTDGetStickersBuilder { inner }
}
pub fn emoji(&self) -> &String { &self.emoji }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDGetStickersBuilder {
inner: GetStickers
}
impl RTDGetStickersBuilder {
pub fn build(&self) -> GetStickers { self.inner.clone() }
pub fn emoji<T: AsRef<str>>(&mut self, emoji: T) -> &mut Self {
self.inner.emoji = emoji.as_ref().to_string();
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<GetStickers> for GetStickers {
fn as_ref(&self) -> &GetStickers { self }
}
impl AsRef<GetStickers> for RTDGetStickersBuilder {
fn as_ref(&self) -> &GetStickers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchStickers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
emoji: String,
limit: i64,
}
impl RObject for SearchStickers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchStickers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchStickers {}
impl SearchStickers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchStickersBuilder {
let mut inner = SearchStickers::default();
inner.td_name = "searchStickers".to_string();
RTDSearchStickersBuilder { inner }
}
pub fn emoji(&self) -> &String { &self.emoji }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDSearchStickersBuilder {
inner: SearchStickers
}
impl RTDSearchStickersBuilder {
pub fn build(&self) -> SearchStickers { self.inner.clone() }
pub fn emoji<T: AsRef<str>>(&mut self, emoji: T) -> &mut Self {
self.inner.emoji = emoji.as_ref().to_string();
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<SearchStickers> for SearchStickers {
fn as_ref(&self) -> &SearchStickers { self }
}
impl AsRef<SearchStickers> for RTDSearchStickersBuilder {
fn as_ref(&self) -> &SearchStickers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetInstalledStickerSets {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
is_masks: bool,
}
impl RObject for GetInstalledStickerSets {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getInstalledStickerSets" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetInstalledStickerSets {}
impl GetInstalledStickerSets {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetInstalledStickerSetsBuilder {
let mut inner = GetInstalledStickerSets::default();
inner.td_name = "getInstalledStickerSets".to_string();
RTDGetInstalledStickerSetsBuilder { inner }
}
pub fn is_masks(&self) -> bool { self.is_masks }
}
#[doc(hidden)]
pub struct RTDGetInstalledStickerSetsBuilder {
inner: GetInstalledStickerSets
}
impl RTDGetInstalledStickerSetsBuilder {
pub fn build(&self) -> GetInstalledStickerSets { self.inner.clone() }
pub fn is_masks(&mut self, is_masks: bool) -> &mut Self {
self.inner.is_masks = is_masks;
self
}
}
impl AsRef<GetInstalledStickerSets> for GetInstalledStickerSets {
fn as_ref(&self) -> &GetInstalledStickerSets { self }
}
impl AsRef<GetInstalledStickerSets> for RTDGetInstalledStickerSetsBuilder {
fn as_ref(&self) -> &GetInstalledStickerSets { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetArchivedStickerSets {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
is_masks: bool,
offset_sticker_set_id: isize,
limit: i64,
}
impl RObject for GetArchivedStickerSets {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getArchivedStickerSets" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetArchivedStickerSets {}
impl GetArchivedStickerSets {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetArchivedStickerSetsBuilder {
let mut inner = GetArchivedStickerSets::default();
inner.td_name = "getArchivedStickerSets".to_string();
RTDGetArchivedStickerSetsBuilder { inner }
}
pub fn is_masks(&self) -> bool { self.is_masks }
pub fn offset_sticker_set_id(&self) -> isize { self.offset_sticker_set_id }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDGetArchivedStickerSetsBuilder {
inner: GetArchivedStickerSets
}
impl RTDGetArchivedStickerSetsBuilder {
pub fn build(&self) -> GetArchivedStickerSets { self.inner.clone() }
pub fn is_masks(&mut self, is_masks: bool) -> &mut Self {
self.inner.is_masks = is_masks;
self
}
pub fn offset_sticker_set_id(&mut self, offset_sticker_set_id: isize) -> &mut Self {
self.inner.offset_sticker_set_id = offset_sticker_set_id;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<GetArchivedStickerSets> for GetArchivedStickerSets {
fn as_ref(&self) -> &GetArchivedStickerSets { self }
}
impl AsRef<GetArchivedStickerSets> for RTDGetArchivedStickerSetsBuilder {
fn as_ref(&self) -> &GetArchivedStickerSets { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetTrendingStickerSets {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetTrendingStickerSets {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getTrendingStickerSets" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetTrendingStickerSets {}
impl GetTrendingStickerSets {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetTrendingStickerSetsBuilder {
let mut inner = GetTrendingStickerSets::default();
inner.td_name = "getTrendingStickerSets".to_string();
RTDGetTrendingStickerSetsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetTrendingStickerSetsBuilder {
inner: GetTrendingStickerSets
}
impl RTDGetTrendingStickerSetsBuilder {
pub fn build(&self) -> GetTrendingStickerSets { self.inner.clone() }
}
impl AsRef<GetTrendingStickerSets> for GetTrendingStickerSets {
fn as_ref(&self) -> &GetTrendingStickerSets { self }
}
impl AsRef<GetTrendingStickerSets> for RTDGetTrendingStickerSetsBuilder {
fn as_ref(&self) -> &GetTrendingStickerSets { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetAttachedStickerSets {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
file_id: i64,
}
impl RObject for GetAttachedStickerSets {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getAttachedStickerSets" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetAttachedStickerSets {}
impl GetAttachedStickerSets {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetAttachedStickerSetsBuilder {
let mut inner = GetAttachedStickerSets::default();
inner.td_name = "getAttachedStickerSets".to_string();
RTDGetAttachedStickerSetsBuilder { inner }
}
pub fn file_id(&self) -> i64 { self.file_id }
}
#[doc(hidden)]
pub struct RTDGetAttachedStickerSetsBuilder {
inner: GetAttachedStickerSets
}
impl RTDGetAttachedStickerSetsBuilder {
pub fn build(&self) -> GetAttachedStickerSets { self.inner.clone() }
pub fn file_id(&mut self, file_id: i64) -> &mut Self {
self.inner.file_id = file_id;
self
}
}
impl AsRef<GetAttachedStickerSets> for GetAttachedStickerSets {
fn as_ref(&self) -> &GetAttachedStickerSets { self }
}
impl AsRef<GetAttachedStickerSets> for RTDGetAttachedStickerSetsBuilder {
fn as_ref(&self) -> &GetAttachedStickerSets { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetStickerSet {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
set_id: isize,
}
impl RObject for GetStickerSet {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getStickerSet" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetStickerSet {}
impl GetStickerSet {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetStickerSetBuilder {
let mut inner = GetStickerSet::default();
inner.td_name = "getStickerSet".to_string();
RTDGetStickerSetBuilder { inner }
}
pub fn set_id(&self) -> isize { self.set_id }
}
#[doc(hidden)]
pub struct RTDGetStickerSetBuilder {
inner: GetStickerSet
}
impl RTDGetStickerSetBuilder {
pub fn build(&self) -> GetStickerSet { self.inner.clone() }
pub fn set_id(&mut self, set_id: isize) -> &mut Self {
self.inner.set_id = set_id;
self
}
}
impl AsRef<GetStickerSet> for GetStickerSet {
fn as_ref(&self) -> &GetStickerSet { self }
}
impl AsRef<GetStickerSet> for RTDGetStickerSetBuilder {
fn as_ref(&self) -> &GetStickerSet { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchStickerSet {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
name: String,
}
impl RObject for SearchStickerSet {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchStickerSet" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchStickerSet {}
impl SearchStickerSet {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchStickerSetBuilder {
let mut inner = SearchStickerSet::default();
inner.td_name = "searchStickerSet".to_string();
RTDSearchStickerSetBuilder { inner }
}
pub fn name(&self) -> &String { &self.name }
}
#[doc(hidden)]
pub struct RTDSearchStickerSetBuilder {
inner: SearchStickerSet
}
impl RTDSearchStickerSetBuilder {
pub fn build(&self) -> SearchStickerSet { self.inner.clone() }
pub fn name<T: AsRef<str>>(&mut self, name: T) -> &mut Self {
self.inner.name = name.as_ref().to_string();
self
}
}
impl AsRef<SearchStickerSet> for SearchStickerSet {
fn as_ref(&self) -> &SearchStickerSet { self }
}
impl AsRef<SearchStickerSet> for RTDSearchStickerSetBuilder {
fn as_ref(&self) -> &SearchStickerSet { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchInstalledStickerSets {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
is_masks: bool,
query: String,
limit: i64,
}
impl RObject for SearchInstalledStickerSets {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchInstalledStickerSets" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchInstalledStickerSets {}
impl SearchInstalledStickerSets {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchInstalledStickerSetsBuilder {
let mut inner = SearchInstalledStickerSets::default();
inner.td_name = "searchInstalledStickerSets".to_string();
RTDSearchInstalledStickerSetsBuilder { inner }
}
pub fn is_masks(&self) -> bool { self.is_masks }
pub fn query(&self) -> &String { &self.query }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDSearchInstalledStickerSetsBuilder {
inner: SearchInstalledStickerSets
}
impl RTDSearchInstalledStickerSetsBuilder {
pub fn build(&self) -> SearchInstalledStickerSets { self.inner.clone() }
pub fn is_masks(&mut self, is_masks: bool) -> &mut Self {
self.inner.is_masks = is_masks;
self
}
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<SearchInstalledStickerSets> for SearchInstalledStickerSets {
fn as_ref(&self) -> &SearchInstalledStickerSets { self }
}
impl AsRef<SearchInstalledStickerSets> for RTDSearchInstalledStickerSetsBuilder {
fn as_ref(&self) -> &SearchInstalledStickerSets { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchStickerSets {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
query: String,
}
impl RObject for SearchStickerSets {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchStickerSets" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchStickerSets {}
impl SearchStickerSets {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchStickerSetsBuilder {
let mut inner = SearchStickerSets::default();
inner.td_name = "searchStickerSets".to_string();
RTDSearchStickerSetsBuilder { inner }
}
pub fn query(&self) -> &String { &self.query }
}
#[doc(hidden)]
pub struct RTDSearchStickerSetsBuilder {
inner: SearchStickerSets
}
impl RTDSearchStickerSetsBuilder {
pub fn build(&self) -> SearchStickerSets { self.inner.clone() }
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
}
impl AsRef<SearchStickerSets> for SearchStickerSets {
fn as_ref(&self) -> &SearchStickerSets { self }
}
impl AsRef<SearchStickerSets> for RTDSearchStickerSetsBuilder {
fn as_ref(&self) -> &SearchStickerSets { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ChangeStickerSet {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
set_id: isize,
is_installed: bool,
is_archived: bool,
}
impl RObject for ChangeStickerSet {
#[doc(hidden)] fn td_name(&self) -> &'static str { "changeStickerSet" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ChangeStickerSet {}
impl ChangeStickerSet {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDChangeStickerSetBuilder {
let mut inner = ChangeStickerSet::default();
inner.td_name = "changeStickerSet".to_string();
RTDChangeStickerSetBuilder { inner }
}
pub fn set_id(&self) -> isize { self.set_id }
pub fn is_installed(&self) -> bool { self.is_installed }
pub fn is_archived(&self) -> bool { self.is_archived }
}
#[doc(hidden)]
pub struct RTDChangeStickerSetBuilder {
inner: ChangeStickerSet
}
impl RTDChangeStickerSetBuilder {
pub fn build(&self) -> ChangeStickerSet { self.inner.clone() }
pub fn set_id(&mut self, set_id: isize) -> &mut Self {
self.inner.set_id = set_id;
self
}
pub fn is_installed(&mut self, is_installed: bool) -> &mut Self {
self.inner.is_installed = is_installed;
self
}
pub fn is_archived(&mut self, is_archived: bool) -> &mut Self {
self.inner.is_archived = is_archived;
self
}
}
impl AsRef<ChangeStickerSet> for ChangeStickerSet {
fn as_ref(&self) -> &ChangeStickerSet { self }
}
impl AsRef<ChangeStickerSet> for RTDChangeStickerSetBuilder {
fn as_ref(&self) -> &ChangeStickerSet { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ViewTrendingStickerSets {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
sticker_set_ids: Vec<isize>,
}
impl RObject for ViewTrendingStickerSets {
#[doc(hidden)] fn td_name(&self) -> &'static str { "viewTrendingStickerSets" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ViewTrendingStickerSets {}
impl ViewTrendingStickerSets {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDViewTrendingStickerSetsBuilder {
let mut inner = ViewTrendingStickerSets::default();
inner.td_name = "viewTrendingStickerSets".to_string();
RTDViewTrendingStickerSetsBuilder { inner }
}
pub fn sticker_set_ids(&self) -> &Vec<isize> { &self.sticker_set_ids }
}
#[doc(hidden)]
pub struct RTDViewTrendingStickerSetsBuilder {
inner: ViewTrendingStickerSets
}
impl RTDViewTrendingStickerSetsBuilder {
pub fn build(&self) -> ViewTrendingStickerSets { self.inner.clone() }
pub fn sticker_set_ids(&mut self, sticker_set_ids: Vec<isize>) -> &mut Self {
self.inner.sticker_set_ids = sticker_set_ids;
self
}
}
impl AsRef<ViewTrendingStickerSets> for ViewTrendingStickerSets {
fn as_ref(&self) -> &ViewTrendingStickerSets { self }
}
impl AsRef<ViewTrendingStickerSets> for RTDViewTrendingStickerSetsBuilder {
fn as_ref(&self) -> &ViewTrendingStickerSets { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ReorderInstalledStickerSets {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
is_masks: bool,
sticker_set_ids: Vec<isize>,
}
impl RObject for ReorderInstalledStickerSets {
#[doc(hidden)] fn td_name(&self) -> &'static str { "reorderInstalledStickerSets" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ReorderInstalledStickerSets {}
impl ReorderInstalledStickerSets {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDReorderInstalledStickerSetsBuilder {
let mut inner = ReorderInstalledStickerSets::default();
inner.td_name = "reorderInstalledStickerSets".to_string();
RTDReorderInstalledStickerSetsBuilder { inner }
}
pub fn is_masks(&self) -> bool { self.is_masks }
pub fn sticker_set_ids(&self) -> &Vec<isize> { &self.sticker_set_ids }
}
#[doc(hidden)]
pub struct RTDReorderInstalledStickerSetsBuilder {
inner: ReorderInstalledStickerSets
}
impl RTDReorderInstalledStickerSetsBuilder {
pub fn build(&self) -> ReorderInstalledStickerSets { self.inner.clone() }
pub fn is_masks(&mut self, is_masks: bool) -> &mut Self {
self.inner.is_masks = is_masks;
self
}
pub fn sticker_set_ids(&mut self, sticker_set_ids: Vec<isize>) -> &mut Self {
self.inner.sticker_set_ids = sticker_set_ids;
self
}
}
impl AsRef<ReorderInstalledStickerSets> for ReorderInstalledStickerSets {
fn as_ref(&self) -> &ReorderInstalledStickerSets { self }
}
impl AsRef<ReorderInstalledStickerSets> for RTDReorderInstalledStickerSetsBuilder {
fn as_ref(&self) -> &ReorderInstalledStickerSets { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetRecentStickers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
is_attached: bool,
}
impl RObject for GetRecentStickers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getRecentStickers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetRecentStickers {}
impl GetRecentStickers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetRecentStickersBuilder {
let mut inner = GetRecentStickers::default();
inner.td_name = "getRecentStickers".to_string();
RTDGetRecentStickersBuilder { inner }
}
pub fn is_attached(&self) -> bool { self.is_attached }
}
#[doc(hidden)]
pub struct RTDGetRecentStickersBuilder {
inner: GetRecentStickers
}
impl RTDGetRecentStickersBuilder {
pub fn build(&self) -> GetRecentStickers { self.inner.clone() }
pub fn is_attached(&mut self, is_attached: bool) -> &mut Self {
self.inner.is_attached = is_attached;
self
}
}
impl AsRef<GetRecentStickers> for GetRecentStickers {
fn as_ref(&self) -> &GetRecentStickers { self }
}
impl AsRef<GetRecentStickers> for RTDGetRecentStickersBuilder {
fn as_ref(&self) -> &GetRecentStickers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddRecentSticker {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
is_attached: bool,
sticker: InputFile,
}
impl RObject for AddRecentSticker {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addRecentSticker" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddRecentSticker {}
impl AddRecentSticker {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddRecentStickerBuilder {
let mut inner = AddRecentSticker::default();
inner.td_name = "addRecentSticker".to_string();
RTDAddRecentStickerBuilder { inner }
}
pub fn is_attached(&self) -> bool { self.is_attached }
pub fn sticker(&self) -> &InputFile { &self.sticker }
}
#[doc(hidden)]
pub struct RTDAddRecentStickerBuilder {
inner: AddRecentSticker
}
impl RTDAddRecentStickerBuilder {
pub fn build(&self) -> AddRecentSticker { self.inner.clone() }
pub fn is_attached(&mut self, is_attached: bool) -> &mut Self {
self.inner.is_attached = is_attached;
self
}
pub fn sticker<T: AsRef<InputFile>>(&mut self, sticker: T) -> &mut Self {
self.inner.sticker = sticker.as_ref().clone();
self
}
}
impl AsRef<AddRecentSticker> for AddRecentSticker {
fn as_ref(&self) -> &AddRecentSticker { self }
}
impl AsRef<AddRecentSticker> for RTDAddRecentStickerBuilder {
fn as_ref(&self) -> &AddRecentSticker { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RemoveRecentSticker {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
is_attached: bool,
sticker: InputFile,
}
impl RObject for RemoveRecentSticker {
#[doc(hidden)] fn td_name(&self) -> &'static str { "removeRecentSticker" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RemoveRecentSticker {}
impl RemoveRecentSticker {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRemoveRecentStickerBuilder {
let mut inner = RemoveRecentSticker::default();
inner.td_name = "removeRecentSticker".to_string();
RTDRemoveRecentStickerBuilder { inner }
}
pub fn is_attached(&self) -> bool { self.is_attached }
pub fn sticker(&self) -> &InputFile { &self.sticker }
}
#[doc(hidden)]
pub struct RTDRemoveRecentStickerBuilder {
inner: RemoveRecentSticker
}
impl RTDRemoveRecentStickerBuilder {
pub fn build(&self) -> RemoveRecentSticker { self.inner.clone() }
pub fn is_attached(&mut self, is_attached: bool) -> &mut Self {
self.inner.is_attached = is_attached;
self
}
pub fn sticker<T: AsRef<InputFile>>(&mut self, sticker: T) -> &mut Self {
self.inner.sticker = sticker.as_ref().clone();
self
}
}
impl AsRef<RemoveRecentSticker> for RemoveRecentSticker {
fn as_ref(&self) -> &RemoveRecentSticker { self }
}
impl AsRef<RemoveRecentSticker> for RTDRemoveRecentStickerBuilder {
fn as_ref(&self) -> &RemoveRecentSticker { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ClearRecentStickers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
is_attached: bool,
}
impl RObject for ClearRecentStickers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "clearRecentStickers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ClearRecentStickers {}
impl ClearRecentStickers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDClearRecentStickersBuilder {
let mut inner = ClearRecentStickers::default();
inner.td_name = "clearRecentStickers".to_string();
RTDClearRecentStickersBuilder { inner }
}
pub fn is_attached(&self) -> bool { self.is_attached }
}
#[doc(hidden)]
pub struct RTDClearRecentStickersBuilder {
inner: ClearRecentStickers
}
impl RTDClearRecentStickersBuilder {
pub fn build(&self) -> ClearRecentStickers { self.inner.clone() }
pub fn is_attached(&mut self, is_attached: bool) -> &mut Self {
self.inner.is_attached = is_attached;
self
}
}
impl AsRef<ClearRecentStickers> for ClearRecentStickers {
fn as_ref(&self) -> &ClearRecentStickers { self }
}
impl AsRef<ClearRecentStickers> for RTDClearRecentStickersBuilder {
fn as_ref(&self) -> &ClearRecentStickers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetFavoriteStickers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetFavoriteStickers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getFavoriteStickers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetFavoriteStickers {}
impl GetFavoriteStickers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetFavoriteStickersBuilder {
let mut inner = GetFavoriteStickers::default();
inner.td_name = "getFavoriteStickers".to_string();
RTDGetFavoriteStickersBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetFavoriteStickersBuilder {
inner: GetFavoriteStickers
}
impl RTDGetFavoriteStickersBuilder {
pub fn build(&self) -> GetFavoriteStickers { self.inner.clone() }
}
impl AsRef<GetFavoriteStickers> for GetFavoriteStickers {
fn as_ref(&self) -> &GetFavoriteStickers { self }
}
impl AsRef<GetFavoriteStickers> for RTDGetFavoriteStickersBuilder {
fn as_ref(&self) -> &GetFavoriteStickers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddFavoriteSticker {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
sticker: InputFile,
}
impl RObject for AddFavoriteSticker {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addFavoriteSticker" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddFavoriteSticker {}
impl AddFavoriteSticker {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddFavoriteStickerBuilder {
let mut inner = AddFavoriteSticker::default();
inner.td_name = "addFavoriteSticker".to_string();
RTDAddFavoriteStickerBuilder { inner }
}
pub fn sticker(&self) -> &InputFile { &self.sticker }
}
#[doc(hidden)]
pub struct RTDAddFavoriteStickerBuilder {
inner: AddFavoriteSticker
}
impl RTDAddFavoriteStickerBuilder {
pub fn build(&self) -> AddFavoriteSticker { self.inner.clone() }
pub fn sticker<T: AsRef<InputFile>>(&mut self, sticker: T) -> &mut Self {
self.inner.sticker = sticker.as_ref().clone();
self
}
}
impl AsRef<AddFavoriteSticker> for AddFavoriteSticker {
fn as_ref(&self) -> &AddFavoriteSticker { self }
}
impl AsRef<AddFavoriteSticker> for RTDAddFavoriteStickerBuilder {
fn as_ref(&self) -> &AddFavoriteSticker { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RemoveFavoriteSticker {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
sticker: InputFile,
}
impl RObject for RemoveFavoriteSticker {
#[doc(hidden)] fn td_name(&self) -> &'static str { "removeFavoriteSticker" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RemoveFavoriteSticker {}
impl RemoveFavoriteSticker {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRemoveFavoriteStickerBuilder {
let mut inner = RemoveFavoriteSticker::default();
inner.td_name = "removeFavoriteSticker".to_string();
RTDRemoveFavoriteStickerBuilder { inner }
}
pub fn sticker(&self) -> &InputFile { &self.sticker }
}
#[doc(hidden)]
pub struct RTDRemoveFavoriteStickerBuilder {
inner: RemoveFavoriteSticker
}
impl RTDRemoveFavoriteStickerBuilder {
pub fn build(&self) -> RemoveFavoriteSticker { self.inner.clone() }
pub fn sticker<T: AsRef<InputFile>>(&mut self, sticker: T) -> &mut Self {
self.inner.sticker = sticker.as_ref().clone();
self
}
}
impl AsRef<RemoveFavoriteSticker> for RemoveFavoriteSticker {
fn as_ref(&self) -> &RemoveFavoriteSticker { self }
}
impl AsRef<RemoveFavoriteSticker> for RTDRemoveFavoriteStickerBuilder {
fn as_ref(&self) -> &RemoveFavoriteSticker { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetStickerEmojis {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
sticker: InputFile,
}
impl RObject for GetStickerEmojis {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getStickerEmojis" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetStickerEmojis {}
impl GetStickerEmojis {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetStickerEmojisBuilder {
let mut inner = GetStickerEmojis::default();
inner.td_name = "getStickerEmojis".to_string();
RTDGetStickerEmojisBuilder { inner }
}
pub fn sticker(&self) -> &InputFile { &self.sticker }
}
#[doc(hidden)]
pub struct RTDGetStickerEmojisBuilder {
inner: GetStickerEmojis
}
impl RTDGetStickerEmojisBuilder {
pub fn build(&self) -> GetStickerEmojis { self.inner.clone() }
pub fn sticker<T: AsRef<InputFile>>(&mut self, sticker: T) -> &mut Self {
self.inner.sticker = sticker.as_ref().clone();
self
}
}
impl AsRef<GetStickerEmojis> for GetStickerEmojis {
fn as_ref(&self) -> &GetStickerEmojis { self }
}
impl AsRef<GetStickerEmojis> for RTDGetStickerEmojisBuilder {
fn as_ref(&self) -> &GetStickerEmojis { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetSavedAnimations {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetSavedAnimations {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getSavedAnimations" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetSavedAnimations {}
impl GetSavedAnimations {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetSavedAnimationsBuilder {
let mut inner = GetSavedAnimations::default();
inner.td_name = "getSavedAnimations".to_string();
RTDGetSavedAnimationsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetSavedAnimationsBuilder {
inner: GetSavedAnimations
}
impl RTDGetSavedAnimationsBuilder {
pub fn build(&self) -> GetSavedAnimations { self.inner.clone() }
}
impl AsRef<GetSavedAnimations> for GetSavedAnimations {
fn as_ref(&self) -> &GetSavedAnimations { self }
}
impl AsRef<GetSavedAnimations> for RTDGetSavedAnimationsBuilder {
fn as_ref(&self) -> &GetSavedAnimations { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddSavedAnimation {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
animation: InputFile,
}
impl RObject for AddSavedAnimation {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addSavedAnimation" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddSavedAnimation {}
impl AddSavedAnimation {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddSavedAnimationBuilder {
let mut inner = AddSavedAnimation::default();
inner.td_name = "addSavedAnimation".to_string();
RTDAddSavedAnimationBuilder { inner }
}
pub fn animation(&self) -> &InputFile { &self.animation }
}
#[doc(hidden)]
pub struct RTDAddSavedAnimationBuilder {
inner: AddSavedAnimation
}
impl RTDAddSavedAnimationBuilder {
pub fn build(&self) -> AddSavedAnimation { self.inner.clone() }
pub fn animation<T: AsRef<InputFile>>(&mut self, animation: T) -> &mut Self {
self.inner.animation = animation.as_ref().clone();
self
}
}
impl AsRef<AddSavedAnimation> for AddSavedAnimation {
fn as_ref(&self) -> &AddSavedAnimation { self }
}
impl AsRef<AddSavedAnimation> for RTDAddSavedAnimationBuilder {
fn as_ref(&self) -> &AddSavedAnimation { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RemoveSavedAnimation {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
animation: InputFile,
}
impl RObject for RemoveSavedAnimation {
#[doc(hidden)] fn td_name(&self) -> &'static str { "removeSavedAnimation" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RemoveSavedAnimation {}
impl RemoveSavedAnimation {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRemoveSavedAnimationBuilder {
let mut inner = RemoveSavedAnimation::default();
inner.td_name = "removeSavedAnimation".to_string();
RTDRemoveSavedAnimationBuilder { inner }
}
pub fn animation(&self) -> &InputFile { &self.animation }
}
#[doc(hidden)]
pub struct RTDRemoveSavedAnimationBuilder {
inner: RemoveSavedAnimation
}
impl RTDRemoveSavedAnimationBuilder {
pub fn build(&self) -> RemoveSavedAnimation { self.inner.clone() }
pub fn animation<T: AsRef<InputFile>>(&mut self, animation: T) -> &mut Self {
self.inner.animation = animation.as_ref().clone();
self
}
}
impl AsRef<RemoveSavedAnimation> for RemoveSavedAnimation {
fn as_ref(&self) -> &RemoveSavedAnimation { self }
}
impl AsRef<RemoveSavedAnimation> for RTDRemoveSavedAnimationBuilder {
fn as_ref(&self) -> &RemoveSavedAnimation { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetRecentInlineBots {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetRecentInlineBots {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getRecentInlineBots" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetRecentInlineBots {}
impl GetRecentInlineBots {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetRecentInlineBotsBuilder {
let mut inner = GetRecentInlineBots::default();
inner.td_name = "getRecentInlineBots".to_string();
RTDGetRecentInlineBotsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetRecentInlineBotsBuilder {
inner: GetRecentInlineBots
}
impl RTDGetRecentInlineBotsBuilder {
pub fn build(&self) -> GetRecentInlineBots { self.inner.clone() }
}
impl AsRef<GetRecentInlineBots> for GetRecentInlineBots {
fn as_ref(&self) -> &GetRecentInlineBots { self }
}
impl AsRef<GetRecentInlineBots> for RTDGetRecentInlineBotsBuilder {
fn as_ref(&self) -> &GetRecentInlineBots { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchHashtags {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
prefix: String,
limit: i64,
}
impl RObject for SearchHashtags {
#[doc(hidden)] fn td_name(&self) -> &'static str { "searchHashtags" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SearchHashtags {}
impl SearchHashtags {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSearchHashtagsBuilder {
let mut inner = SearchHashtags::default();
inner.td_name = "searchHashtags".to_string();
RTDSearchHashtagsBuilder { inner }
}
pub fn prefix(&self) -> &String { &self.prefix }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDSearchHashtagsBuilder {
inner: SearchHashtags
}
impl RTDSearchHashtagsBuilder {
pub fn build(&self) -> SearchHashtags { self.inner.clone() }
pub fn prefix<T: AsRef<str>>(&mut self, prefix: T) -> &mut Self {
self.inner.prefix = prefix.as_ref().to_string();
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<SearchHashtags> for SearchHashtags {
fn as_ref(&self) -> &SearchHashtags { self }
}
impl AsRef<SearchHashtags> for RTDSearchHashtagsBuilder {
fn as_ref(&self) -> &SearchHashtags { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RemoveRecentHashtag {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
hashtag: String,
}
impl RObject for RemoveRecentHashtag {
#[doc(hidden)] fn td_name(&self) -> &'static str { "removeRecentHashtag" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RemoveRecentHashtag {}
impl RemoveRecentHashtag {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRemoveRecentHashtagBuilder {
let mut inner = RemoveRecentHashtag::default();
inner.td_name = "removeRecentHashtag".to_string();
RTDRemoveRecentHashtagBuilder { inner }
}
pub fn hashtag(&self) -> &String { &self.hashtag }
}
#[doc(hidden)]
pub struct RTDRemoveRecentHashtagBuilder {
inner: RemoveRecentHashtag
}
impl RTDRemoveRecentHashtagBuilder {
pub fn build(&self) -> RemoveRecentHashtag { self.inner.clone() }
pub fn hashtag<T: AsRef<str>>(&mut self, hashtag: T) -> &mut Self {
self.inner.hashtag = hashtag.as_ref().to_string();
self
}
}
impl AsRef<RemoveRecentHashtag> for RemoveRecentHashtag {
fn as_ref(&self) -> &RemoveRecentHashtag { self }
}
impl AsRef<RemoveRecentHashtag> for RTDRemoveRecentHashtagBuilder {
fn as_ref(&self) -> &RemoveRecentHashtag { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetWebPagePreview {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
text: FormattedText,
}
impl RObject for GetWebPagePreview {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getWebPagePreview" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetWebPagePreview {}
impl GetWebPagePreview {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetWebPagePreviewBuilder {
let mut inner = GetWebPagePreview::default();
inner.td_name = "getWebPagePreview".to_string();
RTDGetWebPagePreviewBuilder { inner }
}
pub fn text(&self) -> &FormattedText { &self.text }
}
#[doc(hidden)]
pub struct RTDGetWebPagePreviewBuilder {
inner: GetWebPagePreview
}
impl RTDGetWebPagePreviewBuilder {
pub fn build(&self) -> GetWebPagePreview { self.inner.clone() }
pub fn text<T: AsRef<FormattedText>>(&mut self, text: T) -> &mut Self {
self.inner.text = text.as_ref().clone();
self
}
}
impl AsRef<GetWebPagePreview> for GetWebPagePreview {
fn as_ref(&self) -> &GetWebPagePreview { self }
}
impl AsRef<GetWebPagePreview> for RTDGetWebPagePreviewBuilder {
fn as_ref(&self) -> &GetWebPagePreview { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetWebPageInstantView {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
url: String,
force_full: bool,
}
impl RObject for GetWebPageInstantView {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getWebPageInstantView" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetWebPageInstantView {}
impl GetWebPageInstantView {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetWebPageInstantViewBuilder {
let mut inner = GetWebPageInstantView::default();
inner.td_name = "getWebPageInstantView".to_string();
RTDGetWebPageInstantViewBuilder { inner }
}
pub fn url(&self) -> &String { &self.url }
pub fn force_full(&self) -> bool { self.force_full }
}
#[doc(hidden)]
pub struct RTDGetWebPageInstantViewBuilder {
inner: GetWebPageInstantView
}
impl RTDGetWebPageInstantViewBuilder {
pub fn build(&self) -> GetWebPageInstantView { self.inner.clone() }
pub fn url<T: AsRef<str>>(&mut self, url: T) -> &mut Self {
self.inner.url = url.as_ref().to_string();
self
}
pub fn force_full(&mut self, force_full: bool) -> &mut Self {
self.inner.force_full = force_full;
self
}
}
impl AsRef<GetWebPageInstantView> for GetWebPageInstantView {
fn as_ref(&self) -> &GetWebPageInstantView { self }
}
impl AsRef<GetWebPageInstantView> for RTDGetWebPageInstantViewBuilder {
fn as_ref(&self) -> &GetWebPageInstantView { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetProfilePhoto {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
photo: InputFile,
}
impl RObject for SetProfilePhoto {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setProfilePhoto" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetProfilePhoto {}
impl SetProfilePhoto {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetProfilePhotoBuilder {
let mut inner = SetProfilePhoto::default();
inner.td_name = "setProfilePhoto".to_string();
RTDSetProfilePhotoBuilder { inner }
}
pub fn photo(&self) -> &InputFile { &self.photo }
}
#[doc(hidden)]
pub struct RTDSetProfilePhotoBuilder {
inner: SetProfilePhoto
}
impl RTDSetProfilePhotoBuilder {
pub fn build(&self) -> SetProfilePhoto { self.inner.clone() }
pub fn photo<T: AsRef<InputFile>>(&mut self, photo: T) -> &mut Self {
self.inner.photo = photo.as_ref().clone();
self
}
}
impl AsRef<SetProfilePhoto> for SetProfilePhoto {
fn as_ref(&self) -> &SetProfilePhoto { self }
}
impl AsRef<SetProfilePhoto> for RTDSetProfilePhotoBuilder {
fn as_ref(&self) -> &SetProfilePhoto { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteProfilePhoto {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
profile_photo_id: isize,
}
impl RObject for DeleteProfilePhoto {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteProfilePhoto" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteProfilePhoto {}
impl DeleteProfilePhoto {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteProfilePhotoBuilder {
let mut inner = DeleteProfilePhoto::default();
inner.td_name = "deleteProfilePhoto".to_string();
RTDDeleteProfilePhotoBuilder { inner }
}
pub fn profile_photo_id(&self) -> isize { self.profile_photo_id }
}
#[doc(hidden)]
pub struct RTDDeleteProfilePhotoBuilder {
inner: DeleteProfilePhoto
}
impl RTDDeleteProfilePhotoBuilder {
pub fn build(&self) -> DeleteProfilePhoto { self.inner.clone() }
pub fn profile_photo_id(&mut self, profile_photo_id: isize) -> &mut Self {
self.inner.profile_photo_id = profile_photo_id;
self
}
}
impl AsRef<DeleteProfilePhoto> for DeleteProfilePhoto {
fn as_ref(&self) -> &DeleteProfilePhoto { self }
}
impl AsRef<DeleteProfilePhoto> for RTDDeleteProfilePhotoBuilder {
fn as_ref(&self) -> &DeleteProfilePhoto { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetName {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
first_name: String,
last_name: String,
}
impl RObject for SetName {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setName" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetName {}
impl SetName {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetNameBuilder {
let mut inner = SetName::default();
inner.td_name = "setName".to_string();
RTDSetNameBuilder { inner }
}
pub fn first_name(&self) -> &String { &self.first_name }
pub fn last_name(&self) -> &String { &self.last_name }
}
#[doc(hidden)]
pub struct RTDSetNameBuilder {
inner: SetName
}
impl RTDSetNameBuilder {
pub fn build(&self) -> SetName { self.inner.clone() }
pub fn first_name<T: AsRef<str>>(&mut self, first_name: T) -> &mut Self {
self.inner.first_name = first_name.as_ref().to_string();
self
}
pub fn last_name<T: AsRef<str>>(&mut self, last_name: T) -> &mut Self {
self.inner.last_name = last_name.as_ref().to_string();
self
}
}
impl AsRef<SetName> for SetName {
fn as_ref(&self) -> &SetName { self }
}
impl AsRef<SetName> for RTDSetNameBuilder {
fn as_ref(&self) -> &SetName { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetBio {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
bio: String,
}
impl RObject for SetBio {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setBio" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetBio {}
impl SetBio {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetBioBuilder {
let mut inner = SetBio::default();
inner.td_name = "setBio".to_string();
RTDSetBioBuilder { inner }
}
pub fn bio(&self) -> &String { &self.bio }
}
#[doc(hidden)]
pub struct RTDSetBioBuilder {
inner: SetBio
}
impl RTDSetBioBuilder {
pub fn build(&self) -> SetBio { self.inner.clone() }
pub fn bio<T: AsRef<str>>(&mut self, bio: T) -> &mut Self {
self.inner.bio = bio.as_ref().to_string();
self
}
}
impl AsRef<SetBio> for SetBio {
fn as_ref(&self) -> &SetBio { self }
}
impl AsRef<SetBio> for RTDSetBioBuilder {
fn as_ref(&self) -> &SetBio { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetUsername {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
username: String,
}
impl RObject for SetUsername {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setUsername" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetUsername {}
impl SetUsername {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetUsernameBuilder {
let mut inner = SetUsername::default();
inner.td_name = "setUsername".to_string();
RTDSetUsernameBuilder { inner }
}
pub fn username(&self) -> &String { &self.username }
}
#[doc(hidden)]
pub struct RTDSetUsernameBuilder {
inner: SetUsername
}
impl RTDSetUsernameBuilder {
pub fn build(&self) -> SetUsername { self.inner.clone() }
pub fn username<T: AsRef<str>>(&mut self, username: T) -> &mut Self {
self.inner.username = username.as_ref().to_string();
self
}
}
impl AsRef<SetUsername> for SetUsername {
fn as_ref(&self) -> &SetUsername { self }
}
impl AsRef<SetUsername> for RTDSetUsernameBuilder {
fn as_ref(&self) -> &SetUsername { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ChangePhoneNumber {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
phone_number: String,
allow_flash_call: bool,
is_current_phone_number: bool,
}
impl RObject for ChangePhoneNumber {
#[doc(hidden)] fn td_name(&self) -> &'static str { "changePhoneNumber" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ChangePhoneNumber {}
impl ChangePhoneNumber {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDChangePhoneNumberBuilder {
let mut inner = ChangePhoneNumber::default();
inner.td_name = "changePhoneNumber".to_string();
RTDChangePhoneNumberBuilder { inner }
}
pub fn phone_number(&self) -> &String { &self.phone_number }
pub fn allow_flash_call(&self) -> bool { self.allow_flash_call }
pub fn is_current_phone_number(&self) -> bool { self.is_current_phone_number }
}
#[doc(hidden)]
pub struct RTDChangePhoneNumberBuilder {
inner: ChangePhoneNumber
}
impl RTDChangePhoneNumberBuilder {
pub fn build(&self) -> ChangePhoneNumber { self.inner.clone() }
pub fn phone_number<T: AsRef<str>>(&mut self, phone_number: T) -> &mut Self {
self.inner.phone_number = phone_number.as_ref().to_string();
self
}
pub fn allow_flash_call(&mut self, allow_flash_call: bool) -> &mut Self {
self.inner.allow_flash_call = allow_flash_call;
self
}
pub fn is_current_phone_number(&mut self, is_current_phone_number: bool) -> &mut Self {
self.inner.is_current_phone_number = is_current_phone_number;
self
}
}
impl AsRef<ChangePhoneNumber> for ChangePhoneNumber {
fn as_ref(&self) -> &ChangePhoneNumber { self }
}
impl AsRef<ChangePhoneNumber> for RTDChangePhoneNumberBuilder {
fn as_ref(&self) -> &ChangePhoneNumber { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ResendChangePhoneNumberCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for ResendChangePhoneNumberCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "resendChangePhoneNumberCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ResendChangePhoneNumberCode {}
impl ResendChangePhoneNumberCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDResendChangePhoneNumberCodeBuilder {
let mut inner = ResendChangePhoneNumberCode::default();
inner.td_name = "resendChangePhoneNumberCode".to_string();
RTDResendChangePhoneNumberCodeBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDResendChangePhoneNumberCodeBuilder {
inner: ResendChangePhoneNumberCode
}
impl RTDResendChangePhoneNumberCodeBuilder {
pub fn build(&self) -> ResendChangePhoneNumberCode { self.inner.clone() }
}
impl AsRef<ResendChangePhoneNumberCode> for ResendChangePhoneNumberCode {
fn as_ref(&self) -> &ResendChangePhoneNumberCode { self }
}
impl AsRef<ResendChangePhoneNumberCode> for RTDResendChangePhoneNumberCodeBuilder {
fn as_ref(&self) -> &ResendChangePhoneNumberCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckChangePhoneNumberCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
code: String,
}
impl RObject for CheckChangePhoneNumberCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkChangePhoneNumberCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CheckChangePhoneNumberCode {}
impl CheckChangePhoneNumberCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckChangePhoneNumberCodeBuilder {
let mut inner = CheckChangePhoneNumberCode::default();
inner.td_name = "checkChangePhoneNumberCode".to_string();
RTDCheckChangePhoneNumberCodeBuilder { inner }
}
pub fn code(&self) -> &String { &self.code }
}
#[doc(hidden)]
pub struct RTDCheckChangePhoneNumberCodeBuilder {
inner: CheckChangePhoneNumberCode
}
impl RTDCheckChangePhoneNumberCodeBuilder {
pub fn build(&self) -> CheckChangePhoneNumberCode { self.inner.clone() }
pub fn code<T: AsRef<str>>(&mut self, code: T) -> &mut Self {
self.inner.code = code.as_ref().to_string();
self
}
}
impl AsRef<CheckChangePhoneNumberCode> for CheckChangePhoneNumberCode {
fn as_ref(&self) -> &CheckChangePhoneNumberCode { self }
}
impl AsRef<CheckChangePhoneNumberCode> for RTDCheckChangePhoneNumberCodeBuilder {
fn as_ref(&self) -> &CheckChangePhoneNumberCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetActiveSessions {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetActiveSessions {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getActiveSessions" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetActiveSessions {}
impl GetActiveSessions {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetActiveSessionsBuilder {
let mut inner = GetActiveSessions::default();
inner.td_name = "getActiveSessions".to_string();
RTDGetActiveSessionsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetActiveSessionsBuilder {
inner: GetActiveSessions
}
impl RTDGetActiveSessionsBuilder {
pub fn build(&self) -> GetActiveSessions { self.inner.clone() }
}
impl AsRef<GetActiveSessions> for GetActiveSessions {
fn as_ref(&self) -> &GetActiveSessions { self }
}
impl AsRef<GetActiveSessions> for RTDGetActiveSessionsBuilder {
fn as_ref(&self) -> &GetActiveSessions { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TerminateSession {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
session_id: isize,
}
impl RObject for TerminateSession {
#[doc(hidden)] fn td_name(&self) -> &'static str { "terminateSession" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TerminateSession {}
impl TerminateSession {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTerminateSessionBuilder {
let mut inner = TerminateSession::default();
inner.td_name = "terminateSession".to_string();
RTDTerminateSessionBuilder { inner }
}
pub fn session_id(&self) -> isize { self.session_id }
}
#[doc(hidden)]
pub struct RTDTerminateSessionBuilder {
inner: TerminateSession
}
impl RTDTerminateSessionBuilder {
pub fn build(&self) -> TerminateSession { self.inner.clone() }
pub fn session_id(&mut self, session_id: isize) -> &mut Self {
self.inner.session_id = session_id;
self
}
}
impl AsRef<TerminateSession> for TerminateSession {
fn as_ref(&self) -> &TerminateSession { self }
}
impl AsRef<TerminateSession> for RTDTerminateSessionBuilder {
fn as_ref(&self) -> &TerminateSession { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TerminateAllOtherSessions {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for TerminateAllOtherSessions {
#[doc(hidden)] fn td_name(&self) -> &'static str { "terminateAllOtherSessions" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TerminateAllOtherSessions {}
impl TerminateAllOtherSessions {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTerminateAllOtherSessionsBuilder {
let mut inner = TerminateAllOtherSessions::default();
inner.td_name = "terminateAllOtherSessions".to_string();
RTDTerminateAllOtherSessionsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDTerminateAllOtherSessionsBuilder {
inner: TerminateAllOtherSessions
}
impl RTDTerminateAllOtherSessionsBuilder {
pub fn build(&self) -> TerminateAllOtherSessions { self.inner.clone() }
}
impl AsRef<TerminateAllOtherSessions> for TerminateAllOtherSessions {
fn as_ref(&self) -> &TerminateAllOtherSessions { self }
}
impl AsRef<TerminateAllOtherSessions> for RTDTerminateAllOtherSessionsBuilder {
fn as_ref(&self) -> &TerminateAllOtherSessions { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetConnectedWebsites {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetConnectedWebsites {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getConnectedWebsites" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetConnectedWebsites {}
impl GetConnectedWebsites {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetConnectedWebsitesBuilder {
let mut inner = GetConnectedWebsites::default();
inner.td_name = "getConnectedWebsites".to_string();
RTDGetConnectedWebsitesBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetConnectedWebsitesBuilder {
inner: GetConnectedWebsites
}
impl RTDGetConnectedWebsitesBuilder {
pub fn build(&self) -> GetConnectedWebsites { self.inner.clone() }
}
impl AsRef<GetConnectedWebsites> for GetConnectedWebsites {
fn as_ref(&self) -> &GetConnectedWebsites { self }
}
impl AsRef<GetConnectedWebsites> for RTDGetConnectedWebsitesBuilder {
fn as_ref(&self) -> &GetConnectedWebsites { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DisconnectWebsite {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
website_id: isize,
}
impl RObject for DisconnectWebsite {
#[doc(hidden)] fn td_name(&self) -> &'static str { "disconnectWebsite" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DisconnectWebsite {}
impl DisconnectWebsite {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDisconnectWebsiteBuilder {
let mut inner = DisconnectWebsite::default();
inner.td_name = "disconnectWebsite".to_string();
RTDDisconnectWebsiteBuilder { inner }
}
pub fn website_id(&self) -> isize { self.website_id }
}
#[doc(hidden)]
pub struct RTDDisconnectWebsiteBuilder {
inner: DisconnectWebsite
}
impl RTDDisconnectWebsiteBuilder {
pub fn build(&self) -> DisconnectWebsite { self.inner.clone() }
pub fn website_id(&mut self, website_id: isize) -> &mut Self {
self.inner.website_id = website_id;
self
}
}
impl AsRef<DisconnectWebsite> for DisconnectWebsite {
fn as_ref(&self) -> &DisconnectWebsite { self }
}
impl AsRef<DisconnectWebsite> for RTDDisconnectWebsiteBuilder {
fn as_ref(&self) -> &DisconnectWebsite { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DisconnectAllWebsites {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for DisconnectAllWebsites {
#[doc(hidden)] fn td_name(&self) -> &'static str { "disconnectAllWebsites" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DisconnectAllWebsites {}
impl DisconnectAllWebsites {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDisconnectAllWebsitesBuilder {
let mut inner = DisconnectAllWebsites::default();
inner.td_name = "disconnectAllWebsites".to_string();
RTDDisconnectAllWebsitesBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDDisconnectAllWebsitesBuilder {
inner: DisconnectAllWebsites
}
impl RTDDisconnectAllWebsitesBuilder {
pub fn build(&self) -> DisconnectAllWebsites { self.inner.clone() }
}
impl AsRef<DisconnectAllWebsites> for DisconnectAllWebsites {
fn as_ref(&self) -> &DisconnectAllWebsites { self }
}
impl AsRef<DisconnectAllWebsites> for RTDDisconnectAllWebsitesBuilder {
fn as_ref(&self) -> &DisconnectAllWebsites { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ToggleBasicGroupAdministrators {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
basic_group_id: i64,
everyone_is_administrator: bool,
}
impl RObject for ToggleBasicGroupAdministrators {
#[doc(hidden)] fn td_name(&self) -> &'static str { "toggleBasicGroupAdministrators" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ToggleBasicGroupAdministrators {}
impl ToggleBasicGroupAdministrators {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDToggleBasicGroupAdministratorsBuilder {
let mut inner = ToggleBasicGroupAdministrators::default();
inner.td_name = "toggleBasicGroupAdministrators".to_string();
RTDToggleBasicGroupAdministratorsBuilder { inner }
}
pub fn basic_group_id(&self) -> i64 { self.basic_group_id }
pub fn everyone_is_administrator(&self) -> bool { self.everyone_is_administrator }
}
#[doc(hidden)]
pub struct RTDToggleBasicGroupAdministratorsBuilder {
inner: ToggleBasicGroupAdministrators
}
impl RTDToggleBasicGroupAdministratorsBuilder {
pub fn build(&self) -> ToggleBasicGroupAdministrators { self.inner.clone() }
pub fn basic_group_id(&mut self, basic_group_id: i64) -> &mut Self {
self.inner.basic_group_id = basic_group_id;
self
}
pub fn everyone_is_administrator(&mut self, everyone_is_administrator: bool) -> &mut Self {
self.inner.everyone_is_administrator = everyone_is_administrator;
self
}
}
impl AsRef<ToggleBasicGroupAdministrators> for ToggleBasicGroupAdministrators {
fn as_ref(&self) -> &ToggleBasicGroupAdministrators { self }
}
impl AsRef<ToggleBasicGroupAdministrators> for RTDToggleBasicGroupAdministratorsBuilder {
fn as_ref(&self) -> &ToggleBasicGroupAdministrators { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetSupergroupUsername {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
username: String,
}
impl RObject for SetSupergroupUsername {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setSupergroupUsername" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetSupergroupUsername {}
impl SetSupergroupUsername {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetSupergroupUsernameBuilder {
let mut inner = SetSupergroupUsername::default();
inner.td_name = "setSupergroupUsername".to_string();
RTDSetSupergroupUsernameBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn username(&self) -> &String { &self.username }
}
#[doc(hidden)]
pub struct RTDSetSupergroupUsernameBuilder {
inner: SetSupergroupUsername
}
impl RTDSetSupergroupUsernameBuilder {
pub fn build(&self) -> SetSupergroupUsername { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn username<T: AsRef<str>>(&mut self, username: T) -> &mut Self {
self.inner.username = username.as_ref().to_string();
self
}
}
impl AsRef<SetSupergroupUsername> for SetSupergroupUsername {
fn as_ref(&self) -> &SetSupergroupUsername { self }
}
impl AsRef<SetSupergroupUsername> for RTDSetSupergroupUsernameBuilder {
fn as_ref(&self) -> &SetSupergroupUsername { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetSupergroupStickerSet {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
sticker_set_id: isize,
}
impl RObject for SetSupergroupStickerSet {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setSupergroupStickerSet" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetSupergroupStickerSet {}
impl SetSupergroupStickerSet {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetSupergroupStickerSetBuilder {
let mut inner = SetSupergroupStickerSet::default();
inner.td_name = "setSupergroupStickerSet".to_string();
RTDSetSupergroupStickerSetBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn sticker_set_id(&self) -> isize { self.sticker_set_id }
}
#[doc(hidden)]
pub struct RTDSetSupergroupStickerSetBuilder {
inner: SetSupergroupStickerSet
}
impl RTDSetSupergroupStickerSetBuilder {
pub fn build(&self) -> SetSupergroupStickerSet { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn sticker_set_id(&mut self, sticker_set_id: isize) -> &mut Self {
self.inner.sticker_set_id = sticker_set_id;
self
}
}
impl AsRef<SetSupergroupStickerSet> for SetSupergroupStickerSet {
fn as_ref(&self) -> &SetSupergroupStickerSet { self }
}
impl AsRef<SetSupergroupStickerSet> for RTDSetSupergroupStickerSetBuilder {
fn as_ref(&self) -> &SetSupergroupStickerSet { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ToggleSupergroupInvites {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
anyone_can_invite: bool,
}
impl RObject for ToggleSupergroupInvites {
#[doc(hidden)] fn td_name(&self) -> &'static str { "toggleSupergroupInvites" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ToggleSupergroupInvites {}
impl ToggleSupergroupInvites {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDToggleSupergroupInvitesBuilder {
let mut inner = ToggleSupergroupInvites::default();
inner.td_name = "toggleSupergroupInvites".to_string();
RTDToggleSupergroupInvitesBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn anyone_can_invite(&self) -> bool { self.anyone_can_invite }
}
#[doc(hidden)]
pub struct RTDToggleSupergroupInvitesBuilder {
inner: ToggleSupergroupInvites
}
impl RTDToggleSupergroupInvitesBuilder {
pub fn build(&self) -> ToggleSupergroupInvites { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn anyone_can_invite(&mut self, anyone_can_invite: bool) -> &mut Self {
self.inner.anyone_can_invite = anyone_can_invite;
self
}
}
impl AsRef<ToggleSupergroupInvites> for ToggleSupergroupInvites {
fn as_ref(&self) -> &ToggleSupergroupInvites { self }
}
impl AsRef<ToggleSupergroupInvites> for RTDToggleSupergroupInvitesBuilder {
fn as_ref(&self) -> &ToggleSupergroupInvites { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ToggleSupergroupSignMessages {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
sign_messages: bool,
}
impl RObject for ToggleSupergroupSignMessages {
#[doc(hidden)] fn td_name(&self) -> &'static str { "toggleSupergroupSignMessages" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ToggleSupergroupSignMessages {}
impl ToggleSupergroupSignMessages {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDToggleSupergroupSignMessagesBuilder {
let mut inner = ToggleSupergroupSignMessages::default();
inner.td_name = "toggleSupergroupSignMessages".to_string();
RTDToggleSupergroupSignMessagesBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn sign_messages(&self) -> bool { self.sign_messages }
}
#[doc(hidden)]
pub struct RTDToggleSupergroupSignMessagesBuilder {
inner: ToggleSupergroupSignMessages
}
impl RTDToggleSupergroupSignMessagesBuilder {
pub fn build(&self) -> ToggleSupergroupSignMessages { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn sign_messages(&mut self, sign_messages: bool) -> &mut Self {
self.inner.sign_messages = sign_messages;
self
}
}
impl AsRef<ToggleSupergroupSignMessages> for ToggleSupergroupSignMessages {
fn as_ref(&self) -> &ToggleSupergroupSignMessages { self }
}
impl AsRef<ToggleSupergroupSignMessages> for RTDToggleSupergroupSignMessagesBuilder {
fn as_ref(&self) -> &ToggleSupergroupSignMessages { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ToggleSupergroupIsAllHistoryAvailable {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
is_all_history_available: bool,
}
impl RObject for ToggleSupergroupIsAllHistoryAvailable {
#[doc(hidden)] fn td_name(&self) -> &'static str { "toggleSupergroupIsAllHistoryAvailable" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ToggleSupergroupIsAllHistoryAvailable {}
impl ToggleSupergroupIsAllHistoryAvailable {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDToggleSupergroupIsAllHistoryAvailableBuilder {
let mut inner = ToggleSupergroupIsAllHistoryAvailable::default();
inner.td_name = "toggleSupergroupIsAllHistoryAvailable".to_string();
RTDToggleSupergroupIsAllHistoryAvailableBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn is_all_history_available(&self) -> bool { self.is_all_history_available }
}
#[doc(hidden)]
pub struct RTDToggleSupergroupIsAllHistoryAvailableBuilder {
inner: ToggleSupergroupIsAllHistoryAvailable
}
impl RTDToggleSupergroupIsAllHistoryAvailableBuilder {
pub fn build(&self) -> ToggleSupergroupIsAllHistoryAvailable { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn is_all_history_available(&mut self, is_all_history_available: bool) -> &mut Self {
self.inner.is_all_history_available = is_all_history_available;
self
}
}
impl AsRef<ToggleSupergroupIsAllHistoryAvailable> for ToggleSupergroupIsAllHistoryAvailable {
fn as_ref(&self) -> &ToggleSupergroupIsAllHistoryAvailable { self }
}
impl AsRef<ToggleSupergroupIsAllHistoryAvailable> for RTDToggleSupergroupIsAllHistoryAvailableBuilder {
fn as_ref(&self) -> &ToggleSupergroupIsAllHistoryAvailable { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetSupergroupDescription {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
description: String,
}
impl RObject for SetSupergroupDescription {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setSupergroupDescription" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetSupergroupDescription {}
impl SetSupergroupDescription {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetSupergroupDescriptionBuilder {
let mut inner = SetSupergroupDescription::default();
inner.td_name = "setSupergroupDescription".to_string();
RTDSetSupergroupDescriptionBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn description(&self) -> &String { &self.description }
}
#[doc(hidden)]
pub struct RTDSetSupergroupDescriptionBuilder {
inner: SetSupergroupDescription
}
impl RTDSetSupergroupDescriptionBuilder {
pub fn build(&self) -> SetSupergroupDescription { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn description<T: AsRef<str>>(&mut self, description: T) -> &mut Self {
self.inner.description = description.as_ref().to_string();
self
}
}
impl AsRef<SetSupergroupDescription> for SetSupergroupDescription {
fn as_ref(&self) -> &SetSupergroupDescription { self }
}
impl AsRef<SetSupergroupDescription> for RTDSetSupergroupDescriptionBuilder {
fn as_ref(&self) -> &SetSupergroupDescription { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct PinSupergroupMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
message_id: i64,
disable_notification: bool,
}
impl RObject for PinSupergroupMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "pinSupergroupMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for PinSupergroupMessage {}
impl PinSupergroupMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDPinSupergroupMessageBuilder {
let mut inner = PinSupergroupMessage::default();
inner.td_name = "pinSupergroupMessage".to_string();
RTDPinSupergroupMessageBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn disable_notification(&self) -> bool { self.disable_notification }
}
#[doc(hidden)]
pub struct RTDPinSupergroupMessageBuilder {
inner: PinSupergroupMessage
}
impl RTDPinSupergroupMessageBuilder {
pub fn build(&self) -> PinSupergroupMessage { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn disable_notification(&mut self, disable_notification: bool) -> &mut Self {
self.inner.disable_notification = disable_notification;
self
}
}
impl AsRef<PinSupergroupMessage> for PinSupergroupMessage {
fn as_ref(&self) -> &PinSupergroupMessage { self }
}
impl AsRef<PinSupergroupMessage> for RTDPinSupergroupMessageBuilder {
fn as_ref(&self) -> &PinSupergroupMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UnpinSupergroupMessage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
}
impl RObject for UnpinSupergroupMessage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "unpinSupergroupMessage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for UnpinSupergroupMessage {}
impl UnpinSupergroupMessage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDUnpinSupergroupMessageBuilder {
let mut inner = UnpinSupergroupMessage::default();
inner.td_name = "unpinSupergroupMessage".to_string();
RTDUnpinSupergroupMessageBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
}
#[doc(hidden)]
pub struct RTDUnpinSupergroupMessageBuilder {
inner: UnpinSupergroupMessage
}
impl RTDUnpinSupergroupMessageBuilder {
pub fn build(&self) -> UnpinSupergroupMessage { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
}
impl AsRef<UnpinSupergroupMessage> for UnpinSupergroupMessage {
fn as_ref(&self) -> &UnpinSupergroupMessage { self }
}
impl AsRef<UnpinSupergroupMessage> for RTDUnpinSupergroupMessageBuilder {
fn as_ref(&self) -> &UnpinSupergroupMessage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ReportSupergroupSpam {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
user_id: i64,
message_ids: Vec<i64>,
}
impl RObject for ReportSupergroupSpam {
#[doc(hidden)] fn td_name(&self) -> &'static str { "reportSupergroupSpam" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ReportSupergroupSpam {}
impl ReportSupergroupSpam {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDReportSupergroupSpamBuilder {
let mut inner = ReportSupergroupSpam::default();
inner.td_name = "reportSupergroupSpam".to_string();
RTDReportSupergroupSpamBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn user_id(&self) -> i64 { self.user_id }
pub fn message_ids(&self) -> &Vec<i64> { &self.message_ids }
}
#[doc(hidden)]
pub struct RTDReportSupergroupSpamBuilder {
inner: ReportSupergroupSpam
}
impl RTDReportSupergroupSpamBuilder {
pub fn build(&self) -> ReportSupergroupSpam { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn message_ids(&mut self, message_ids: Vec<i64>) -> &mut Self {
self.inner.message_ids = message_ids;
self
}
}
impl AsRef<ReportSupergroupSpam> for ReportSupergroupSpam {
fn as_ref(&self) -> &ReportSupergroupSpam { self }
}
impl AsRef<ReportSupergroupSpam> for RTDReportSupergroupSpamBuilder {
fn as_ref(&self) -> &ReportSupergroupSpam { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetSupergroupMembers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
filter: SupergroupMembersFilter,
offset: i64,
limit: i64,
}
impl RObject for GetSupergroupMembers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getSupergroupMembers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetSupergroupMembers {}
impl GetSupergroupMembers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetSupergroupMembersBuilder {
let mut inner = GetSupergroupMembers::default();
inner.td_name = "getSupergroupMembers".to_string();
RTDGetSupergroupMembersBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
pub fn filter(&self) -> &SupergroupMembersFilter { &self.filter }
pub fn offset(&self) -> i64 { self.offset }
pub fn limit(&self) -> i64 { self.limit }
}
#[doc(hidden)]
pub struct RTDGetSupergroupMembersBuilder {
inner: GetSupergroupMembers
}
impl RTDGetSupergroupMembersBuilder {
pub fn build(&self) -> GetSupergroupMembers { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
pub fn filter<T: AsRef<SupergroupMembersFilter>>(&mut self, filter: T) -> &mut Self {
self.inner.filter = filter.as_ref().clone();
self
}
pub fn offset(&mut self, offset: i64) -> &mut Self {
self.inner.offset = offset;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
}
impl AsRef<GetSupergroupMembers> for GetSupergroupMembers {
fn as_ref(&self) -> &GetSupergroupMembers { self }
}
impl AsRef<GetSupergroupMembers> for RTDGetSupergroupMembersBuilder {
fn as_ref(&self) -> &GetSupergroupMembers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteSupergroup {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
supergroup_id: i64,
}
impl RObject for DeleteSupergroup {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteSupergroup" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteSupergroup {}
impl DeleteSupergroup {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteSupergroupBuilder {
let mut inner = DeleteSupergroup::default();
inner.td_name = "deleteSupergroup".to_string();
RTDDeleteSupergroupBuilder { inner }
}
pub fn supergroup_id(&self) -> i64 { self.supergroup_id }
}
#[doc(hidden)]
pub struct RTDDeleteSupergroupBuilder {
inner: DeleteSupergroup
}
impl RTDDeleteSupergroupBuilder {
pub fn build(&self) -> DeleteSupergroup { self.inner.clone() }
pub fn supergroup_id(&mut self, supergroup_id: i64) -> &mut Self {
self.inner.supergroup_id = supergroup_id;
self
}
}
impl AsRef<DeleteSupergroup> for DeleteSupergroup {
fn as_ref(&self) -> &DeleteSupergroup { self }
}
impl AsRef<DeleteSupergroup> for RTDDeleteSupergroupBuilder {
fn as_ref(&self) -> &DeleteSupergroup { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CloseSecretChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
secret_chat_id: i64,
}
impl RObject for CloseSecretChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "closeSecretChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CloseSecretChat {}
impl CloseSecretChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCloseSecretChatBuilder {
let mut inner = CloseSecretChat::default();
inner.td_name = "closeSecretChat".to_string();
RTDCloseSecretChatBuilder { inner }
}
pub fn secret_chat_id(&self) -> i64 { self.secret_chat_id }
}
#[doc(hidden)]
pub struct RTDCloseSecretChatBuilder {
inner: CloseSecretChat
}
impl RTDCloseSecretChatBuilder {
pub fn build(&self) -> CloseSecretChat { self.inner.clone() }
pub fn secret_chat_id(&mut self, secret_chat_id: i64) -> &mut Self {
self.inner.secret_chat_id = secret_chat_id;
self
}
}
impl AsRef<CloseSecretChat> for CloseSecretChat {
fn as_ref(&self) -> &CloseSecretChat { self }
}
impl AsRef<CloseSecretChat> for RTDCloseSecretChatBuilder {
fn as_ref(&self) -> &CloseSecretChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChatEventLog {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
query: String,
from_event_id: isize,
limit: i64,
filters: ChatEventLogFilters,
user_ids: Vec<i64>,
}
impl RObject for GetChatEventLog {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChatEventLog" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChatEventLog {}
impl GetChatEventLog {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatEventLogBuilder {
let mut inner = GetChatEventLog::default();
inner.td_name = "getChatEventLog".to_string();
RTDGetChatEventLogBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn query(&self) -> &String { &self.query }
pub fn from_event_id(&self) -> isize { self.from_event_id }
pub fn limit(&self) -> i64 { self.limit }
pub fn filters(&self) -> &ChatEventLogFilters { &self.filters }
pub fn user_ids(&self) -> &Vec<i64> { &self.user_ids }
}
#[doc(hidden)]
pub struct RTDGetChatEventLogBuilder {
inner: GetChatEventLog
}
impl RTDGetChatEventLogBuilder {
pub fn build(&self) -> GetChatEventLog { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn query<T: AsRef<str>>(&mut self, query: T) -> &mut Self {
self.inner.query = query.as_ref().to_string();
self
}
pub fn from_event_id(&mut self, from_event_id: isize) -> &mut Self {
self.inner.from_event_id = from_event_id;
self
}
pub fn limit(&mut self, limit: i64) -> &mut Self {
self.inner.limit = limit;
self
}
pub fn filters<T: AsRef<ChatEventLogFilters>>(&mut self, filters: T) -> &mut Self {
self.inner.filters = filters.as_ref().clone();
self
}
pub fn user_ids(&mut self, user_ids: Vec<i64>) -> &mut Self {
self.inner.user_ids = user_ids;
self
}
}
impl AsRef<GetChatEventLog> for GetChatEventLog {
fn as_ref(&self) -> &GetChatEventLog { self }
}
impl AsRef<GetChatEventLog> for RTDGetChatEventLogBuilder {
fn as_ref(&self) -> &GetChatEventLog { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetPaymentForm {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
}
impl RObject for GetPaymentForm {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getPaymentForm" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetPaymentForm {}
impl GetPaymentForm {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetPaymentFormBuilder {
let mut inner = GetPaymentForm::default();
inner.td_name = "getPaymentForm".to_string();
RTDGetPaymentFormBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
}
#[doc(hidden)]
pub struct RTDGetPaymentFormBuilder {
inner: GetPaymentForm
}
impl RTDGetPaymentFormBuilder {
pub fn build(&self) -> GetPaymentForm { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
}
impl AsRef<GetPaymentForm> for GetPaymentForm {
fn as_ref(&self) -> &GetPaymentForm { self }
}
impl AsRef<GetPaymentForm> for RTDGetPaymentFormBuilder {
fn as_ref(&self) -> &GetPaymentForm { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ValidateOrderInfo {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
order_info: OrderInfo,
allow_save: bool,
}
impl RObject for ValidateOrderInfo {
#[doc(hidden)] fn td_name(&self) -> &'static str { "validateOrderInfo" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ValidateOrderInfo {}
impl ValidateOrderInfo {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDValidateOrderInfoBuilder {
let mut inner = ValidateOrderInfo::default();
inner.td_name = "validateOrderInfo".to_string();
RTDValidateOrderInfoBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn order_info(&self) -> &OrderInfo { &self.order_info }
pub fn allow_save(&self) -> bool { self.allow_save }
}
#[doc(hidden)]
pub struct RTDValidateOrderInfoBuilder {
inner: ValidateOrderInfo
}
impl RTDValidateOrderInfoBuilder {
pub fn build(&self) -> ValidateOrderInfo { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn order_info<T: AsRef<OrderInfo>>(&mut self, order_info: T) -> &mut Self {
self.inner.order_info = order_info.as_ref().clone();
self
}
pub fn allow_save(&mut self, allow_save: bool) -> &mut Self {
self.inner.allow_save = allow_save;
self
}
}
impl AsRef<ValidateOrderInfo> for ValidateOrderInfo {
fn as_ref(&self) -> &ValidateOrderInfo { self }
}
impl AsRef<ValidateOrderInfo> for RTDValidateOrderInfoBuilder {
fn as_ref(&self) -> &ValidateOrderInfo { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendPaymentForm {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
order_info_id: String,
shipping_option_id: String,
credentials: InputCredentials,
}
impl RObject for SendPaymentForm {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendPaymentForm" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendPaymentForm {}
impl SendPaymentForm {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendPaymentFormBuilder {
let mut inner = SendPaymentForm::default();
inner.td_name = "sendPaymentForm".to_string();
RTDSendPaymentFormBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
pub fn order_info_id(&self) -> &String { &self.order_info_id }
pub fn shipping_option_id(&self) -> &String { &self.shipping_option_id }
pub fn credentials(&self) -> &InputCredentials { &self.credentials }
}
#[doc(hidden)]
pub struct RTDSendPaymentFormBuilder {
inner: SendPaymentForm
}
impl RTDSendPaymentFormBuilder {
pub fn build(&self) -> SendPaymentForm { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
pub fn order_info_id<T: AsRef<str>>(&mut self, order_info_id: T) -> &mut Self {
self.inner.order_info_id = order_info_id.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 credentials<T: AsRef<InputCredentials>>(&mut self, credentials: T) -> &mut Self {
self.inner.credentials = credentials.as_ref().clone();
self
}
}
impl AsRef<SendPaymentForm> for SendPaymentForm {
fn as_ref(&self) -> &SendPaymentForm { self }
}
impl AsRef<SendPaymentForm> for RTDSendPaymentFormBuilder {
fn as_ref(&self) -> &SendPaymentForm { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetPaymentReceipt {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
message_id: i64,
}
impl RObject for GetPaymentReceipt {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getPaymentReceipt" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetPaymentReceipt {}
impl GetPaymentReceipt {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetPaymentReceiptBuilder {
let mut inner = GetPaymentReceipt::default();
inner.td_name = "getPaymentReceipt".to_string();
RTDGetPaymentReceiptBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn message_id(&self) -> i64 { self.message_id }
}
#[doc(hidden)]
pub struct RTDGetPaymentReceiptBuilder {
inner: GetPaymentReceipt
}
impl RTDGetPaymentReceiptBuilder {
pub fn build(&self) -> GetPaymentReceipt { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn message_id(&mut self, message_id: i64) -> &mut Self {
self.inner.message_id = message_id;
self
}
}
impl AsRef<GetPaymentReceipt> for GetPaymentReceipt {
fn as_ref(&self) -> &GetPaymentReceipt { self }
}
impl AsRef<GetPaymentReceipt> for RTDGetPaymentReceiptBuilder {
fn as_ref(&self) -> &GetPaymentReceipt { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetSavedOrderInfo {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetSavedOrderInfo {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getSavedOrderInfo" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetSavedOrderInfo {}
impl GetSavedOrderInfo {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetSavedOrderInfoBuilder {
let mut inner = GetSavedOrderInfo::default();
inner.td_name = "getSavedOrderInfo".to_string();
RTDGetSavedOrderInfoBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetSavedOrderInfoBuilder {
inner: GetSavedOrderInfo
}
impl RTDGetSavedOrderInfoBuilder {
pub fn build(&self) -> GetSavedOrderInfo { self.inner.clone() }
}
impl AsRef<GetSavedOrderInfo> for GetSavedOrderInfo {
fn as_ref(&self) -> &GetSavedOrderInfo { self }
}
impl AsRef<GetSavedOrderInfo> for RTDGetSavedOrderInfoBuilder {
fn as_ref(&self) -> &GetSavedOrderInfo { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteSavedOrderInfo {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for DeleteSavedOrderInfo {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteSavedOrderInfo" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteSavedOrderInfo {}
impl DeleteSavedOrderInfo {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteSavedOrderInfoBuilder {
let mut inner = DeleteSavedOrderInfo::default();
inner.td_name = "deleteSavedOrderInfo".to_string();
RTDDeleteSavedOrderInfoBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDDeleteSavedOrderInfoBuilder {
inner: DeleteSavedOrderInfo
}
impl RTDDeleteSavedOrderInfoBuilder {
pub fn build(&self) -> DeleteSavedOrderInfo { self.inner.clone() }
}
impl AsRef<DeleteSavedOrderInfo> for DeleteSavedOrderInfo {
fn as_ref(&self) -> &DeleteSavedOrderInfo { self }
}
impl AsRef<DeleteSavedOrderInfo> for RTDDeleteSavedOrderInfoBuilder {
fn as_ref(&self) -> &DeleteSavedOrderInfo { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteSavedCredentials {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for DeleteSavedCredentials {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteSavedCredentials" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteSavedCredentials {}
impl DeleteSavedCredentials {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteSavedCredentialsBuilder {
let mut inner = DeleteSavedCredentials::default();
inner.td_name = "deleteSavedCredentials".to_string();
RTDDeleteSavedCredentialsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDDeleteSavedCredentialsBuilder {
inner: DeleteSavedCredentials
}
impl RTDDeleteSavedCredentialsBuilder {
pub fn build(&self) -> DeleteSavedCredentials { self.inner.clone() }
}
impl AsRef<DeleteSavedCredentials> for DeleteSavedCredentials {
fn as_ref(&self) -> &DeleteSavedCredentials { self }
}
impl AsRef<DeleteSavedCredentials> for RTDDeleteSavedCredentialsBuilder {
fn as_ref(&self) -> &DeleteSavedCredentials { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetSupportUser {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetSupportUser {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getSupportUser" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetSupportUser {}
impl GetSupportUser {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetSupportUserBuilder {
let mut inner = GetSupportUser::default();
inner.td_name = "getSupportUser".to_string();
RTDGetSupportUserBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetSupportUserBuilder {
inner: GetSupportUser
}
impl RTDGetSupportUserBuilder {
pub fn build(&self) -> GetSupportUser { self.inner.clone() }
}
impl AsRef<GetSupportUser> for GetSupportUser {
fn as_ref(&self) -> &GetSupportUser { self }
}
impl AsRef<GetSupportUser> for RTDGetSupportUserBuilder {
fn as_ref(&self) -> &GetSupportUser { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetWallpapers {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetWallpapers {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getWallpapers" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetWallpapers {}
impl GetWallpapers {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetWallpapersBuilder {
let mut inner = GetWallpapers::default();
inner.td_name = "getWallpapers".to_string();
RTDGetWallpapersBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetWallpapersBuilder {
inner: GetWallpapers
}
impl RTDGetWallpapersBuilder {
pub fn build(&self) -> GetWallpapers { self.inner.clone() }
}
impl AsRef<GetWallpapers> for GetWallpapers {
fn as_ref(&self) -> &GetWallpapers { self }
}
impl AsRef<GetWallpapers> for RTDGetWallpapersBuilder {
fn as_ref(&self) -> &GetWallpapers { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetLocalizationTargetInfo {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
only_local: bool,
}
impl RObject for GetLocalizationTargetInfo {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getLocalizationTargetInfo" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetLocalizationTargetInfo {}
impl GetLocalizationTargetInfo {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetLocalizationTargetInfoBuilder {
let mut inner = GetLocalizationTargetInfo::default();
inner.td_name = "getLocalizationTargetInfo".to_string();
RTDGetLocalizationTargetInfoBuilder { inner }
}
pub fn only_local(&self) -> bool { self.only_local }
}
#[doc(hidden)]
pub struct RTDGetLocalizationTargetInfoBuilder {
inner: GetLocalizationTargetInfo
}
impl RTDGetLocalizationTargetInfoBuilder {
pub fn build(&self) -> GetLocalizationTargetInfo { self.inner.clone() }
pub fn only_local(&mut self, only_local: bool) -> &mut Self {
self.inner.only_local = only_local;
self
}
}
impl AsRef<GetLocalizationTargetInfo> for GetLocalizationTargetInfo {
fn as_ref(&self) -> &GetLocalizationTargetInfo { self }
}
impl AsRef<GetLocalizationTargetInfo> for RTDGetLocalizationTargetInfoBuilder {
fn as_ref(&self) -> &GetLocalizationTargetInfo { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetLanguagePackStrings {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
language_pack_id: String,
keys: Vec<String>,
}
impl RObject for GetLanguagePackStrings {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getLanguagePackStrings" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetLanguagePackStrings {}
impl GetLanguagePackStrings {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetLanguagePackStringsBuilder {
let mut inner = GetLanguagePackStrings::default();
inner.td_name = "getLanguagePackStrings".to_string();
RTDGetLanguagePackStringsBuilder { inner }
}
pub fn language_pack_id(&self) -> &String { &self.language_pack_id }
pub fn keys(&self) -> &Vec<String> { &self.keys }
}
#[doc(hidden)]
pub struct RTDGetLanguagePackStringsBuilder {
inner: GetLanguagePackStrings
}
impl RTDGetLanguagePackStringsBuilder {
pub fn build(&self) -> GetLanguagePackStrings { self.inner.clone() }
pub fn language_pack_id<T: AsRef<str>>(&mut self, language_pack_id: T) -> &mut Self {
self.inner.language_pack_id = language_pack_id.as_ref().to_string();
self
}
pub fn keys(&mut self, keys: Vec<String>) -> &mut Self {
self.inner.keys = keys;
self
}
}
impl AsRef<GetLanguagePackStrings> for GetLanguagePackStrings {
fn as_ref(&self) -> &GetLanguagePackStrings { self }
}
impl AsRef<GetLanguagePackStrings> for RTDGetLanguagePackStringsBuilder {
fn as_ref(&self) -> &GetLanguagePackStrings { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetCustomLanguagePack {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
info: LanguagePackInfo,
strings: Vec<LanguagePackString>,
}
impl RObject for SetCustomLanguagePack {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setCustomLanguagePack" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetCustomLanguagePack {}
impl SetCustomLanguagePack {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetCustomLanguagePackBuilder {
let mut inner = SetCustomLanguagePack::default();
inner.td_name = "setCustomLanguagePack".to_string();
RTDSetCustomLanguagePackBuilder { inner }
}
pub fn info(&self) -> &LanguagePackInfo { &self.info }
pub fn strings(&self) -> &Vec<LanguagePackString> { &self.strings }
}
#[doc(hidden)]
pub struct RTDSetCustomLanguagePackBuilder {
inner: SetCustomLanguagePack
}
impl RTDSetCustomLanguagePackBuilder {
pub fn build(&self) -> SetCustomLanguagePack { self.inner.clone() }
pub fn info<T: AsRef<LanguagePackInfo>>(&mut self, info: T) -> &mut Self {
self.inner.info = info.as_ref().clone();
self
}
pub fn strings(&mut self, strings: Vec<LanguagePackString>) -> &mut Self {
self.inner.strings = strings;
self
}
}
impl AsRef<SetCustomLanguagePack> for SetCustomLanguagePack {
fn as_ref(&self) -> &SetCustomLanguagePack { self }
}
impl AsRef<SetCustomLanguagePack> for RTDSetCustomLanguagePackBuilder {
fn as_ref(&self) -> &SetCustomLanguagePack { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditCustomLanguagePackInfo {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
info: LanguagePackInfo,
}
impl RObject for EditCustomLanguagePackInfo {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editCustomLanguagePackInfo" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditCustomLanguagePackInfo {}
impl EditCustomLanguagePackInfo {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditCustomLanguagePackInfoBuilder {
let mut inner = EditCustomLanguagePackInfo::default();
inner.td_name = "editCustomLanguagePackInfo".to_string();
RTDEditCustomLanguagePackInfoBuilder { inner }
}
pub fn info(&self) -> &LanguagePackInfo { &self.info }
}
#[doc(hidden)]
pub struct RTDEditCustomLanguagePackInfoBuilder {
inner: EditCustomLanguagePackInfo
}
impl RTDEditCustomLanguagePackInfoBuilder {
pub fn build(&self) -> EditCustomLanguagePackInfo { self.inner.clone() }
pub fn info<T: AsRef<LanguagePackInfo>>(&mut self, info: T) -> &mut Self {
self.inner.info = info.as_ref().clone();
self
}
}
impl AsRef<EditCustomLanguagePackInfo> for EditCustomLanguagePackInfo {
fn as_ref(&self) -> &EditCustomLanguagePackInfo { self }
}
impl AsRef<EditCustomLanguagePackInfo> for RTDEditCustomLanguagePackInfoBuilder {
fn as_ref(&self) -> &EditCustomLanguagePackInfo { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetCustomLanguagePackString {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
language_pack_id: String,
new_string: LanguagePackString,
}
impl RObject for SetCustomLanguagePackString {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setCustomLanguagePackString" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetCustomLanguagePackString {}
impl SetCustomLanguagePackString {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetCustomLanguagePackStringBuilder {
let mut inner = SetCustomLanguagePackString::default();
inner.td_name = "setCustomLanguagePackString".to_string();
RTDSetCustomLanguagePackStringBuilder { inner }
}
pub fn language_pack_id(&self) -> &String { &self.language_pack_id }
pub fn new_string(&self) -> &LanguagePackString { &self.new_string }
}
#[doc(hidden)]
pub struct RTDSetCustomLanguagePackStringBuilder {
inner: SetCustomLanguagePackString
}
impl RTDSetCustomLanguagePackStringBuilder {
pub fn build(&self) -> SetCustomLanguagePackString { self.inner.clone() }
pub fn language_pack_id<T: AsRef<str>>(&mut self, language_pack_id: T) -> &mut Self {
self.inner.language_pack_id = language_pack_id.as_ref().to_string();
self
}
pub fn new_string<T: AsRef<LanguagePackString>>(&mut self, new_string: T) -> &mut Self {
self.inner.new_string = new_string.as_ref().clone();
self
}
}
impl AsRef<SetCustomLanguagePackString> for SetCustomLanguagePackString {
fn as_ref(&self) -> &SetCustomLanguagePackString { self }
}
impl AsRef<SetCustomLanguagePackString> for RTDSetCustomLanguagePackStringBuilder {
fn as_ref(&self) -> &SetCustomLanguagePackString { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteLanguagePack {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
language_pack_id: String,
}
impl RObject for DeleteLanguagePack {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteLanguagePack" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteLanguagePack {}
impl DeleteLanguagePack {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteLanguagePackBuilder {
let mut inner = DeleteLanguagePack::default();
inner.td_name = "deleteLanguagePack".to_string();
RTDDeleteLanguagePackBuilder { inner }
}
pub fn language_pack_id(&self) -> &String { &self.language_pack_id }
}
#[doc(hidden)]
pub struct RTDDeleteLanguagePackBuilder {
inner: DeleteLanguagePack
}
impl RTDDeleteLanguagePackBuilder {
pub fn build(&self) -> DeleteLanguagePack { self.inner.clone() }
pub fn language_pack_id<T: AsRef<str>>(&mut self, language_pack_id: T) -> &mut Self {
self.inner.language_pack_id = language_pack_id.as_ref().to_string();
self
}
}
impl AsRef<DeleteLanguagePack> for DeleteLanguagePack {
fn as_ref(&self) -> &DeleteLanguagePack { self }
}
impl AsRef<DeleteLanguagePack> for RTDDeleteLanguagePackBuilder {
fn as_ref(&self) -> &DeleteLanguagePack { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RegisterDevice {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
device_token: DeviceToken,
other_user_ids: Vec<i64>,
}
impl RObject for RegisterDevice {
#[doc(hidden)] fn td_name(&self) -> &'static str { "registerDevice" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RegisterDevice {}
impl RegisterDevice {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRegisterDeviceBuilder {
let mut inner = RegisterDevice::default();
inner.td_name = "registerDevice".to_string();
RTDRegisterDeviceBuilder { inner }
}
pub fn device_token(&self) -> &DeviceToken { &self.device_token }
pub fn other_user_ids(&self) -> &Vec<i64> { &self.other_user_ids }
}
#[doc(hidden)]
pub struct RTDRegisterDeviceBuilder {
inner: RegisterDevice
}
impl RTDRegisterDeviceBuilder {
pub fn build(&self) -> RegisterDevice { self.inner.clone() }
pub fn device_token<T: AsRef<DeviceToken>>(&mut self, device_token: T) -> &mut Self {
self.inner.device_token = device_token.as_ref().clone();
self
}
pub fn other_user_ids(&mut self, other_user_ids: Vec<i64>) -> &mut Self {
self.inner.other_user_ids = other_user_ids;
self
}
}
impl AsRef<RegisterDevice> for RegisterDevice {
fn as_ref(&self) -> &RegisterDevice { self }
}
impl AsRef<RegisterDevice> for RTDRegisterDeviceBuilder {
fn as_ref(&self) -> &RegisterDevice { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetRecentlyVisitedTMeUrls {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
referrer: String,
}
impl RObject for GetRecentlyVisitedTMeUrls {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getRecentlyVisitedTMeUrls" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetRecentlyVisitedTMeUrls {}
impl GetRecentlyVisitedTMeUrls {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetRecentlyVisitedTMeUrlsBuilder {
let mut inner = GetRecentlyVisitedTMeUrls::default();
inner.td_name = "getRecentlyVisitedTMeUrls".to_string();
RTDGetRecentlyVisitedTMeUrlsBuilder { inner }
}
pub fn referrer(&self) -> &String { &self.referrer }
}
#[doc(hidden)]
pub struct RTDGetRecentlyVisitedTMeUrlsBuilder {
inner: GetRecentlyVisitedTMeUrls
}
impl RTDGetRecentlyVisitedTMeUrlsBuilder {
pub fn build(&self) -> GetRecentlyVisitedTMeUrls { self.inner.clone() }
pub fn referrer<T: AsRef<str>>(&mut self, referrer: T) -> &mut Self {
self.inner.referrer = referrer.as_ref().to_string();
self
}
}
impl AsRef<GetRecentlyVisitedTMeUrls> for GetRecentlyVisitedTMeUrls {
fn as_ref(&self) -> &GetRecentlyVisitedTMeUrls { self }
}
impl AsRef<GetRecentlyVisitedTMeUrls> for RTDGetRecentlyVisitedTMeUrlsBuilder {
fn as_ref(&self) -> &GetRecentlyVisitedTMeUrls { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetUserPrivacySettingRules {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
setting: UserPrivacySetting,
rules: UserPrivacySettingRules,
}
impl RObject for SetUserPrivacySettingRules {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setUserPrivacySettingRules" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetUserPrivacySettingRules {}
impl SetUserPrivacySettingRules {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetUserPrivacySettingRulesBuilder {
let mut inner = SetUserPrivacySettingRules::default();
inner.td_name = "setUserPrivacySettingRules".to_string();
RTDSetUserPrivacySettingRulesBuilder { inner }
}
pub fn setting(&self) -> &UserPrivacySetting { &self.setting }
pub fn rules(&self) -> &UserPrivacySettingRules { &self.rules }
}
#[doc(hidden)]
pub struct RTDSetUserPrivacySettingRulesBuilder {
inner: SetUserPrivacySettingRules
}
impl RTDSetUserPrivacySettingRulesBuilder {
pub fn build(&self) -> SetUserPrivacySettingRules { self.inner.clone() }
pub fn setting<T: AsRef<UserPrivacySetting>>(&mut self, setting: T) -> &mut Self {
self.inner.setting = setting.as_ref().clone();
self
}
pub fn rules<T: AsRef<UserPrivacySettingRules>>(&mut self, rules: T) -> &mut Self {
self.inner.rules = rules.as_ref().clone();
self
}
}
impl AsRef<SetUserPrivacySettingRules> for SetUserPrivacySettingRules {
fn as_ref(&self) -> &SetUserPrivacySettingRules { self }
}
impl AsRef<SetUserPrivacySettingRules> for RTDSetUserPrivacySettingRulesBuilder {
fn as_ref(&self) -> &SetUserPrivacySettingRules { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetUserPrivacySettingRules {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
setting: UserPrivacySetting,
}
impl RObject for GetUserPrivacySettingRules {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getUserPrivacySettingRules" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetUserPrivacySettingRules {}
impl GetUserPrivacySettingRules {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetUserPrivacySettingRulesBuilder {
let mut inner = GetUserPrivacySettingRules::default();
inner.td_name = "getUserPrivacySettingRules".to_string();
RTDGetUserPrivacySettingRulesBuilder { inner }
}
pub fn setting(&self) -> &UserPrivacySetting { &self.setting }
}
#[doc(hidden)]
pub struct RTDGetUserPrivacySettingRulesBuilder {
inner: GetUserPrivacySettingRules
}
impl RTDGetUserPrivacySettingRulesBuilder {
pub fn build(&self) -> GetUserPrivacySettingRules { self.inner.clone() }
pub fn setting<T: AsRef<UserPrivacySetting>>(&mut self, setting: T) -> &mut Self {
self.inner.setting = setting.as_ref().clone();
self
}
}
impl AsRef<GetUserPrivacySettingRules> for GetUserPrivacySettingRules {
fn as_ref(&self) -> &GetUserPrivacySettingRules { self }
}
impl AsRef<GetUserPrivacySettingRules> for RTDGetUserPrivacySettingRulesBuilder {
fn as_ref(&self) -> &GetUserPrivacySettingRules { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetOption {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
name: String,
}
impl RObject for GetOption {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getOption" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl TDOptionValue for GetOption {}
impl RFunction for GetOption {}
impl GetOption {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetOptionBuilder {
let mut inner = GetOption::default();
inner.td_name = "getOption".to_string();
RTDGetOptionBuilder { inner }
}
pub fn name(&self) -> &String { &self.name }
}
#[doc(hidden)]
pub struct RTDGetOptionBuilder {
inner: GetOption
}
impl RTDGetOptionBuilder {
pub fn build(&self) -> GetOption { self.inner.clone() }
pub fn name<T: AsRef<str>>(&mut self, name: T) -> &mut Self {
self.inner.name = name.as_ref().to_string();
self
}
}
impl AsRef<GetOption> for GetOption {
fn as_ref(&self) -> &GetOption { self }
}
impl AsRef<GetOption> for RTDGetOptionBuilder {
fn as_ref(&self) -> &GetOption { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetOption {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
name: String,
value: OptionValue,
}
impl RObject for SetOption {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setOption" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetOption {}
impl SetOption {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetOptionBuilder {
let mut inner = SetOption::default();
inner.td_name = "setOption".to_string();
RTDSetOptionBuilder { inner }
}
pub fn name(&self) -> &String { &self.name }
pub fn value(&self) -> &OptionValue { &self.value }
}
#[doc(hidden)]
pub struct RTDSetOptionBuilder {
inner: SetOption
}
impl RTDSetOptionBuilder {
pub fn build(&self) -> SetOption { self.inner.clone() }
pub fn name<T: AsRef<str>>(&mut self, name: T) -> &mut Self {
self.inner.name = name.as_ref().to_string();
self
}
pub fn value<T: AsRef<OptionValue>>(&mut self, value: T) -> &mut Self {
self.inner.value = value.as_ref().clone();
self
}
}
impl AsRef<SetOption> for SetOption {
fn as_ref(&self) -> &SetOption { self }
}
impl AsRef<SetOption> for RTDSetOptionBuilder {
fn as_ref(&self) -> &SetOption { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetAccountTtl {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
ttl: AccountTtl,
}
impl RObject for SetAccountTtl {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setAccountTtl" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetAccountTtl {}
impl SetAccountTtl {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetAccountTtlBuilder {
let mut inner = SetAccountTtl::default();
inner.td_name = "setAccountTtl".to_string();
RTDSetAccountTtlBuilder { inner }
}
pub fn ttl(&self) -> &AccountTtl { &self.ttl }
}
#[doc(hidden)]
pub struct RTDSetAccountTtlBuilder {
inner: SetAccountTtl
}
impl RTDSetAccountTtlBuilder {
pub fn build(&self) -> SetAccountTtl { self.inner.clone() }
pub fn ttl<T: AsRef<AccountTtl>>(&mut self, ttl: T) -> &mut Self {
self.inner.ttl = ttl.as_ref().clone();
self
}
}
impl AsRef<SetAccountTtl> for SetAccountTtl {
fn as_ref(&self) -> &SetAccountTtl { self }
}
impl AsRef<SetAccountTtl> for RTDSetAccountTtlBuilder {
fn as_ref(&self) -> &SetAccountTtl { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetAccountTtl {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetAccountTtl {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getAccountTtl" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetAccountTtl {}
impl GetAccountTtl {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetAccountTtlBuilder {
let mut inner = GetAccountTtl::default();
inner.td_name = "getAccountTtl".to_string();
RTDGetAccountTtlBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetAccountTtlBuilder {
inner: GetAccountTtl
}
impl RTDGetAccountTtlBuilder {
pub fn build(&self) -> GetAccountTtl { self.inner.clone() }
}
impl AsRef<GetAccountTtl> for GetAccountTtl {
fn as_ref(&self) -> &GetAccountTtl { self }
}
impl AsRef<GetAccountTtl> for RTDGetAccountTtlBuilder {
fn as_ref(&self) -> &GetAccountTtl { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteAccount {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
reason: String,
}
impl RObject for DeleteAccount {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deleteAccount" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeleteAccount {}
impl DeleteAccount {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeleteAccountBuilder {
let mut inner = DeleteAccount::default();
inner.td_name = "deleteAccount".to_string();
RTDDeleteAccountBuilder { inner }
}
pub fn reason(&self) -> &String { &self.reason }
}
#[doc(hidden)]
pub struct RTDDeleteAccountBuilder {
inner: DeleteAccount
}
impl RTDDeleteAccountBuilder {
pub fn build(&self) -> DeleteAccount { self.inner.clone() }
pub fn reason<T: AsRef<str>>(&mut self, reason: T) -> &mut Self {
self.inner.reason = reason.as_ref().to_string();
self
}
}
impl AsRef<DeleteAccount> for DeleteAccount {
fn as_ref(&self) -> &DeleteAccount { self }
}
impl AsRef<DeleteAccount> for RTDDeleteAccountBuilder {
fn as_ref(&self) -> &DeleteAccount { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetChatReportSpamState {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
}
impl RObject for GetChatReportSpamState {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getChatReportSpamState" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetChatReportSpamState {}
impl GetChatReportSpamState {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetChatReportSpamStateBuilder {
let mut inner = GetChatReportSpamState::default();
inner.td_name = "getChatReportSpamState".to_string();
RTDGetChatReportSpamStateBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDGetChatReportSpamStateBuilder {
inner: GetChatReportSpamState
}
impl RTDGetChatReportSpamStateBuilder {
pub fn build(&self) -> GetChatReportSpamState { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<GetChatReportSpamState> for GetChatReportSpamState {
fn as_ref(&self) -> &GetChatReportSpamState { self }
}
impl AsRef<GetChatReportSpamState> for RTDGetChatReportSpamStateBuilder {
fn as_ref(&self) -> &GetChatReportSpamState { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ChangeChatReportSpamState {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
is_spam_chat: bool,
}
impl RObject for ChangeChatReportSpamState {
#[doc(hidden)] fn td_name(&self) -> &'static str { "changeChatReportSpamState" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ChangeChatReportSpamState {}
impl ChangeChatReportSpamState {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDChangeChatReportSpamStateBuilder {
let mut inner = ChangeChatReportSpamState::default();
inner.td_name = "changeChatReportSpamState".to_string();
RTDChangeChatReportSpamStateBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn is_spam_chat(&self) -> bool { self.is_spam_chat }
}
#[doc(hidden)]
pub struct RTDChangeChatReportSpamStateBuilder {
inner: ChangeChatReportSpamState
}
impl RTDChangeChatReportSpamStateBuilder {
pub fn build(&self) -> ChangeChatReportSpamState { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn is_spam_chat(&mut self, is_spam_chat: bool) -> &mut Self {
self.inner.is_spam_chat = is_spam_chat;
self
}
}
impl AsRef<ChangeChatReportSpamState> for ChangeChatReportSpamState {
fn as_ref(&self) -> &ChangeChatReportSpamState { self }
}
impl AsRef<ChangeChatReportSpamState> for RTDChangeChatReportSpamStateBuilder {
fn as_ref(&self) -> &ChangeChatReportSpamState { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ReportChat {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_id: i64,
reason: ChatReportReason,
message_ids: Vec<i64>,
}
impl RObject for ReportChat {
#[doc(hidden)] fn td_name(&self) -> &'static str { "reportChat" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ReportChat {}
impl ReportChat {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDReportChatBuilder {
let mut inner = ReportChat::default();
inner.td_name = "reportChat".to_string();
RTDReportChatBuilder { inner }
}
pub fn chat_id(&self) -> i64 { self.chat_id }
pub fn reason(&self) -> &ChatReportReason { &self.reason }
pub fn message_ids(&self) -> &Vec<i64> { &self.message_ids }
}
#[doc(hidden)]
pub struct RTDReportChatBuilder {
inner: ReportChat
}
impl RTDReportChatBuilder {
pub fn build(&self) -> ReportChat { self.inner.clone() }
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
pub fn reason<T: AsRef<ChatReportReason>>(&mut self, reason: T) -> &mut Self {
self.inner.reason = reason.as_ref().clone();
self
}
pub fn message_ids(&mut self, message_ids: Vec<i64>) -> &mut Self {
self.inner.message_ids = message_ids;
self
}
}
impl AsRef<ReportChat> for ReportChat {
fn as_ref(&self) -> &ReportChat { self }
}
impl AsRef<ReportChat> for RTDReportChatBuilder {
fn as_ref(&self) -> &ReportChat { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetStorageStatistics {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
chat_limit: i64,
}
impl RObject for GetStorageStatistics {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getStorageStatistics" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetStorageStatistics {}
impl GetStorageStatistics {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetStorageStatisticsBuilder {
let mut inner = GetStorageStatistics::default();
inner.td_name = "getStorageStatistics".to_string();
RTDGetStorageStatisticsBuilder { inner }
}
pub fn chat_limit(&self) -> i64 { self.chat_limit }
}
#[doc(hidden)]
pub struct RTDGetStorageStatisticsBuilder {
inner: GetStorageStatistics
}
impl RTDGetStorageStatisticsBuilder {
pub fn build(&self) -> GetStorageStatistics { self.inner.clone() }
pub fn chat_limit(&mut self, chat_limit: i64) -> &mut Self {
self.inner.chat_limit = chat_limit;
self
}
}
impl AsRef<GetStorageStatistics> for GetStorageStatistics {
fn as_ref(&self) -> &GetStorageStatistics { self }
}
impl AsRef<GetStorageStatistics> for RTDGetStorageStatisticsBuilder {
fn as_ref(&self) -> &GetStorageStatistics { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetStorageStatisticsFast {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetStorageStatisticsFast {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getStorageStatisticsFast" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetStorageStatisticsFast {}
impl GetStorageStatisticsFast {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetStorageStatisticsFastBuilder {
let mut inner = GetStorageStatisticsFast::default();
inner.td_name = "getStorageStatisticsFast".to_string();
RTDGetStorageStatisticsFastBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetStorageStatisticsFastBuilder {
inner: GetStorageStatisticsFast
}
impl RTDGetStorageStatisticsFastBuilder {
pub fn build(&self) -> GetStorageStatisticsFast { self.inner.clone() }
}
impl AsRef<GetStorageStatisticsFast> for GetStorageStatisticsFast {
fn as_ref(&self) -> &GetStorageStatisticsFast { self }
}
impl AsRef<GetStorageStatisticsFast> for RTDGetStorageStatisticsFastBuilder {
fn as_ref(&self) -> &GetStorageStatisticsFast { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct OptimizeStorage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
size: i64,
ttl: i64,
count: i64,
immunity_delay: i64,
file_types: Vec<FileType>,
chat_ids: Vec<i64>,
exclude_chat_ids: Vec<i64>,
chat_limit: i64,
}
impl RObject for OptimizeStorage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "optimizeStorage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for OptimizeStorage {}
impl OptimizeStorage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDOptimizeStorageBuilder {
let mut inner = OptimizeStorage::default();
inner.td_name = "optimizeStorage".to_string();
RTDOptimizeStorageBuilder { inner }
}
pub fn size(&self) -> i64 { self.size }
pub fn ttl(&self) -> i64 { self.ttl }
pub fn count(&self) -> i64 { self.count }
pub fn immunity_delay(&self) -> i64 { self.immunity_delay }
pub fn file_types(&self) -> &Vec<FileType> { &self.file_types }
pub fn chat_ids(&self) -> &Vec<i64> { &self.chat_ids }
pub fn exclude_chat_ids(&self) -> &Vec<i64> { &self.exclude_chat_ids }
pub fn chat_limit(&self) -> i64 { self.chat_limit }
}
#[doc(hidden)]
pub struct RTDOptimizeStorageBuilder {
inner: OptimizeStorage
}
impl RTDOptimizeStorageBuilder {
pub fn build(&self) -> OptimizeStorage { self.inner.clone() }
pub fn size(&mut self, size: i64) -> &mut Self {
self.inner.size = size;
self
}
pub fn ttl(&mut self, ttl: i64) -> &mut Self {
self.inner.ttl = ttl;
self
}
pub fn count(&mut self, count: i64) -> &mut Self {
self.inner.count = count;
self
}
pub fn immunity_delay(&mut self, immunity_delay: i64) -> &mut Self {
self.inner.immunity_delay = immunity_delay;
self
}
pub fn file_types(&mut self, file_types: Vec<FileType>) -> &mut Self {
self.inner.file_types = file_types;
self
}
pub fn chat_ids(&mut self, chat_ids: Vec<i64>) -> &mut Self {
self.inner.chat_ids = chat_ids;
self
}
pub fn exclude_chat_ids(&mut self, exclude_chat_ids: Vec<i64>) -> &mut Self {
self.inner.exclude_chat_ids = exclude_chat_ids;
self
}
pub fn chat_limit(&mut self, chat_limit: i64) -> &mut Self {
self.inner.chat_limit = chat_limit;
self
}
}
impl AsRef<OptimizeStorage> for OptimizeStorage {
fn as_ref(&self) -> &OptimizeStorage { self }
}
impl AsRef<OptimizeStorage> for RTDOptimizeStorageBuilder {
fn as_ref(&self) -> &OptimizeStorage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetNetworkType {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
#[serde(rename(serialize = "type", deserialize = "type"))] type_: NetworkType,
}
impl RObject for SetNetworkType {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setNetworkType" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetNetworkType {}
impl SetNetworkType {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetNetworkTypeBuilder {
let mut inner = SetNetworkType::default();
inner.td_name = "setNetworkType".to_string();
RTDSetNetworkTypeBuilder { inner }
}
pub fn type_(&self) -> &NetworkType { &self.type_ }
}
#[doc(hidden)]
pub struct RTDSetNetworkTypeBuilder {
inner: SetNetworkType
}
impl RTDSetNetworkTypeBuilder {
pub fn build(&self) -> SetNetworkType { self.inner.clone() }
pub fn type_<T: AsRef<NetworkType>>(&mut self, type_: T) -> &mut Self {
self.inner.type_ = type_.as_ref().clone();
self
}
}
impl AsRef<SetNetworkType> for SetNetworkType {
fn as_ref(&self) -> &SetNetworkType { self }
}
impl AsRef<SetNetworkType> for RTDSetNetworkTypeBuilder {
fn as_ref(&self) -> &SetNetworkType { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetNetworkStatistics {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
only_current: bool,
}
impl RObject for GetNetworkStatistics {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getNetworkStatistics" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetNetworkStatistics {}
impl GetNetworkStatistics {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetNetworkStatisticsBuilder {
let mut inner = GetNetworkStatistics::default();
inner.td_name = "getNetworkStatistics".to_string();
RTDGetNetworkStatisticsBuilder { inner }
}
pub fn only_current(&self) -> bool { self.only_current }
}
#[doc(hidden)]
pub struct RTDGetNetworkStatisticsBuilder {
inner: GetNetworkStatistics
}
impl RTDGetNetworkStatisticsBuilder {
pub fn build(&self) -> GetNetworkStatistics { self.inner.clone() }
pub fn only_current(&mut self, only_current: bool) -> &mut Self {
self.inner.only_current = only_current;
self
}
}
impl AsRef<GetNetworkStatistics> for GetNetworkStatistics {
fn as_ref(&self) -> &GetNetworkStatistics { self }
}
impl AsRef<GetNetworkStatistics> for RTDGetNetworkStatisticsBuilder {
fn as_ref(&self) -> &GetNetworkStatistics { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddNetworkStatistics {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
entry: NetworkStatisticsEntry,
}
impl RObject for AddNetworkStatistics {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addNetworkStatistics" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddNetworkStatistics {}
impl AddNetworkStatistics {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddNetworkStatisticsBuilder {
let mut inner = AddNetworkStatistics::default();
inner.td_name = "addNetworkStatistics".to_string();
RTDAddNetworkStatisticsBuilder { inner }
}
pub fn entry(&self) -> &NetworkStatisticsEntry { &self.entry }
}
#[doc(hidden)]
pub struct RTDAddNetworkStatisticsBuilder {
inner: AddNetworkStatistics
}
impl RTDAddNetworkStatisticsBuilder {
pub fn build(&self) -> AddNetworkStatistics { self.inner.clone() }
pub fn entry<T: AsRef<NetworkStatisticsEntry>>(&mut self, entry: T) -> &mut Self {
self.inner.entry = entry.as_ref().clone();
self
}
}
impl AsRef<AddNetworkStatistics> for AddNetworkStatistics {
fn as_ref(&self) -> &AddNetworkStatistics { self }
}
impl AsRef<AddNetworkStatistics> for RTDAddNetworkStatisticsBuilder {
fn as_ref(&self) -> &AddNetworkStatistics { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ResetNetworkStatistics {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for ResetNetworkStatistics {
#[doc(hidden)] fn td_name(&self) -> &'static str { "resetNetworkStatistics" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ResetNetworkStatistics {}
impl ResetNetworkStatistics {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDResetNetworkStatisticsBuilder {
let mut inner = ResetNetworkStatistics::default();
inner.td_name = "resetNetworkStatistics".to_string();
RTDResetNetworkStatisticsBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDResetNetworkStatisticsBuilder {
inner: ResetNetworkStatistics
}
impl RTDResetNetworkStatisticsBuilder {
pub fn build(&self) -> ResetNetworkStatistics { self.inner.clone() }
}
impl AsRef<ResetNetworkStatistics> for ResetNetworkStatistics {
fn as_ref(&self) -> &ResetNetworkStatistics { self }
}
impl AsRef<ResetNetworkStatistics> for RTDResetNetworkStatisticsBuilder {
fn as_ref(&self) -> &ResetNetworkStatistics { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetPassportElement {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
#[serde(rename(serialize = "type", deserialize = "type"))] type_: PassportElementType,
password: String,
}
impl RObject for GetPassportElement {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getPassportElement" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl TDPassportElement for GetPassportElement {}
impl RFunction for GetPassportElement {}
impl GetPassportElement {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetPassportElementBuilder {
let mut inner = GetPassportElement::default();
inner.td_name = "getPassportElement".to_string();
RTDGetPassportElementBuilder { inner }
}
pub fn type_(&self) -> &PassportElementType { &self.type_ }
pub fn password(&self) -> &String { &self.password }
}
#[doc(hidden)]
pub struct RTDGetPassportElementBuilder {
inner: GetPassportElement
}
impl RTDGetPassportElementBuilder {
pub fn build(&self) -> GetPassportElement { self.inner.clone() }
pub fn type_<T: AsRef<PassportElementType>>(&mut self, type_: T) -> &mut Self {
self.inner.type_ = type_.as_ref().clone();
self
}
pub fn password<T: AsRef<str>>(&mut self, password: T) -> &mut Self {
self.inner.password = password.as_ref().to_string();
self
}
}
impl AsRef<GetPassportElement> for GetPassportElement {
fn as_ref(&self) -> &GetPassportElement { self }
}
impl AsRef<GetPassportElement> for RTDGetPassportElementBuilder {
fn as_ref(&self) -> &GetPassportElement { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetAllPassportElements {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
password: String,
}
impl RObject for GetAllPassportElements {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getAllPassportElements" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetAllPassportElements {}
impl GetAllPassportElements {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetAllPassportElementsBuilder {
let mut inner = GetAllPassportElements::default();
inner.td_name = "getAllPassportElements".to_string();
RTDGetAllPassportElementsBuilder { inner }
}
pub fn password(&self) -> &String { &self.password }
}
#[doc(hidden)]
pub struct RTDGetAllPassportElementsBuilder {
inner: GetAllPassportElements
}
impl RTDGetAllPassportElementsBuilder {
pub fn build(&self) -> GetAllPassportElements { self.inner.clone() }
pub fn password<T: AsRef<str>>(&mut self, password: T) -> &mut Self {
self.inner.password = password.as_ref().to_string();
self
}
}
impl AsRef<GetAllPassportElements> for GetAllPassportElements {
fn as_ref(&self) -> &GetAllPassportElements { self }
}
impl AsRef<GetAllPassportElements> for RTDGetAllPassportElementsBuilder {
fn as_ref(&self) -> &GetAllPassportElements { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetPassportElement {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
element: InputPassportElement,
password: String,
}
impl RObject for SetPassportElement {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setPassportElement" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl TDPassportElement for SetPassportElement {}
impl RFunction for SetPassportElement {}
impl SetPassportElement {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetPassportElementBuilder {
let mut inner = SetPassportElement::default();
inner.td_name = "setPassportElement".to_string();
RTDSetPassportElementBuilder { inner }
}
pub fn element(&self) -> &InputPassportElement { &self.element }
pub fn password(&self) -> &String { &self.password }
}
#[doc(hidden)]
pub struct RTDSetPassportElementBuilder {
inner: SetPassportElement
}
impl RTDSetPassportElementBuilder {
pub fn build(&self) -> SetPassportElement { self.inner.clone() }
pub fn element<T: AsRef<InputPassportElement>>(&mut self, element: T) -> &mut Self {
self.inner.element = element.as_ref().clone();
self
}
pub fn password<T: AsRef<str>>(&mut self, password: T) -> &mut Self {
self.inner.password = password.as_ref().to_string();
self
}
}
impl AsRef<SetPassportElement> for SetPassportElement {
fn as_ref(&self) -> &SetPassportElement { self }
}
impl AsRef<SetPassportElement> for RTDSetPassportElementBuilder {
fn as_ref(&self) -> &SetPassportElement { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeletePassportElement {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
#[serde(rename(serialize = "type", deserialize = "type"))] type_: PassportElementType,
}
impl RObject for DeletePassportElement {
#[doc(hidden)] fn td_name(&self) -> &'static str { "deletePassportElement" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DeletePassportElement {}
impl DeletePassportElement {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDeletePassportElementBuilder {
let mut inner = DeletePassportElement::default();
inner.td_name = "deletePassportElement".to_string();
RTDDeletePassportElementBuilder { inner }
}
pub fn type_(&self) -> &PassportElementType { &self.type_ }
}
#[doc(hidden)]
pub struct RTDDeletePassportElementBuilder {
inner: DeletePassportElement
}
impl RTDDeletePassportElementBuilder {
pub fn build(&self) -> DeletePassportElement { self.inner.clone() }
pub fn type_<T: AsRef<PassportElementType>>(&mut self, type_: T) -> &mut Self {
self.inner.type_ = type_.as_ref().clone();
self
}
}
impl AsRef<DeletePassportElement> for DeletePassportElement {
fn as_ref(&self) -> &DeletePassportElement { self }
}
impl AsRef<DeletePassportElement> for RTDDeletePassportElementBuilder {
fn as_ref(&self) -> &DeletePassportElement { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetPassportElementErrors {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
errors: Vec<InputPassportElementError>,
}
impl RObject for SetPassportElementErrors {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setPassportElementErrors" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetPassportElementErrors {}
impl SetPassportElementErrors {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetPassportElementErrorsBuilder {
let mut inner = SetPassportElementErrors::default();
inner.td_name = "setPassportElementErrors".to_string();
RTDSetPassportElementErrorsBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
pub fn errors(&self) -> &Vec<InputPassportElementError> { &self.errors }
}
#[doc(hidden)]
pub struct RTDSetPassportElementErrorsBuilder {
inner: SetPassportElementErrors
}
impl RTDSetPassportElementErrorsBuilder {
pub fn build(&self) -> SetPassportElementErrors { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn errors(&mut self, errors: Vec<InputPassportElementError>) -> &mut Self {
self.inner.errors = errors;
self
}
}
impl AsRef<SetPassportElementErrors> for SetPassportElementErrors {
fn as_ref(&self) -> &SetPassportElementErrors { self }
}
impl AsRef<SetPassportElementErrors> for RTDSetPassportElementErrorsBuilder {
fn as_ref(&self) -> &SetPassportElementErrors { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetPreferredCountryLanguage {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
country_code: String,
}
impl RObject for GetPreferredCountryLanguage {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getPreferredCountryLanguage" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetPreferredCountryLanguage {}
impl GetPreferredCountryLanguage {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetPreferredCountryLanguageBuilder {
let mut inner = GetPreferredCountryLanguage::default();
inner.td_name = "getPreferredCountryLanguage".to_string();
RTDGetPreferredCountryLanguageBuilder { inner }
}
pub fn country_code(&self) -> &String { &self.country_code }
}
#[doc(hidden)]
pub struct RTDGetPreferredCountryLanguageBuilder {
inner: GetPreferredCountryLanguage
}
impl RTDGetPreferredCountryLanguageBuilder {
pub fn build(&self) -> GetPreferredCountryLanguage { self.inner.clone() }
pub fn country_code<T: AsRef<str>>(&mut self, country_code: T) -> &mut Self {
self.inner.country_code = country_code.as_ref().to_string();
self
}
}
impl AsRef<GetPreferredCountryLanguage> for GetPreferredCountryLanguage {
fn as_ref(&self) -> &GetPreferredCountryLanguage { self }
}
impl AsRef<GetPreferredCountryLanguage> for RTDGetPreferredCountryLanguageBuilder {
fn as_ref(&self) -> &GetPreferredCountryLanguage { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendPhoneNumberVerificationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
phone_number: String,
allow_flash_call: bool,
is_current_phone_number: bool,
}
impl RObject for SendPhoneNumberVerificationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendPhoneNumberVerificationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendPhoneNumberVerificationCode {}
impl SendPhoneNumberVerificationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendPhoneNumberVerificationCodeBuilder {
let mut inner = SendPhoneNumberVerificationCode::default();
inner.td_name = "sendPhoneNumberVerificationCode".to_string();
RTDSendPhoneNumberVerificationCodeBuilder { inner }
}
pub fn phone_number(&self) -> &String { &self.phone_number }
pub fn allow_flash_call(&self) -> bool { self.allow_flash_call }
pub fn is_current_phone_number(&self) -> bool { self.is_current_phone_number }
}
#[doc(hidden)]
pub struct RTDSendPhoneNumberVerificationCodeBuilder {
inner: SendPhoneNumberVerificationCode
}
impl RTDSendPhoneNumberVerificationCodeBuilder {
pub fn build(&self) -> SendPhoneNumberVerificationCode { self.inner.clone() }
pub fn phone_number<T: AsRef<str>>(&mut self, phone_number: T) -> &mut Self {
self.inner.phone_number = phone_number.as_ref().to_string();
self
}
pub fn allow_flash_call(&mut self, allow_flash_call: bool) -> &mut Self {
self.inner.allow_flash_call = allow_flash_call;
self
}
pub fn is_current_phone_number(&mut self, is_current_phone_number: bool) -> &mut Self {
self.inner.is_current_phone_number = is_current_phone_number;
self
}
}
impl AsRef<SendPhoneNumberVerificationCode> for SendPhoneNumberVerificationCode {
fn as_ref(&self) -> &SendPhoneNumberVerificationCode { self }
}
impl AsRef<SendPhoneNumberVerificationCode> for RTDSendPhoneNumberVerificationCodeBuilder {
fn as_ref(&self) -> &SendPhoneNumberVerificationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ResendPhoneNumberVerificationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for ResendPhoneNumberVerificationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "resendPhoneNumberVerificationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ResendPhoneNumberVerificationCode {}
impl ResendPhoneNumberVerificationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDResendPhoneNumberVerificationCodeBuilder {
let mut inner = ResendPhoneNumberVerificationCode::default();
inner.td_name = "resendPhoneNumberVerificationCode".to_string();
RTDResendPhoneNumberVerificationCodeBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDResendPhoneNumberVerificationCodeBuilder {
inner: ResendPhoneNumberVerificationCode
}
impl RTDResendPhoneNumberVerificationCodeBuilder {
pub fn build(&self) -> ResendPhoneNumberVerificationCode { self.inner.clone() }
}
impl AsRef<ResendPhoneNumberVerificationCode> for ResendPhoneNumberVerificationCode {
fn as_ref(&self) -> &ResendPhoneNumberVerificationCode { self }
}
impl AsRef<ResendPhoneNumberVerificationCode> for RTDResendPhoneNumberVerificationCodeBuilder {
fn as_ref(&self) -> &ResendPhoneNumberVerificationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckPhoneNumberVerificationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
code: String,
}
impl RObject for CheckPhoneNumberVerificationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkPhoneNumberVerificationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CheckPhoneNumberVerificationCode {}
impl CheckPhoneNumberVerificationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckPhoneNumberVerificationCodeBuilder {
let mut inner = CheckPhoneNumberVerificationCode::default();
inner.td_name = "checkPhoneNumberVerificationCode".to_string();
RTDCheckPhoneNumberVerificationCodeBuilder { inner }
}
pub fn code(&self) -> &String { &self.code }
}
#[doc(hidden)]
pub struct RTDCheckPhoneNumberVerificationCodeBuilder {
inner: CheckPhoneNumberVerificationCode
}
impl RTDCheckPhoneNumberVerificationCodeBuilder {
pub fn build(&self) -> CheckPhoneNumberVerificationCode { self.inner.clone() }
pub fn code<T: AsRef<str>>(&mut self, code: T) -> &mut Self {
self.inner.code = code.as_ref().to_string();
self
}
}
impl AsRef<CheckPhoneNumberVerificationCode> for CheckPhoneNumberVerificationCode {
fn as_ref(&self) -> &CheckPhoneNumberVerificationCode { self }
}
impl AsRef<CheckPhoneNumberVerificationCode> for RTDCheckPhoneNumberVerificationCodeBuilder {
fn as_ref(&self) -> &CheckPhoneNumberVerificationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendEmailAddressVerificationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
email_address: String,
}
impl RObject for SendEmailAddressVerificationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendEmailAddressVerificationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendEmailAddressVerificationCode {}
impl SendEmailAddressVerificationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendEmailAddressVerificationCodeBuilder {
let mut inner = SendEmailAddressVerificationCode::default();
inner.td_name = "sendEmailAddressVerificationCode".to_string();
RTDSendEmailAddressVerificationCodeBuilder { inner }
}
pub fn email_address(&self) -> &String { &self.email_address }
}
#[doc(hidden)]
pub struct RTDSendEmailAddressVerificationCodeBuilder {
inner: SendEmailAddressVerificationCode
}
impl RTDSendEmailAddressVerificationCodeBuilder {
pub fn build(&self) -> SendEmailAddressVerificationCode { self.inner.clone() }
pub fn email_address<T: AsRef<str>>(&mut self, email_address: T) -> &mut Self {
self.inner.email_address = email_address.as_ref().to_string();
self
}
}
impl AsRef<SendEmailAddressVerificationCode> for SendEmailAddressVerificationCode {
fn as_ref(&self) -> &SendEmailAddressVerificationCode { self }
}
impl AsRef<SendEmailAddressVerificationCode> for RTDSendEmailAddressVerificationCodeBuilder {
fn as_ref(&self) -> &SendEmailAddressVerificationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ResendEmailAddressVerificationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for ResendEmailAddressVerificationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "resendEmailAddressVerificationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ResendEmailAddressVerificationCode {}
impl ResendEmailAddressVerificationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDResendEmailAddressVerificationCodeBuilder {
let mut inner = ResendEmailAddressVerificationCode::default();
inner.td_name = "resendEmailAddressVerificationCode".to_string();
RTDResendEmailAddressVerificationCodeBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDResendEmailAddressVerificationCodeBuilder {
inner: ResendEmailAddressVerificationCode
}
impl RTDResendEmailAddressVerificationCodeBuilder {
pub fn build(&self) -> ResendEmailAddressVerificationCode { self.inner.clone() }
}
impl AsRef<ResendEmailAddressVerificationCode> for ResendEmailAddressVerificationCode {
fn as_ref(&self) -> &ResendEmailAddressVerificationCode { self }
}
impl AsRef<ResendEmailAddressVerificationCode> for RTDResendEmailAddressVerificationCodeBuilder {
fn as_ref(&self) -> &ResendEmailAddressVerificationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckEmailAddressVerificationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
code: String,
}
impl RObject for CheckEmailAddressVerificationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkEmailAddressVerificationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CheckEmailAddressVerificationCode {}
impl CheckEmailAddressVerificationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckEmailAddressVerificationCodeBuilder {
let mut inner = CheckEmailAddressVerificationCode::default();
inner.td_name = "checkEmailAddressVerificationCode".to_string();
RTDCheckEmailAddressVerificationCodeBuilder { inner }
}
pub fn code(&self) -> &String { &self.code }
}
#[doc(hidden)]
pub struct RTDCheckEmailAddressVerificationCodeBuilder {
inner: CheckEmailAddressVerificationCode
}
impl RTDCheckEmailAddressVerificationCodeBuilder {
pub fn build(&self) -> CheckEmailAddressVerificationCode { self.inner.clone() }
pub fn code<T: AsRef<str>>(&mut self, code: T) -> &mut Self {
self.inner.code = code.as_ref().to_string();
self
}
}
impl AsRef<CheckEmailAddressVerificationCode> for CheckEmailAddressVerificationCode {
fn as_ref(&self) -> &CheckEmailAddressVerificationCode { self }
}
impl AsRef<CheckEmailAddressVerificationCode> for RTDCheckEmailAddressVerificationCodeBuilder {
fn as_ref(&self) -> &CheckEmailAddressVerificationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetPassportAuthorizationForm {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
bot_user_id: i64,
scope: String,
public_key: String,
nonce: String,
password: String,
}
impl RObject for GetPassportAuthorizationForm {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getPassportAuthorizationForm" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetPassportAuthorizationForm {}
impl GetPassportAuthorizationForm {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetPassportAuthorizationFormBuilder {
let mut inner = GetPassportAuthorizationForm::default();
inner.td_name = "getPassportAuthorizationForm".to_string();
RTDGetPassportAuthorizationFormBuilder { inner }
}
pub fn bot_user_id(&self) -> i64 { self.bot_user_id }
pub fn scope(&self) -> &String { &self.scope }
pub fn public_key(&self) -> &String { &self.public_key }
pub fn nonce(&self) -> &String { &self.nonce }
pub fn password(&self) -> &String { &self.password }
}
#[doc(hidden)]
pub struct RTDGetPassportAuthorizationFormBuilder {
inner: GetPassportAuthorizationForm
}
impl RTDGetPassportAuthorizationFormBuilder {
pub fn build(&self) -> GetPassportAuthorizationForm { self.inner.clone() }
pub fn bot_user_id(&mut self, bot_user_id: i64) -> &mut Self {
self.inner.bot_user_id = bot_user_id;
self
}
pub fn scope<T: AsRef<str>>(&mut self, scope: T) -> &mut Self {
self.inner.scope = scope.as_ref().to_string();
self
}
pub fn public_key<T: AsRef<str>>(&mut self, public_key: T) -> &mut Self {
self.inner.public_key = public_key.as_ref().to_string();
self
}
pub fn nonce<T: AsRef<str>>(&mut self, nonce: T) -> &mut Self {
self.inner.nonce = nonce.as_ref().to_string();
self
}
pub fn password<T: AsRef<str>>(&mut self, password: T) -> &mut Self {
self.inner.password = password.as_ref().to_string();
self
}
}
impl AsRef<GetPassportAuthorizationForm> for GetPassportAuthorizationForm {
fn as_ref(&self) -> &GetPassportAuthorizationForm { self }
}
impl AsRef<GetPassportAuthorizationForm> for RTDGetPassportAuthorizationFormBuilder {
fn as_ref(&self) -> &GetPassportAuthorizationForm { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendPassportAuthorizationForm {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
autorization_form_id: i64,
types: Vec<PassportElementType>,
}
impl RObject for SendPassportAuthorizationForm {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendPassportAuthorizationForm" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendPassportAuthorizationForm {}
impl SendPassportAuthorizationForm {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendPassportAuthorizationFormBuilder {
let mut inner = SendPassportAuthorizationForm::default();
inner.td_name = "sendPassportAuthorizationForm".to_string();
RTDSendPassportAuthorizationFormBuilder { inner }
}
pub fn autorization_form_id(&self) -> i64 { self.autorization_form_id }
pub fn types(&self) -> &Vec<PassportElementType> { &self.types }
}
#[doc(hidden)]
pub struct RTDSendPassportAuthorizationFormBuilder {
inner: SendPassportAuthorizationForm
}
impl RTDSendPassportAuthorizationFormBuilder {
pub fn build(&self) -> SendPassportAuthorizationForm { self.inner.clone() }
pub fn autorization_form_id(&mut self, autorization_form_id: i64) -> &mut Self {
self.inner.autorization_form_id = autorization_form_id;
self
}
pub fn types(&mut self, types: Vec<PassportElementType>) -> &mut Self {
self.inner.types = types;
self
}
}
impl AsRef<SendPassportAuthorizationForm> for SendPassportAuthorizationForm {
fn as_ref(&self) -> &SendPassportAuthorizationForm { self }
}
impl AsRef<SendPassportAuthorizationForm> for RTDSendPassportAuthorizationFormBuilder {
fn as_ref(&self) -> &SendPassportAuthorizationForm { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendPhoneNumberConfirmationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
hash: String,
phone_number: String,
allow_flash_call: bool,
is_current_phone_number: bool,
}
impl RObject for SendPhoneNumberConfirmationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendPhoneNumberConfirmationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendPhoneNumberConfirmationCode {}
impl SendPhoneNumberConfirmationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendPhoneNumberConfirmationCodeBuilder {
let mut inner = SendPhoneNumberConfirmationCode::default();
inner.td_name = "sendPhoneNumberConfirmationCode".to_string();
RTDSendPhoneNumberConfirmationCodeBuilder { inner }
}
pub fn hash(&self) -> &String { &self.hash }
pub fn phone_number(&self) -> &String { &self.phone_number }
pub fn allow_flash_call(&self) -> bool { self.allow_flash_call }
pub fn is_current_phone_number(&self) -> bool { self.is_current_phone_number }
}
#[doc(hidden)]
pub struct RTDSendPhoneNumberConfirmationCodeBuilder {
inner: SendPhoneNumberConfirmationCode
}
impl RTDSendPhoneNumberConfirmationCodeBuilder {
pub fn build(&self) -> SendPhoneNumberConfirmationCode { self.inner.clone() }
pub fn hash<T: AsRef<str>>(&mut self, hash: T) -> &mut Self {
self.inner.hash = hash.as_ref().to_string();
self
}
pub fn phone_number<T: AsRef<str>>(&mut self, phone_number: T) -> &mut Self {
self.inner.phone_number = phone_number.as_ref().to_string();
self
}
pub fn allow_flash_call(&mut self, allow_flash_call: bool) -> &mut Self {
self.inner.allow_flash_call = allow_flash_call;
self
}
pub fn is_current_phone_number(&mut self, is_current_phone_number: bool) -> &mut Self {
self.inner.is_current_phone_number = is_current_phone_number;
self
}
}
impl AsRef<SendPhoneNumberConfirmationCode> for SendPhoneNumberConfirmationCode {
fn as_ref(&self) -> &SendPhoneNumberConfirmationCode { self }
}
impl AsRef<SendPhoneNumberConfirmationCode> for RTDSendPhoneNumberConfirmationCodeBuilder {
fn as_ref(&self) -> &SendPhoneNumberConfirmationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ResendPhoneNumberConfirmationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for ResendPhoneNumberConfirmationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "resendPhoneNumberConfirmationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for ResendPhoneNumberConfirmationCode {}
impl ResendPhoneNumberConfirmationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDResendPhoneNumberConfirmationCodeBuilder {
let mut inner = ResendPhoneNumberConfirmationCode::default();
inner.td_name = "resendPhoneNumberConfirmationCode".to_string();
RTDResendPhoneNumberConfirmationCodeBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDResendPhoneNumberConfirmationCodeBuilder {
inner: ResendPhoneNumberConfirmationCode
}
impl RTDResendPhoneNumberConfirmationCodeBuilder {
pub fn build(&self) -> ResendPhoneNumberConfirmationCode { self.inner.clone() }
}
impl AsRef<ResendPhoneNumberConfirmationCode> for ResendPhoneNumberConfirmationCode {
fn as_ref(&self) -> &ResendPhoneNumberConfirmationCode { self }
}
impl AsRef<ResendPhoneNumberConfirmationCode> for RTDResendPhoneNumberConfirmationCodeBuilder {
fn as_ref(&self) -> &ResendPhoneNumberConfirmationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CheckPhoneNumberConfirmationCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
code: String,
}
impl RObject for CheckPhoneNumberConfirmationCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "checkPhoneNumberConfirmationCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CheckPhoneNumberConfirmationCode {}
impl CheckPhoneNumberConfirmationCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCheckPhoneNumberConfirmationCodeBuilder {
let mut inner = CheckPhoneNumberConfirmationCode::default();
inner.td_name = "checkPhoneNumberConfirmationCode".to_string();
RTDCheckPhoneNumberConfirmationCodeBuilder { inner }
}
pub fn code(&self) -> &String { &self.code }
}
#[doc(hidden)]
pub struct RTDCheckPhoneNumberConfirmationCodeBuilder {
inner: CheckPhoneNumberConfirmationCode
}
impl RTDCheckPhoneNumberConfirmationCodeBuilder {
pub fn build(&self) -> CheckPhoneNumberConfirmationCode { self.inner.clone() }
pub fn code<T: AsRef<str>>(&mut self, code: T) -> &mut Self {
self.inner.code = code.as_ref().to_string();
self
}
}
impl AsRef<CheckPhoneNumberConfirmationCode> for CheckPhoneNumberConfirmationCode {
fn as_ref(&self) -> &CheckPhoneNumberConfirmationCode { self }
}
impl AsRef<CheckPhoneNumberConfirmationCode> for RTDCheckPhoneNumberConfirmationCodeBuilder {
fn as_ref(&self) -> &CheckPhoneNumberConfirmationCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetBotUpdatesStatus {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
pending_update_count: i64,
error_message: String,
}
impl RObject for SetBotUpdatesStatus {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setBotUpdatesStatus" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetBotUpdatesStatus {}
impl SetBotUpdatesStatus {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetBotUpdatesStatusBuilder {
let mut inner = SetBotUpdatesStatus::default();
inner.td_name = "setBotUpdatesStatus".to_string();
RTDSetBotUpdatesStatusBuilder { inner }
}
pub fn pending_update_count(&self) -> i64 { self.pending_update_count }
pub fn error_message(&self) -> &String { &self.error_message }
}
#[doc(hidden)]
pub struct RTDSetBotUpdatesStatusBuilder {
inner: SetBotUpdatesStatus
}
impl RTDSetBotUpdatesStatusBuilder {
pub fn build(&self) -> SetBotUpdatesStatus { self.inner.clone() }
pub fn pending_update_count(&mut self, pending_update_count: i64) -> &mut Self {
self.inner.pending_update_count = pending_update_count;
self
}
pub fn error_message<T: AsRef<str>>(&mut self, error_message: T) -> &mut Self {
self.inner.error_message = error_message.as_ref().to_string();
self
}
}
impl AsRef<SetBotUpdatesStatus> for SetBotUpdatesStatus {
fn as_ref(&self) -> &SetBotUpdatesStatus { self }
}
impl AsRef<SetBotUpdatesStatus> for RTDSetBotUpdatesStatusBuilder {
fn as_ref(&self) -> &SetBotUpdatesStatus { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UploadStickerFile {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
png_sticker: InputFile,
}
impl RObject for UploadStickerFile {
#[doc(hidden)] fn td_name(&self) -> &'static str { "uploadStickerFile" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for UploadStickerFile {}
impl UploadStickerFile {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDUploadStickerFileBuilder {
let mut inner = UploadStickerFile::default();
inner.td_name = "uploadStickerFile".to_string();
RTDUploadStickerFileBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
pub fn png_sticker(&self) -> &InputFile { &self.png_sticker }
}
#[doc(hidden)]
pub struct RTDUploadStickerFileBuilder {
inner: UploadStickerFile
}
impl RTDUploadStickerFileBuilder {
pub fn build(&self) -> UploadStickerFile { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn png_sticker<T: AsRef<InputFile>>(&mut self, png_sticker: T) -> &mut Self {
self.inner.png_sticker = png_sticker.as_ref().clone();
self
}
}
impl AsRef<UploadStickerFile> for UploadStickerFile {
fn as_ref(&self) -> &UploadStickerFile { self }
}
impl AsRef<UploadStickerFile> for RTDUploadStickerFileBuilder {
fn as_ref(&self) -> &UploadStickerFile { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateNewStickerSet {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
title: String,
name: String,
is_masks: bool,
stickers: Vec<InputSticker>,
}
impl RObject for CreateNewStickerSet {
#[doc(hidden)] fn td_name(&self) -> &'static str { "createNewStickerSet" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for CreateNewStickerSet {}
impl CreateNewStickerSet {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDCreateNewStickerSetBuilder {
let mut inner = CreateNewStickerSet::default();
inner.td_name = "createNewStickerSet".to_string();
RTDCreateNewStickerSetBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
pub fn title(&self) -> &String { &self.title }
pub fn name(&self) -> &String { &self.name }
pub fn is_masks(&self) -> bool { self.is_masks }
pub fn stickers(&self) -> &Vec<InputSticker> { &self.stickers }
}
#[doc(hidden)]
pub struct RTDCreateNewStickerSetBuilder {
inner: CreateNewStickerSet
}
impl RTDCreateNewStickerSetBuilder {
pub fn build(&self) -> CreateNewStickerSet { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn title<T: AsRef<str>>(&mut self, title: T) -> &mut Self {
self.inner.title = title.as_ref().to_string();
self
}
pub fn name<T: AsRef<str>>(&mut self, name: T) -> &mut Self {
self.inner.name = name.as_ref().to_string();
self
}
pub fn is_masks(&mut self, is_masks: bool) -> &mut Self {
self.inner.is_masks = is_masks;
self
}
pub fn stickers(&mut self, stickers: Vec<InputSticker>) -> &mut Self {
self.inner.stickers = stickers;
self
}
}
impl AsRef<CreateNewStickerSet> for CreateNewStickerSet {
fn as_ref(&self) -> &CreateNewStickerSet { self }
}
impl AsRef<CreateNewStickerSet> for RTDCreateNewStickerSetBuilder {
fn as_ref(&self) -> &CreateNewStickerSet { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddStickerToSet {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
user_id: i64,
name: String,
sticker: InputSticker,
}
impl RObject for AddStickerToSet {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addStickerToSet" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddStickerToSet {}
impl AddStickerToSet {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddStickerToSetBuilder {
let mut inner = AddStickerToSet::default();
inner.td_name = "addStickerToSet".to_string();
RTDAddStickerToSetBuilder { inner }
}
pub fn user_id(&self) -> i64 { self.user_id }
pub fn name(&self) -> &String { &self.name }
pub fn sticker(&self) -> &InputSticker { &self.sticker }
}
#[doc(hidden)]
pub struct RTDAddStickerToSetBuilder {
inner: AddStickerToSet
}
impl RTDAddStickerToSetBuilder {
pub fn build(&self) -> AddStickerToSet { self.inner.clone() }
pub fn user_id(&mut self, user_id: i64) -> &mut Self {
self.inner.user_id = user_id;
self
}
pub fn name<T: AsRef<str>>(&mut self, name: T) -> &mut Self {
self.inner.name = name.as_ref().to_string();
self
}
pub fn sticker<T: AsRef<InputSticker>>(&mut self, sticker: T) -> &mut Self {
self.inner.sticker = sticker.as_ref().clone();
self
}
}
impl AsRef<AddStickerToSet> for AddStickerToSet {
fn as_ref(&self) -> &AddStickerToSet { self }
}
impl AsRef<AddStickerToSet> for RTDAddStickerToSetBuilder {
fn as_ref(&self) -> &AddStickerToSet { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetStickerPositionInSet {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
sticker: InputFile,
position: i64,
}
impl RObject for SetStickerPositionInSet {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setStickerPositionInSet" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetStickerPositionInSet {}
impl SetStickerPositionInSet {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetStickerPositionInSetBuilder {
let mut inner = SetStickerPositionInSet::default();
inner.td_name = "setStickerPositionInSet".to_string();
RTDSetStickerPositionInSetBuilder { inner }
}
pub fn sticker(&self) -> &InputFile { &self.sticker }
pub fn position(&self) -> i64 { self.position }
}
#[doc(hidden)]
pub struct RTDSetStickerPositionInSetBuilder {
inner: SetStickerPositionInSet
}
impl RTDSetStickerPositionInSetBuilder {
pub fn build(&self) -> SetStickerPositionInSet { self.inner.clone() }
pub fn sticker<T: AsRef<InputFile>>(&mut self, sticker: T) -> &mut Self {
self.inner.sticker = sticker.as_ref().clone();
self
}
pub fn position(&mut self, position: i64) -> &mut Self {
self.inner.position = position;
self
}
}
impl AsRef<SetStickerPositionInSet> for SetStickerPositionInSet {
fn as_ref(&self) -> &SetStickerPositionInSet { self }
}
impl AsRef<SetStickerPositionInSet> for RTDSetStickerPositionInSetBuilder {
fn as_ref(&self) -> &SetStickerPositionInSet { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RemoveStickerFromSet {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
sticker: InputFile,
}
impl RObject for RemoveStickerFromSet {
#[doc(hidden)] fn td_name(&self) -> &'static str { "removeStickerFromSet" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RemoveStickerFromSet {}
impl RemoveStickerFromSet {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRemoveStickerFromSetBuilder {
let mut inner = RemoveStickerFromSet::default();
inner.td_name = "removeStickerFromSet".to_string();
RTDRemoveStickerFromSetBuilder { inner }
}
pub fn sticker(&self) -> &InputFile { &self.sticker }
}
#[doc(hidden)]
pub struct RTDRemoveStickerFromSetBuilder {
inner: RemoveStickerFromSet
}
impl RTDRemoveStickerFromSetBuilder {
pub fn build(&self) -> RemoveStickerFromSet { self.inner.clone() }
pub fn sticker<T: AsRef<InputFile>>(&mut self, sticker: T) -> &mut Self {
self.inner.sticker = sticker.as_ref().clone();
self
}
}
impl AsRef<RemoveStickerFromSet> for RemoveStickerFromSet {
fn as_ref(&self) -> &RemoveStickerFromSet { self }
}
impl AsRef<RemoveStickerFromSet> for RTDRemoveStickerFromSetBuilder {
fn as_ref(&self) -> &RemoveStickerFromSet { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetMapThumbnailFile {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
location: Location,
zoom: i64,
width: i64,
height: i64,
scale: i64,
chat_id: i64,
}
impl RObject for GetMapThumbnailFile {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getMapThumbnailFile" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetMapThumbnailFile {}
impl GetMapThumbnailFile {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetMapThumbnailFileBuilder {
let mut inner = GetMapThumbnailFile::default();
inner.td_name = "getMapThumbnailFile".to_string();
RTDGetMapThumbnailFileBuilder { inner }
}
pub fn location(&self) -> &Location { &self.location }
pub fn zoom(&self) -> i64 { self.zoom }
pub fn width(&self) -> i64 { self.width }
pub fn height(&self) -> i64 { self.height }
pub fn scale(&self) -> i64 { self.scale }
pub fn chat_id(&self) -> i64 { self.chat_id }
}
#[doc(hidden)]
pub struct RTDGetMapThumbnailFileBuilder {
inner: GetMapThumbnailFile
}
impl RTDGetMapThumbnailFileBuilder {
pub fn build(&self) -> GetMapThumbnailFile { 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 zoom(&mut self, zoom: i64) -> &mut Self {
self.inner.zoom = zoom;
self
}
pub fn width(&mut self, width: i64) -> &mut Self {
self.inner.width = width;
self
}
pub fn height(&mut self, height: i64) -> &mut Self {
self.inner.height = height;
self
}
pub fn scale(&mut self, scale: i64) -> &mut Self {
self.inner.scale = scale;
self
}
pub fn chat_id(&mut self, chat_id: i64) -> &mut Self {
self.inner.chat_id = chat_id;
self
}
}
impl AsRef<GetMapThumbnailFile> for GetMapThumbnailFile {
fn as_ref(&self) -> &GetMapThumbnailFile { self }
}
impl AsRef<GetMapThumbnailFile> for RTDGetMapThumbnailFileBuilder {
fn as_ref(&self) -> &GetMapThumbnailFile { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AcceptTermsOfService {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
terms_of_service_id: String,
}
impl RObject for AcceptTermsOfService {
#[doc(hidden)] fn td_name(&self) -> &'static str { "acceptTermsOfService" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AcceptTermsOfService {}
impl AcceptTermsOfService {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAcceptTermsOfServiceBuilder {
let mut inner = AcceptTermsOfService::default();
inner.td_name = "acceptTermsOfService".to_string();
RTDAcceptTermsOfServiceBuilder { inner }
}
pub fn terms_of_service_id(&self) -> &String { &self.terms_of_service_id }
}
#[doc(hidden)]
pub struct RTDAcceptTermsOfServiceBuilder {
inner: AcceptTermsOfService
}
impl RTDAcceptTermsOfServiceBuilder {
pub fn build(&self) -> AcceptTermsOfService { self.inner.clone() }
pub fn terms_of_service_id<T: AsRef<str>>(&mut self, terms_of_service_id: T) -> &mut Self {
self.inner.terms_of_service_id = terms_of_service_id.as_ref().to_string();
self
}
}
impl AsRef<AcceptTermsOfService> for AcceptTermsOfService {
fn as_ref(&self) -> &AcceptTermsOfService { self }
}
impl AsRef<AcceptTermsOfService> for RTDAcceptTermsOfServiceBuilder {
fn as_ref(&self) -> &AcceptTermsOfService { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SendCustomRequest {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
method: String,
parameters: String,
}
impl RObject for SendCustomRequest {
#[doc(hidden)] fn td_name(&self) -> &'static str { "sendCustomRequest" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SendCustomRequest {}
impl SendCustomRequest {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSendCustomRequestBuilder {
let mut inner = SendCustomRequest::default();
inner.td_name = "sendCustomRequest".to_string();
RTDSendCustomRequestBuilder { inner }
}
pub fn method(&self) -> &String { &self.method }
pub fn parameters(&self) -> &String { &self.parameters }
}
#[doc(hidden)]
pub struct RTDSendCustomRequestBuilder {
inner: SendCustomRequest
}
impl RTDSendCustomRequestBuilder {
pub fn build(&self) -> SendCustomRequest { self.inner.clone() }
pub fn method<T: AsRef<str>>(&mut self, method: T) -> &mut Self {
self.inner.method = method.as_ref().to_string();
self
}
pub fn parameters<T: AsRef<str>>(&mut self, parameters: T) -> &mut Self {
self.inner.parameters = parameters.as_ref().to_string();
self
}
}
impl AsRef<SendCustomRequest> for SendCustomRequest {
fn as_ref(&self) -> &SendCustomRequest { self }
}
impl AsRef<SendCustomRequest> for RTDSendCustomRequestBuilder {
fn as_ref(&self) -> &SendCustomRequest { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AnswerCustomQuery {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
custom_query_id: isize,
data: String,
}
impl RObject for AnswerCustomQuery {
#[doc(hidden)] fn td_name(&self) -> &'static str { "answerCustomQuery" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AnswerCustomQuery {}
impl AnswerCustomQuery {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAnswerCustomQueryBuilder {
let mut inner = AnswerCustomQuery::default();
inner.td_name = "answerCustomQuery".to_string();
RTDAnswerCustomQueryBuilder { inner }
}
pub fn custom_query_id(&self) -> isize { self.custom_query_id }
pub fn data(&self) -> &String { &self.data }
}
#[doc(hidden)]
pub struct RTDAnswerCustomQueryBuilder {
inner: AnswerCustomQuery
}
impl RTDAnswerCustomQueryBuilder {
pub fn build(&self) -> AnswerCustomQuery { self.inner.clone() }
pub fn custom_query_id(&mut self, custom_query_id: isize) -> &mut Self {
self.inner.custom_query_id = custom_query_id;
self
}
pub fn data<T: AsRef<str>>(&mut self, data: T) -> &mut Self {
self.inner.data = data.as_ref().to_string();
self
}
}
impl AsRef<AnswerCustomQuery> for AnswerCustomQuery {
fn as_ref(&self) -> &AnswerCustomQuery { self }
}
impl AsRef<AnswerCustomQuery> for RTDAnswerCustomQueryBuilder {
fn as_ref(&self) -> &AnswerCustomQuery { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetAlarm {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
seconds: f32,
}
impl RObject for SetAlarm {
#[doc(hidden)] fn td_name(&self) -> &'static str { "setAlarm" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for SetAlarm {}
impl SetAlarm {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDSetAlarmBuilder {
let mut inner = SetAlarm::default();
inner.td_name = "setAlarm".to_string();
RTDSetAlarmBuilder { inner }
}
pub fn seconds(&self) -> f32 { self.seconds }
}
#[doc(hidden)]
pub struct RTDSetAlarmBuilder {
inner: SetAlarm
}
impl RTDSetAlarmBuilder {
pub fn build(&self) -> SetAlarm { self.inner.clone() }
pub fn seconds(&mut self, seconds: f32) -> &mut Self {
self.inner.seconds = seconds;
self
}
}
impl AsRef<SetAlarm> for SetAlarm {
fn as_ref(&self) -> &SetAlarm { self }
}
impl AsRef<SetAlarm> for RTDSetAlarmBuilder {
fn as_ref(&self) -> &SetAlarm { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetCountryCode {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetCountryCode {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getCountryCode" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetCountryCode {}
impl GetCountryCode {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetCountryCodeBuilder {
let mut inner = GetCountryCode::default();
inner.td_name = "getCountryCode".to_string();
RTDGetCountryCodeBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetCountryCodeBuilder {
inner: GetCountryCode
}
impl RTDGetCountryCodeBuilder {
pub fn build(&self) -> GetCountryCode { self.inner.clone() }
}
impl AsRef<GetCountryCode> for GetCountryCode {
fn as_ref(&self) -> &GetCountryCode { self }
}
impl AsRef<GetCountryCode> for RTDGetCountryCodeBuilder {
fn as_ref(&self) -> &GetCountryCode { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetInviteText {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetInviteText {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getInviteText" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetInviteText {}
impl GetInviteText {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetInviteTextBuilder {
let mut inner = GetInviteText::default();
inner.td_name = "getInviteText".to_string();
RTDGetInviteTextBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetInviteTextBuilder {
inner: GetInviteText
}
impl RTDGetInviteTextBuilder {
pub fn build(&self) -> GetInviteText { self.inner.clone() }
}
impl AsRef<GetInviteText> for GetInviteText {
fn as_ref(&self) -> &GetInviteText { self }
}
impl AsRef<GetInviteText> for RTDGetInviteTextBuilder {
fn as_ref(&self) -> &GetInviteText { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetDeepLinkInfo {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
link: String,
}
impl RObject for GetDeepLinkInfo {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getDeepLinkInfo" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetDeepLinkInfo {}
impl GetDeepLinkInfo {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetDeepLinkInfoBuilder {
let mut inner = GetDeepLinkInfo::default();
inner.td_name = "getDeepLinkInfo".to_string();
RTDGetDeepLinkInfoBuilder { inner }
}
pub fn link(&self) -> &String { &self.link }
}
#[doc(hidden)]
pub struct RTDGetDeepLinkInfoBuilder {
inner: GetDeepLinkInfo
}
impl RTDGetDeepLinkInfoBuilder {
pub fn build(&self) -> GetDeepLinkInfo { self.inner.clone() }
pub fn link<T: AsRef<str>>(&mut self, link: T) -> &mut Self {
self.inner.link = link.as_ref().to_string();
self
}
}
impl AsRef<GetDeepLinkInfo> for GetDeepLinkInfo {
fn as_ref(&self) -> &GetDeepLinkInfo { self }
}
impl AsRef<GetDeepLinkInfo> for RTDGetDeepLinkInfoBuilder {
fn as_ref(&self) -> &GetDeepLinkInfo { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddProxy {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
server: String,
port: i64,
enable: bool,
#[serde(rename(serialize = "type", deserialize = "type"))] type_: ProxyType,
}
impl RObject for AddProxy {
#[doc(hidden)] fn td_name(&self) -> &'static str { "addProxy" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for AddProxy {}
impl AddProxy {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDAddProxyBuilder {
let mut inner = AddProxy::default();
inner.td_name = "addProxy".to_string();
RTDAddProxyBuilder { inner }
}
pub fn server(&self) -> &String { &self.server }
pub fn port(&self) -> i64 { self.port }
pub fn enable(&self) -> bool { self.enable }
pub fn type_(&self) -> &ProxyType { &self.type_ }
}
#[doc(hidden)]
pub struct RTDAddProxyBuilder {
inner: AddProxy
}
impl RTDAddProxyBuilder {
pub fn build(&self) -> AddProxy { self.inner.clone() }
pub fn server<T: AsRef<str>>(&mut self, server: T) -> &mut Self {
self.inner.server = server.as_ref().to_string();
self
}
pub fn port(&mut self, port: i64) -> &mut Self {
self.inner.port = port;
self
}
pub fn enable(&mut self, enable: bool) -> &mut Self {
self.inner.enable = enable;
self
}
pub fn type_<T: AsRef<ProxyType>>(&mut self, type_: T) -> &mut Self {
self.inner.type_ = type_.as_ref().clone();
self
}
}
impl AsRef<AddProxy> for AddProxy {
fn as_ref(&self) -> &AddProxy { self }
}
impl AsRef<AddProxy> for RTDAddProxyBuilder {
fn as_ref(&self) -> &AddProxy { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EditProxy {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
proxy_id: i64,
server: String,
port: i64,
enable: bool,
#[serde(rename(serialize = "type", deserialize = "type"))] type_: ProxyType,
}
impl RObject for EditProxy {
#[doc(hidden)] fn td_name(&self) -> &'static str { "editProxy" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EditProxy {}
impl EditProxy {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEditProxyBuilder {
let mut inner = EditProxy::default();
inner.td_name = "editProxy".to_string();
RTDEditProxyBuilder { inner }
}
pub fn proxy_id(&self) -> i64 { self.proxy_id }
pub fn server(&self) -> &String { &self.server }
pub fn port(&self) -> i64 { self.port }
pub fn enable(&self) -> bool { self.enable }
pub fn type_(&self) -> &ProxyType { &self.type_ }
}
#[doc(hidden)]
pub struct RTDEditProxyBuilder {
inner: EditProxy
}
impl RTDEditProxyBuilder {
pub fn build(&self) -> EditProxy { self.inner.clone() }
pub fn proxy_id(&mut self, proxy_id: i64) -> &mut Self {
self.inner.proxy_id = proxy_id;
self
}
pub fn server<T: AsRef<str>>(&mut self, server: T) -> &mut Self {
self.inner.server = server.as_ref().to_string();
self
}
pub fn port(&mut self, port: i64) -> &mut Self {
self.inner.port = port;
self
}
pub fn enable(&mut self, enable: bool) -> &mut Self {
self.inner.enable = enable;
self
}
pub fn type_<T: AsRef<ProxyType>>(&mut self, type_: T) -> &mut Self {
self.inner.type_ = type_.as_ref().clone();
self
}
}
impl AsRef<EditProxy> for EditProxy {
fn as_ref(&self) -> &EditProxy { self }
}
impl AsRef<EditProxy> for RTDEditProxyBuilder {
fn as_ref(&self) -> &EditProxy { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EnableProxy {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
proxy_id: i64,
}
impl RObject for EnableProxy {
#[doc(hidden)] fn td_name(&self) -> &'static str { "enableProxy" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for EnableProxy {}
impl EnableProxy {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDEnableProxyBuilder {
let mut inner = EnableProxy::default();
inner.td_name = "enableProxy".to_string();
RTDEnableProxyBuilder { inner }
}
pub fn proxy_id(&self) -> i64 { self.proxy_id }
}
#[doc(hidden)]
pub struct RTDEnableProxyBuilder {
inner: EnableProxy
}
impl RTDEnableProxyBuilder {
pub fn build(&self) -> EnableProxy { self.inner.clone() }
pub fn proxy_id(&mut self, proxy_id: i64) -> &mut Self {
self.inner.proxy_id = proxy_id;
self
}
}
impl AsRef<EnableProxy> for EnableProxy {
fn as_ref(&self) -> &EnableProxy { self }
}
impl AsRef<EnableProxy> for RTDEnableProxyBuilder {
fn as_ref(&self) -> &EnableProxy { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DisableProxy {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for DisableProxy {
#[doc(hidden)] fn td_name(&self) -> &'static str { "disableProxy" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for DisableProxy {}
impl DisableProxy {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDDisableProxyBuilder {
let mut inner = DisableProxy::default();
inner.td_name = "disableProxy".to_string();
RTDDisableProxyBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDDisableProxyBuilder {
inner: DisableProxy
}
impl RTDDisableProxyBuilder {
pub fn build(&self) -> DisableProxy { self.inner.clone() }
}
impl AsRef<DisableProxy> for DisableProxy {
fn as_ref(&self) -> &DisableProxy { self }
}
impl AsRef<DisableProxy> for RTDDisableProxyBuilder {
fn as_ref(&self) -> &DisableProxy { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RemoveProxy {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
proxy_id: i64,
}
impl RObject for RemoveProxy {
#[doc(hidden)] fn td_name(&self) -> &'static str { "removeProxy" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for RemoveProxy {}
impl RemoveProxy {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDRemoveProxyBuilder {
let mut inner = RemoveProxy::default();
inner.td_name = "removeProxy".to_string();
RTDRemoveProxyBuilder { inner }
}
pub fn proxy_id(&self) -> i64 { self.proxy_id }
}
#[doc(hidden)]
pub struct RTDRemoveProxyBuilder {
inner: RemoveProxy
}
impl RTDRemoveProxyBuilder {
pub fn build(&self) -> RemoveProxy { self.inner.clone() }
pub fn proxy_id(&mut self, proxy_id: i64) -> &mut Self {
self.inner.proxy_id = proxy_id;
self
}
}
impl AsRef<RemoveProxy> for RemoveProxy {
fn as_ref(&self) -> &RemoveProxy { self }
}
impl AsRef<RemoveProxy> for RTDRemoveProxyBuilder {
fn as_ref(&self) -> &RemoveProxy { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetProxies {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for GetProxies {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getProxies" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetProxies {}
impl GetProxies {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetProxiesBuilder {
let mut inner = GetProxies::default();
inner.td_name = "getProxies".to_string();
RTDGetProxiesBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDGetProxiesBuilder {
inner: GetProxies
}
impl RTDGetProxiesBuilder {
pub fn build(&self) -> GetProxies { self.inner.clone() }
}
impl AsRef<GetProxies> for GetProxies {
fn as_ref(&self) -> &GetProxies { self }
}
impl AsRef<GetProxies> for RTDGetProxiesBuilder {
fn as_ref(&self) -> &GetProxies { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetProxyLink {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
proxy_id: i64,
}
impl RObject for GetProxyLink {
#[doc(hidden)] fn td_name(&self) -> &'static str { "getProxyLink" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for GetProxyLink {}
impl GetProxyLink {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDGetProxyLinkBuilder {
let mut inner = GetProxyLink::default();
inner.td_name = "getProxyLink".to_string();
RTDGetProxyLinkBuilder { inner }
}
pub fn proxy_id(&self) -> i64 { self.proxy_id }
}
#[doc(hidden)]
pub struct RTDGetProxyLinkBuilder {
inner: GetProxyLink
}
impl RTDGetProxyLinkBuilder {
pub fn build(&self) -> GetProxyLink { self.inner.clone() }
pub fn proxy_id(&mut self, proxy_id: i64) -> &mut Self {
self.inner.proxy_id = proxy_id;
self
}
}
impl AsRef<GetProxyLink> for GetProxyLink {
fn as_ref(&self) -> &GetProxyLink { self }
}
impl AsRef<GetProxyLink> for RTDGetProxyLinkBuilder {
fn as_ref(&self) -> &GetProxyLink { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct PingProxy {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
proxy_id: i64,
}
impl RObject for PingProxy {
#[doc(hidden)] fn td_name(&self) -> &'static str { "pingProxy" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for PingProxy {}
impl PingProxy {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDPingProxyBuilder {
let mut inner = PingProxy::default();
inner.td_name = "pingProxy".to_string();
RTDPingProxyBuilder { inner }
}
pub fn proxy_id(&self) -> i64 { self.proxy_id }
}
#[doc(hidden)]
pub struct RTDPingProxyBuilder {
inner: PingProxy
}
impl RTDPingProxyBuilder {
pub fn build(&self) -> PingProxy { self.inner.clone() }
pub fn proxy_id(&mut self, proxy_id: i64) -> &mut Self {
self.inner.proxy_id = proxy_id;
self
}
}
impl AsRef<PingProxy> for PingProxy {
fn as_ref(&self) -> &PingProxy { self }
}
impl AsRef<PingProxy> for RTDPingProxyBuilder {
fn as_ref(&self) -> &PingProxy { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestCallEmpty {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for TestCallEmpty {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testCallEmpty" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestCallEmpty {}
impl TestCallEmpty {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestCallEmptyBuilder {
let mut inner = TestCallEmpty::default();
inner.td_name = "testCallEmpty".to_string();
RTDTestCallEmptyBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDTestCallEmptyBuilder {
inner: TestCallEmpty
}
impl RTDTestCallEmptyBuilder {
pub fn build(&self) -> TestCallEmpty { self.inner.clone() }
}
impl AsRef<TestCallEmpty> for TestCallEmpty {
fn as_ref(&self) -> &TestCallEmpty { self }
}
impl AsRef<TestCallEmpty> for RTDTestCallEmptyBuilder {
fn as_ref(&self) -> &TestCallEmpty { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestCallString {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
x: String,
}
impl RObject for TestCallString {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testCallString" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestCallString {}
impl TestCallString {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestCallStringBuilder {
let mut inner = TestCallString::default();
inner.td_name = "testCallString".to_string();
RTDTestCallStringBuilder { inner }
}
pub fn x(&self) -> &String { &self.x }
}
#[doc(hidden)]
pub struct RTDTestCallStringBuilder {
inner: TestCallString
}
impl RTDTestCallStringBuilder {
pub fn build(&self) -> TestCallString { self.inner.clone() }
pub fn x<T: AsRef<str>>(&mut self, x: T) -> &mut Self {
self.inner.x = x.as_ref().to_string();
self
}
}
impl AsRef<TestCallString> for TestCallString {
fn as_ref(&self) -> &TestCallString { self }
}
impl AsRef<TestCallString> for RTDTestCallStringBuilder {
fn as_ref(&self) -> &TestCallString { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestCallBytes {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
x: String,
}
impl RObject for TestCallBytes {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testCallBytes" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestCallBytes {}
impl TestCallBytes {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestCallBytesBuilder {
let mut inner = TestCallBytes::default();
inner.td_name = "testCallBytes".to_string();
RTDTestCallBytesBuilder { inner }
}
pub fn x(&self) -> &String { &self.x }
}
#[doc(hidden)]
pub struct RTDTestCallBytesBuilder {
inner: TestCallBytes
}
impl RTDTestCallBytesBuilder {
pub fn build(&self) -> TestCallBytes { self.inner.clone() }
pub fn x<T: AsRef<str>>(&mut self, x: T) -> &mut Self {
self.inner.x = x.as_ref().to_string();
self
}
}
impl AsRef<TestCallBytes> for TestCallBytes {
fn as_ref(&self) -> &TestCallBytes { self }
}
impl AsRef<TestCallBytes> for RTDTestCallBytesBuilder {
fn as_ref(&self) -> &TestCallBytes { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestCallVectorInt {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
x: Vec<i64>,
}
impl RObject for TestCallVectorInt {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testCallVectorInt" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestCallVectorInt {}
impl TestCallVectorInt {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestCallVectorIntBuilder {
let mut inner = TestCallVectorInt::default();
inner.td_name = "testCallVectorInt".to_string();
RTDTestCallVectorIntBuilder { inner }
}
pub fn x(&self) -> &Vec<i64> { &self.x }
}
#[doc(hidden)]
pub struct RTDTestCallVectorIntBuilder {
inner: TestCallVectorInt
}
impl RTDTestCallVectorIntBuilder {
pub fn build(&self) -> TestCallVectorInt { self.inner.clone() }
pub fn x(&mut self, x: Vec<i64>) -> &mut Self {
self.inner.x = x;
self
}
}
impl AsRef<TestCallVectorInt> for TestCallVectorInt {
fn as_ref(&self) -> &TestCallVectorInt { self }
}
impl AsRef<TestCallVectorInt> for RTDTestCallVectorIntBuilder {
fn as_ref(&self) -> &TestCallVectorInt { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestCallVectorIntObject {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
x: Vec<TestInt>,
}
impl RObject for TestCallVectorIntObject {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testCallVectorIntObject" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestCallVectorIntObject {}
impl TestCallVectorIntObject {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestCallVectorIntObjectBuilder {
let mut inner = TestCallVectorIntObject::default();
inner.td_name = "testCallVectorIntObject".to_string();
RTDTestCallVectorIntObjectBuilder { inner }
}
pub fn x(&self) -> &Vec<TestInt> { &self.x }
}
#[doc(hidden)]
pub struct RTDTestCallVectorIntObjectBuilder {
inner: TestCallVectorIntObject
}
impl RTDTestCallVectorIntObjectBuilder {
pub fn build(&self) -> TestCallVectorIntObject { self.inner.clone() }
pub fn x(&mut self, x: Vec<TestInt>) -> &mut Self {
self.inner.x = x;
self
}
}
impl AsRef<TestCallVectorIntObject> for TestCallVectorIntObject {
fn as_ref(&self) -> &TestCallVectorIntObject { self }
}
impl AsRef<TestCallVectorIntObject> for RTDTestCallVectorIntObjectBuilder {
fn as_ref(&self) -> &TestCallVectorIntObject { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestCallVectorString {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
x: Vec<String>,
}
impl RObject for TestCallVectorString {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testCallVectorString" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestCallVectorString {}
impl TestCallVectorString {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestCallVectorStringBuilder {
let mut inner = TestCallVectorString::default();
inner.td_name = "testCallVectorString".to_string();
RTDTestCallVectorStringBuilder { inner }
}
pub fn x(&self) -> &Vec<String> { &self.x }
}
#[doc(hidden)]
pub struct RTDTestCallVectorStringBuilder {
inner: TestCallVectorString
}
impl RTDTestCallVectorStringBuilder {
pub fn build(&self) -> TestCallVectorString { self.inner.clone() }
pub fn x(&mut self, x: Vec<String>) -> &mut Self {
self.inner.x = x;
self
}
}
impl AsRef<TestCallVectorString> for TestCallVectorString {
fn as_ref(&self) -> &TestCallVectorString { self }
}
impl AsRef<TestCallVectorString> for RTDTestCallVectorStringBuilder {
fn as_ref(&self) -> &TestCallVectorString { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestCallVectorStringObject {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
x: Vec<TestString>,
}
impl RObject for TestCallVectorStringObject {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testCallVectorStringObject" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestCallVectorStringObject {}
impl TestCallVectorStringObject {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestCallVectorStringObjectBuilder {
let mut inner = TestCallVectorStringObject::default();
inner.td_name = "testCallVectorStringObject".to_string();
RTDTestCallVectorStringObjectBuilder { inner }
}
pub fn x(&self) -> &Vec<TestString> { &self.x }
}
#[doc(hidden)]
pub struct RTDTestCallVectorStringObjectBuilder {
inner: TestCallVectorStringObject
}
impl RTDTestCallVectorStringObjectBuilder {
pub fn build(&self) -> TestCallVectorStringObject { self.inner.clone() }
pub fn x(&mut self, x: Vec<TestString>) -> &mut Self {
self.inner.x = x;
self
}
}
impl AsRef<TestCallVectorStringObject> for TestCallVectorStringObject {
fn as_ref(&self) -> &TestCallVectorStringObject { self }
}
impl AsRef<TestCallVectorStringObject> for RTDTestCallVectorStringObjectBuilder {
fn as_ref(&self) -> &TestCallVectorStringObject { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestSquareInt {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
x: i64,
}
impl RObject for TestSquareInt {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testSquareInt" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestSquareInt {}
impl TestSquareInt {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestSquareIntBuilder {
let mut inner = TestSquareInt::default();
inner.td_name = "testSquareInt".to_string();
RTDTestSquareIntBuilder { inner }
}
pub fn x(&self) -> i64 { self.x }
}
#[doc(hidden)]
pub struct RTDTestSquareIntBuilder {
inner: TestSquareInt
}
impl RTDTestSquareIntBuilder {
pub fn build(&self) -> TestSquareInt { self.inner.clone() }
pub fn x(&mut self, x: i64) -> &mut Self {
self.inner.x = x;
self
}
}
impl AsRef<TestSquareInt> for TestSquareInt {
fn as_ref(&self) -> &TestSquareInt { self }
}
impl AsRef<TestSquareInt> for RTDTestSquareIntBuilder {
fn as_ref(&self) -> &TestSquareInt { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestNetwork {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for TestNetwork {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testNetwork" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestNetwork {}
impl TestNetwork {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestNetworkBuilder {
let mut inner = TestNetwork::default();
inner.td_name = "testNetwork".to_string();
RTDTestNetworkBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDTestNetworkBuilder {
inner: TestNetwork
}
impl RTDTestNetworkBuilder {
pub fn build(&self) -> TestNetwork { self.inner.clone() }
}
impl AsRef<TestNetwork> for TestNetwork {
fn as_ref(&self) -> &TestNetwork { self }
}
impl AsRef<TestNetwork> for RTDTestNetworkBuilder {
fn as_ref(&self) -> &TestNetwork { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestGetDifference {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for TestGetDifference {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testGetDifference" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestGetDifference {}
impl TestGetDifference {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestGetDifferenceBuilder {
let mut inner = TestGetDifference::default();
inner.td_name = "testGetDifference".to_string();
RTDTestGetDifferenceBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDTestGetDifferenceBuilder {
inner: TestGetDifference
}
impl RTDTestGetDifferenceBuilder {
pub fn build(&self) -> TestGetDifference { self.inner.clone() }
}
impl AsRef<TestGetDifference> for TestGetDifference {
fn as_ref(&self) -> &TestGetDifference { self }
}
impl AsRef<TestGetDifference> for RTDTestGetDifferenceBuilder {
fn as_ref(&self) -> &TestGetDifference { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestUseUpdate {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for TestUseUpdate {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testUseUpdate" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl TDUpdate for TestUseUpdate {}
impl RFunction for TestUseUpdate {}
impl TestUseUpdate {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestUseUpdateBuilder {
let mut inner = TestUseUpdate::default();
inner.td_name = "testUseUpdate".to_string();
RTDTestUseUpdateBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDTestUseUpdateBuilder {
inner: TestUseUpdate
}
impl RTDTestUseUpdateBuilder {
pub fn build(&self) -> TestUseUpdate { self.inner.clone() }
}
impl AsRef<TestUseUpdate> for TestUseUpdate {
fn as_ref(&self) -> &TestUseUpdate { self }
}
impl AsRef<TestUseUpdate> for RTDTestUseUpdateBuilder {
fn as_ref(&self) -> &TestUseUpdate { &self.inner }
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestUseError {
#[doc(hidden)]
#[serde(rename(serialize = "@type", deserialize = "@type"))]
td_name: String,
}
impl RObject for TestUseError {
#[doc(hidden)] fn td_name(&self) -> &'static str { "testUseError" }
fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
}
impl RFunction for TestUseError {}
impl TestUseError {
pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
pub fn builder() -> RTDTestUseErrorBuilder {
let mut inner = TestUseError::default();
inner.td_name = "testUseError".to_string();
RTDTestUseErrorBuilder { inner }
}
}
#[doc(hidden)]
pub struct RTDTestUseErrorBuilder {
inner: TestUseError
}
impl RTDTestUseErrorBuilder {
pub fn build(&self) -> TestUseError { self.inner.clone() }
}
impl AsRef<TestUseError> for TestUseError {
fn as_ref(&self) -> &TestUseError { self }
}
impl AsRef<TestUseError> for RTDTestUseErrorBuilder {
fn as_ref(&self) -> &TestUseError { &self.inner }
}