1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
use serde::{Deserialize, Serialize};
/// Describes a service message about a regular gift that was sent or received.
/// # Documentation
/// <https://core.telegram.org/bots/api#giftinfo>
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct GiftInfo {
/// Information about the gift
pub gift: Box<crate::types::Gift>,
/// Unique identifier of the received gift for the bot; only present for gifts received on behalf of business accounts
#[serde(skip_serializing_if = "Option::is_none")]
pub owned_gift_id: Option<Box<str>>,
/// Number of Telegram Stars that can be claimed by the receiver by converting the gift; omitted if conversion to Telegram Stars is impossible
#[serde(skip_serializing_if = "Option::is_none")]
pub convert_star_count: Option<i64>,
/// Number of Telegram Stars that were prepaid for the ability to upgrade the gift
#[serde(skip_serializing_if = "Option::is_none")]
pub prepaid_upgrade_star_count: Option<i64>,
/// `true`, if the gift's upgrade was purchased after the gift was sent
#[serde(skip_serializing_if = "Option::is_none")]
pub is_upgrade_separate: Option<bool>,
/// `true`, if the gift can be upgraded to a unique gift
#[serde(skip_serializing_if = "Option::is_none")]
pub can_be_upgraded: Option<bool>,
/// Text of the message that was added to the gift
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<Box<str>>,
/// Special entities that appear in the text
#[serde(skip_serializing_if = "Option::is_none")]
pub entities: Option<Box<[crate::types::MessageEntity]>>,
/// `true`, if the sender and gift text are shown only to the gift receiver; otherwise, everyone will be able to see them
#[serde(skip_serializing_if = "Option::is_none")]
pub is_private: Option<bool>,
/// Unique number reserved for this gift when upgraded. See the number field in [`crate::types::UniqueGift`]
#[serde(skip_serializing_if = "Option::is_none")]
pub unique_gift_number: Option<i64>,
}
impl GiftInfo {
/// Creates a new `GiftInfo`.
///
/// # Arguments
/// * `gift` - Information about the gift
///
/// # Notes
/// Use builder methods to set optional fields.
#[must_use]
pub fn new<T0: Into<crate::types::Gift>>(gift: T0) -> Self {
Self {
gift: Box::new(gift.into()),
owned_gift_id: None,
convert_star_count: None,
prepaid_upgrade_star_count: None,
is_upgrade_separate: None,
can_be_upgraded: None,
text: None,
entities: None,
is_private: None,
unique_gift_number: None,
}
}
/// Information about the gift
#[must_use]
pub fn gift<T: Into<crate::types::Gift>>(self, val: T) -> Self {
let mut this = self;
this.gift = Box::new(val.into());
this
}
/// Unique identifier of the received gift for the bot; only present for gifts received on behalf of business accounts
#[must_use]
pub fn owned_gift_id<T: Into<Box<str>>>(self, val: T) -> Self {
let mut this = self;
this.owned_gift_id = Some(val.into());
this
}
/// Unique identifier of the received gift for the bot; only present for gifts received on behalf of business accounts
#[must_use]
pub fn owned_gift_id_option<T: Into<Box<str>>>(self, val: Option<T>) -> Self {
let mut this = self;
this.owned_gift_id = val.map(Into::into);
this
}
/// Number of Telegram Stars that can be claimed by the receiver by converting the gift; omitted if conversion to Telegram Stars is impossible
#[must_use]
pub fn convert_star_count<T: Into<i64>>(self, val: T) -> Self {
let mut this = self;
this.convert_star_count = Some(val.into());
this
}
/// Number of Telegram Stars that can be claimed by the receiver by converting the gift; omitted if conversion to Telegram Stars is impossible
#[must_use]
pub fn convert_star_count_option<T: Into<i64>>(self, val: Option<T>) -> Self {
let mut this = self;
this.convert_star_count = val.map(Into::into);
this
}
/// Number of Telegram Stars that were prepaid for the ability to upgrade the gift
#[must_use]
pub fn prepaid_upgrade_star_count<T: Into<i64>>(self, val: T) -> Self {
let mut this = self;
this.prepaid_upgrade_star_count = Some(val.into());
this
}
/// Number of Telegram Stars that were prepaid for the ability to upgrade the gift
#[must_use]
pub fn prepaid_upgrade_star_count_option<T: Into<i64>>(self, val: Option<T>) -> Self {
let mut this = self;
this.prepaid_upgrade_star_count = val.map(Into::into);
this
}
/// `true`, if the gift's upgrade was purchased after the gift was sent
#[must_use]
pub fn is_upgrade_separate<T: Into<bool>>(self, val: T) -> Self {
let mut this = self;
this.is_upgrade_separate = Some(val.into());
this
}
/// `true`, if the gift's upgrade was purchased after the gift was sent
#[must_use]
pub fn is_upgrade_separate_option<T: Into<bool>>(self, val: Option<T>) -> Self {
let mut this = self;
this.is_upgrade_separate = val.map(Into::into);
this
}
/// `true`, if the gift can be upgraded to a unique gift
#[must_use]
pub fn can_be_upgraded<T: Into<bool>>(self, val: T) -> Self {
let mut this = self;
this.can_be_upgraded = Some(val.into());
this
}
/// `true`, if the gift can be upgraded to a unique gift
#[must_use]
pub fn can_be_upgraded_option<T: Into<bool>>(self, val: Option<T>) -> Self {
let mut this = self;
this.can_be_upgraded = val.map(Into::into);
this
}
/// Text of the message that was added to the gift
#[must_use]
pub fn text<T: Into<Box<str>>>(self, val: T) -> Self {
let mut this = self;
this.text = Some(val.into());
this
}
/// Text of the message that was added to the gift
#[must_use]
pub fn text_option<T: Into<Box<str>>>(self, val: Option<T>) -> Self {
let mut this = self;
this.text = val.map(Into::into);
this
}
/// Special entities that appear in the text
///
/// # Notes
/// Adds multiple elements.
#[must_use]
pub fn entities<T: Into<Box<[crate::types::MessageEntity]>>>(self, val: T) -> Self {
let mut this = self;
this.entities = Some(
this.entities
.unwrap_or_default()
.into_vec()
.into_iter()
.chain(val.into())
.collect(),
);
this
}
/// Special entities that appear in the text
///
/// # Notes
/// Adds a single element.
#[must_use]
pub fn entity<T: Into<crate::types::MessageEntity>>(self, val: T) -> Self {
let mut this = self;
this.entities = Some(
this.entities
.unwrap_or_default()
.into_vec()
.into_iter()
.chain(Some(val.into()))
.collect(),
);
this
}
/// Special entities that appear in the text
///
/// # Notes
/// Adds a single element.
#[must_use]
pub fn entities_option<T: Into<Box<[crate::types::MessageEntity]>>>(
self,
val: Option<T>,
) -> Self {
let mut this = self;
this.entities = val.map(Into::into);
this
}
/// `true`, if the sender and gift text are shown only to the gift receiver; otherwise, everyone will be able to see them
#[must_use]
pub fn is_private<T: Into<bool>>(self, val: T) -> Self {
let mut this = self;
this.is_private = Some(val.into());
this
}
/// `true`, if the sender and gift text are shown only to the gift receiver; otherwise, everyone will be able to see them
#[must_use]
pub fn is_private_option<T: Into<bool>>(self, val: Option<T>) -> Self {
let mut this = self;
this.is_private = val.map(Into::into);
this
}
/// Unique number reserved for this gift when upgraded. See the number field in [`crate::types::UniqueGift`]
#[must_use]
pub fn unique_gift_number<T: Into<i64>>(self, val: T) -> Self {
let mut this = self;
this.unique_gift_number = Some(val.into());
this
}
/// Unique number reserved for this gift when upgraded. See the number field in [`crate::types::UniqueGift`]
#[must_use]
pub fn unique_gift_number_option<T: Into<i64>>(self, val: Option<T>) -> Self {
let mut this = self;
this.unique_gift_number = val.map(Into::into);
this
}
}