Skip to main content

slack_web_api/
objects.rs

1// このファイルは codegen/generate.py が生成する。手で編集しない
2
3//! Core Slack objects shared by many responses, inferred from the documented examples of every method.
4
5use serde::{Deserialize, Serialize};
6
7/// A message (<https://docs.slack.dev/messaging/message-structure>).
8#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
9pub struct Message {
10    #[serde(
11        default,
12        deserialize_with = "crate::de::opt_string",
13        skip_serializing_if = "Option::is_none"
14    )]
15    pub text: Option<String>,
16    #[serde(
17        default,
18        deserialize_with = "crate::de::opt_string",
19        skip_serializing_if = "Option::is_none"
20    )]
21    pub username: Option<String>,
22    #[serde(
23        default,
24        deserialize_with = "crate::de::opt_string",
25        skip_serializing_if = "Option::is_none"
26    )]
27    pub bot_id: Option<String>,
28    #[serde(
29        default,
30        deserialize_with = "crate::de::vec",
31        skip_serializing_if = "Vec::is_empty"
32    )]
33    pub attachments: Vec<MessageAttachment>,
34    #[serde(
35        default,
36        deserialize_with = "crate::de::opt_string",
37        skip_serializing_if = "Option::is_none"
38    )]
39    pub r#type: Option<String>,
40    #[serde(
41        default,
42        deserialize_with = "crate::de::opt_string",
43        skip_serializing_if = "Option::is_none"
44    )]
45    pub subtype: Option<String>,
46    #[serde(
47        default,
48        deserialize_with = "crate::de::opt_string",
49        skip_serializing_if = "Option::is_none"
50    )]
51    pub ts: Option<String>,
52    #[serde(
53        default,
54        deserialize_with = "crate::de::opt_string",
55        skip_serializing_if = "Option::is_none"
56    )]
57    pub thread_ts: Option<String>,
58    #[serde(
59        default,
60        deserialize_with = "crate::de::opt_string",
61        skip_serializing_if = "Option::is_none"
62    )]
63    pub user: Option<String>,
64    #[serde(
65        default,
66        deserialize_with = "crate::de::opt_string",
67        skip_serializing_if = "Option::is_none"
68    )]
69    pub app_id: Option<String>,
70    #[serde(
71        default,
72        deserialize_with = "crate::de::opt_string",
73        skip_serializing_if = "Option::is_none"
74    )]
75    pub team: Option<String>,
76    #[serde(
77        default,
78        deserialize_with = "crate::de::opt_string",
79        skip_serializing_if = "Option::is_none"
80    )]
81    pub channel: Option<String>,
82    #[serde(
83        default,
84        deserialize_with = "crate::de::opt_string",
85        skip_serializing_if = "Option::is_none"
86    )]
87    pub client_msg_id: Option<String>,
88    #[serde(
89        default,
90        deserialize_with = "crate::de::opt_string",
91        skip_serializing_if = "Option::is_none"
92    )]
93    pub event_ts: Option<String>,
94    #[serde(
95        default,
96        deserialize_with = "crate::de::vec",
97        skip_serializing_if = "Vec::is_empty"
98    )]
99    pub blocks: Vec<crate::blocks::Block>,
100    #[serde(
101        default,
102        deserialize_with = "crate::de::vec",
103        skip_serializing_if = "Vec::is_empty"
104    )]
105    pub files: Vec<File>,
106    #[serde(
107        default,
108        deserialize_with = "crate::de::vec",
109        skip_serializing_if = "Vec::is_empty"
110    )]
111    pub reactions: Vec<Reaction>,
112    #[serde(
113        default,
114        deserialize_with = "crate::de::opt_bool",
115        skip_serializing_if = "Option::is_none"
116    )]
117    pub upload: Option<bool>,
118    #[serde(
119        default,
120        deserialize_with = "crate::de::opt_bool",
121        skip_serializing_if = "Option::is_none"
122    )]
123    pub display_as_bot: Option<bool>,
124    #[serde(
125        default,
126        deserialize_with = "crate::de::opt_object",
127        skip_serializing_if = "Option::is_none"
128    )]
129    pub edited: Option<MessageEdited>,
130    #[serde(
131        default,
132        deserialize_with = "crate::de::opt_object",
133        skip_serializing_if = "Option::is_none"
134    )]
135    pub metadata: Option<crate::blocks::MessageMetadata>,
136    #[serde(
137        default,
138        deserialize_with = "crate::de::opt_object",
139        skip_serializing_if = "Option::is_none"
140    )]
141    pub bot_profile: Option<Bot>,
142    #[serde(
143        default,
144        deserialize_with = "crate::de::opt_i64",
145        skip_serializing_if = "Option::is_none"
146    )]
147    pub reply_count: Option<i64>,
148    #[serde(
149        default,
150        deserialize_with = "crate::de::opt_i64",
151        skip_serializing_if = "Option::is_none"
152    )]
153    pub reply_users_count: Option<i64>,
154    #[serde(
155        default,
156        deserialize_with = "crate::de::vec",
157        skip_serializing_if = "Vec::is_empty"
158    )]
159    pub reply_users: Vec<String>,
160    #[serde(
161        default,
162        deserialize_with = "crate::de::opt_string",
163        skip_serializing_if = "Option::is_none"
164    )]
165    pub latest_reply: Option<String>,
166    #[serde(
167        default,
168        deserialize_with = "crate::de::opt_string",
169        skip_serializing_if = "Option::is_none"
170    )]
171    pub parent_user_id: Option<String>,
172    #[serde(
173        default,
174        deserialize_with = "crate::de::opt_bool",
175        skip_serializing_if = "Option::is_none"
176    )]
177    pub is_locked: Option<bool>,
178    #[serde(
179        default,
180        deserialize_with = "crate::de::opt_bool",
181        skip_serializing_if = "Option::is_none"
182    )]
183    pub subscribed: Option<bool>,
184    #[serde(
185        default,
186        deserialize_with = "crate::de::opt_string",
187        skip_serializing_if = "Option::is_none"
188    )]
189    pub last_read: Option<String>,
190    #[serde(
191        default,
192        deserialize_with = "crate::de::opt_bool",
193        skip_serializing_if = "Option::is_none"
194    )]
195    pub hidden: Option<bool>,
196    #[serde(
197        default,
198        deserialize_with = "crate::de::opt_string",
199        skip_serializing_if = "Option::is_none"
200    )]
201    pub deleted_ts: Option<String>,
202    #[serde(
203        default,
204        deserialize_with = "crate::de::opt_bool",
205        skip_serializing_if = "Option::is_none"
206    )]
207    pub is_starred: Option<bool>,
208    #[serde(
209        default,
210        deserialize_with = "crate::de::vec",
211        skip_serializing_if = "Vec::is_empty"
212    )]
213    pub pinned_to: Vec<String>,
214    #[serde(
215        default,
216        deserialize_with = "crate::de::opt_string",
217        skip_serializing_if = "Option::is_none"
218    )]
219    pub permalink: Option<String>,
220    #[serde(
221        default,
222        deserialize_with = "crate::de::opt_string",
223        skip_serializing_if = "Option::is_none"
224    )]
225    pub inviter: Option<String>,
226    #[serde(
227        default,
228        deserialize_with = "crate::de::opt_string",
229        skip_serializing_if = "Option::is_none"
230    )]
231    pub purpose: Option<String>,
232    #[serde(
233        default,
234        deserialize_with = "crate::de::opt_string",
235        skip_serializing_if = "Option::is_none"
236    )]
237    pub name: Option<String>,
238    #[serde(
239        default,
240        deserialize_with = "crate::de::opt_string",
241        skip_serializing_if = "Option::is_none"
242    )]
243    pub old_name: Option<String>,
244    #[serde(
245        default,
246        deserialize_with = "crate::de::opt_string",
247        skip_serializing_if = "Option::is_none"
248    )]
249    pub user_id: Option<String>,
250    #[serde(
251        default,
252        deserialize_with = "crate::de::opt_i64",
253        skip_serializing_if = "Option::is_none"
254    )]
255    pub text_character_count: Option<i64>,
256    #[serde(
257        default,
258        deserialize_with = "crate::de::opt_i64",
259        skip_serializing_if = "Option::is_none"
260    )]
261    pub unread_count: Option<i64>,
262    #[serde(
263        default,
264        deserialize_with = "crate::de::opt_string",
265        skip_serializing_if = "Option::is_none"
266    )]
267    pub topic: Option<String>,
268    #[serde(
269        default,
270        deserialize_with = "crate::de::opt_object",
271        skip_serializing_if = "Option::is_none"
272    )]
273    pub icons: Option<Icons>,
274}
275
276#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
277pub struct MessageEdited {
278    #[serde(
279        default,
280        deserialize_with = "crate::de::opt_string",
281        skip_serializing_if = "Option::is_none"
282    )]
283    pub user: Option<String>,
284    #[serde(
285        default,
286        deserialize_with = "crate::de::opt_string",
287        skip_serializing_if = "Option::is_none"
288    )]
289    pub ts: Option<String>,
290}
291
292/// A channel, DM or multi-person DM (<https://docs.slack.dev/reference/objects/conversation-object>).
293#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
294pub struct Conversation {
295    #[serde(
296        default,
297        deserialize_with = "crate::de::opt_string",
298        skip_serializing_if = "Option::is_none"
299    )]
300    pub id: Option<String>,
301    #[serde(
302        default,
303        deserialize_with = "crate::de::opt_string",
304        skip_serializing_if = "Option::is_none"
305    )]
306    pub name: Option<String>,
307    #[serde(
308        default,
309        deserialize_with = "crate::de::opt_bool",
310        skip_serializing_if = "Option::is_none"
311    )]
312    pub is_channel: Option<bool>,
313    #[serde(
314        default,
315        deserialize_with = "crate::de::opt_i64",
316        skip_serializing_if = "Option::is_none"
317    )]
318    pub created: Option<i64>,
319    #[serde(
320        default,
321        deserialize_with = "crate::de::opt_string",
322        skip_serializing_if = "Option::is_none"
323    )]
324    pub creator: Option<String>,
325    #[serde(
326        default,
327        deserialize_with = "crate::de::opt_bool",
328        skip_serializing_if = "Option::is_none"
329    )]
330    pub is_archived: Option<bool>,
331    #[serde(
332        default,
333        deserialize_with = "crate::de::opt_bool",
334        skip_serializing_if = "Option::is_none"
335    )]
336    pub is_general: Option<bool>,
337    #[serde(
338        default,
339        deserialize_with = "crate::de::opt_string",
340        skip_serializing_if = "Option::is_none"
341    )]
342    pub name_normalized: Option<String>,
343    #[serde(
344        default,
345        deserialize_with = "crate::de::opt_bool",
346        skip_serializing_if = "Option::is_none"
347    )]
348    pub is_shared: Option<bool>,
349    #[serde(
350        default,
351        deserialize_with = "crate::de::opt_bool",
352        skip_serializing_if = "Option::is_none"
353    )]
354    pub is_org_shared: Option<bool>,
355    #[serde(
356        default,
357        deserialize_with = "crate::de::opt_bool",
358        skip_serializing_if = "Option::is_none"
359    )]
360    pub is_member: Option<bool>,
361    #[serde(
362        default,
363        deserialize_with = "crate::de::opt_bool",
364        skip_serializing_if = "Option::is_none"
365    )]
366    pub is_private: Option<bool>,
367    #[serde(
368        default,
369        deserialize_with = "crate::de::opt_bool",
370        skip_serializing_if = "Option::is_none"
371    )]
372    pub is_mpim: Option<bool>,
373    #[serde(
374        default,
375        deserialize_with = "crate::de::opt_string",
376        skip_serializing_if = "Option::is_none"
377    )]
378    pub last_read: Option<String>,
379    #[serde(
380        default,
381        deserialize_with = "crate::de::opt_object",
382        skip_serializing_if = "Option::is_none"
383    )]
384    pub latest: Option<Message>,
385    #[serde(
386        default,
387        deserialize_with = "crate::de::opt_i64",
388        skip_serializing_if = "Option::is_none"
389    )]
390    pub unread_count: Option<i64>,
391    #[serde(
392        default,
393        deserialize_with = "crate::de::opt_i64",
394        skip_serializing_if = "Option::is_none"
395    )]
396    pub unread_count_display: Option<i64>,
397    #[serde(
398        default,
399        deserialize_with = "crate::de::vec",
400        skip_serializing_if = "Vec::is_empty"
401    )]
402    pub members: Vec<String>,
403    #[serde(
404        default,
405        deserialize_with = "crate::de::opt_object",
406        skip_serializing_if = "Option::is_none"
407    )]
408    pub topic: Option<Topic>,
409    #[serde(
410        default,
411        deserialize_with = "crate::de::opt_object",
412        skip_serializing_if = "Option::is_none"
413    )]
414    pub purpose: Option<Topic>,
415    #[serde(
416        default,
417        deserialize_with = "crate::de::vec",
418        skip_serializing_if = "Vec::is_empty"
419    )]
420    pub previous_names: Vec<String>,
421    #[serde(
422        default,
423        deserialize_with = "crate::de::opt_bool",
424        skip_serializing_if = "Option::is_none"
425    )]
426    pub is_group: Option<bool>,
427    #[serde(
428        default,
429        deserialize_with = "crate::de::opt_bool",
430        skip_serializing_if = "Option::is_none"
431    )]
432    pub is_im: Option<bool>,
433    #[serde(
434        default,
435        deserialize_with = "crate::de::opt_i64",
436        skip_serializing_if = "Option::is_none"
437    )]
438    pub unlinked: Option<i64>,
439    #[serde(
440        default,
441        deserialize_with = "crate::de::opt_bool",
442        skip_serializing_if = "Option::is_none"
443    )]
444    pub is_frozen: Option<bool>,
445    #[serde(
446        default,
447        deserialize_with = "crate::de::opt_bool",
448        skip_serializing_if = "Option::is_none"
449    )]
450    pub is_pending_ext_shared: Option<bool>,
451    #[serde(
452        default,
453        deserialize_with = "crate::de::vec",
454        skip_serializing_if = "Vec::is_empty"
455    )]
456    pub pending_shared: Vec<String>,
457    #[serde(
458        default,
459        deserialize_with = "crate::de::opt_string",
460        skip_serializing_if = "Option::is_none"
461    )]
462    pub context_team_id: Option<String>,
463    #[serde(
464        default,
465        deserialize_with = "crate::de::opt_i64",
466        skip_serializing_if = "Option::is_none"
467    )]
468    pub updated: Option<i64>,
469    #[serde(default, skip_serializing_if = "Option::is_none")]
470    pub parent_conversation: Option<serde_json::Value>,
471    #[serde(
472        default,
473        deserialize_with = "crate::de::opt_bool",
474        skip_serializing_if = "Option::is_none"
475    )]
476    pub is_ext_shared: Option<bool>,
477    #[serde(
478        default,
479        deserialize_with = "crate::de::vec",
480        skip_serializing_if = "Vec::is_empty"
481    )]
482    pub shared_team_ids: Vec<String>,
483    #[serde(
484        default,
485        deserialize_with = "crate::de::vec",
486        skip_serializing_if = "Vec::is_empty"
487    )]
488    pub pending_connected_team_ids: Vec<String>,
489    #[serde(
490        default,
491        deserialize_with = "crate::de::opt_object",
492        skip_serializing_if = "Option::is_none"
493    )]
494    pub properties: Option<ConversationProperties>,
495    #[serde(
496        default,
497        deserialize_with = "crate::de::opt_string",
498        skip_serializing_if = "Option::is_none"
499    )]
500    pub user: Option<String>,
501    #[serde(
502        default,
503        deserialize_with = "crate::de::opt_bool",
504        skip_serializing_if = "Option::is_none"
505    )]
506    pub is_user_deleted: Option<bool>,
507    #[serde(
508        default,
509        deserialize_with = "crate::de::opt_bool",
510        skip_serializing_if = "Option::is_none"
511    )]
512    pub is_open: Option<bool>,
513    #[serde(
514        default,
515        deserialize_with = "crate::de::opt_bool",
516        skip_serializing_if = "Option::is_none"
517    )]
518    pub is_read_only: Option<bool>,
519    #[serde(
520        default,
521        deserialize_with = "crate::de::opt_bool",
522        skip_serializing_if = "Option::is_none"
523    )]
524    pub is_thread_only: Option<bool>,
525    #[serde(
526        default,
527        deserialize_with = "crate::de::opt_bool",
528        skip_serializing_if = "Option::is_none"
529    )]
530    pub is_starred: Option<bool>,
531    #[serde(
532        default,
533        deserialize_with = "crate::de::opt_i64",
534        skip_serializing_if = "Option::is_none"
535    )]
536    pub is_moved: Option<i64>,
537    #[serde(
538        default,
539        deserialize_with = "crate::de::opt_f64",
540        skip_serializing_if = "Option::is_none"
541    )]
542    pub priority: Option<f64>,
543    #[serde(
544        default,
545        deserialize_with = "crate::de::opt_i64",
546        skip_serializing_if = "Option::is_none"
547    )]
548    pub num_members: Option<i64>,
549    #[serde(
550        default,
551        deserialize_with = "crate::de::opt_string",
552        skip_serializing_if = "Option::is_none"
553    )]
554    pub locale: Option<String>,
555    #[serde(
556        default,
557        deserialize_with = "crate::de::opt_string",
558        skip_serializing_if = "Option::is_none"
559    )]
560    pub enterprise_id: Option<String>,
561    #[serde(
562        default,
563        deserialize_with = "crate::de::opt_string",
564        skip_serializing_if = "Option::is_none"
565    )]
566    pub conversation_host_id: Option<String>,
567    #[serde(
568        default,
569        deserialize_with = "crate::de::vec",
570        skip_serializing_if = "Vec::is_empty"
571    )]
572    pub internal_team_ids: Vec<String>,
573    #[serde(
574        default,
575        deserialize_with = "crate::de::vec",
576        skip_serializing_if = "Vec::is_empty"
577    )]
578    pub connected_team_ids: Vec<String>,
579    #[serde(
580        default,
581        deserialize_with = "crate::de::opt_i64",
582        skip_serializing_if = "Option::is_none"
583    )]
584    pub date_created: Option<i64>,
585    #[serde(
586        default,
587        deserialize_with = "crate::de::vec",
588        skip_serializing_if = "Vec::is_empty"
589    )]
590    pub connections: Vec<ConversationConnections>,
591    #[serde(
592        default,
593        deserialize_with = "crate::de::vec",
594        skip_serializing_if = "Vec::is_empty"
595    )]
596    pub pending_connections: Vec<serde_json::Value>,
597    #[serde(
598        default,
599        deserialize_with = "crate::de::vec",
600        skip_serializing_if = "Vec::is_empty"
601    )]
602    pub previous_connections: Vec<serde_json::Value>,
603}
604
605#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
606pub struct ConversationProperties {
607    #[serde(
608        default,
609        deserialize_with = "crate::de::opt_object",
610        skip_serializing_if = "Option::is_none"
611    )]
612    pub posting_restricted_to: Option<ConversationPropertiesPostingRestrictedTo>,
613    #[serde(
614        default,
615        deserialize_with = "crate::de::opt_object",
616        skip_serializing_if = "Option::is_none"
617    )]
618    pub threads_restricted_to: Option<ConversationPropertiesThreadsRestrictedTo>,
619    #[serde(
620        default,
621        deserialize_with = "crate::de::vec",
622        skip_serializing_if = "Vec::is_empty"
623    )]
624    pub tabs: Vec<ConversationPropertiesTabs>,
625    #[serde(
626        default,
627        deserialize_with = "crate::de::opt_object",
628        skip_serializing_if = "Option::is_none"
629    )]
630    pub canvas: Option<Canvas>,
631}
632
633#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
634pub struct ConversationPropertiesPostingRestrictedTo {
635    #[serde(
636        default,
637        deserialize_with = "crate::de::vec",
638        skip_serializing_if = "Vec::is_empty"
639    )]
640    pub r#type: Vec<String>,
641}
642
643#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
644pub struct ConversationPropertiesThreadsRestrictedTo {
645    #[serde(
646        default,
647        deserialize_with = "crate::de::vec",
648        skip_serializing_if = "Vec::is_empty"
649    )]
650    pub r#type: Vec<String>,
651}
652
653#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
654pub struct ConversationPropertiesTabs {
655    #[serde(
656        default,
657        deserialize_with = "crate::de::opt_string",
658        skip_serializing_if = "Option::is_none"
659    )]
660    pub id: Option<String>,
661    #[serde(
662        default,
663        deserialize_with = "crate::de::opt_string",
664        skip_serializing_if = "Option::is_none"
665    )]
666    pub label: Option<String>,
667    #[serde(
668        default,
669        deserialize_with = "crate::de::opt_string",
670        skip_serializing_if = "Option::is_none"
671    )]
672    pub r#type: Option<String>,
673}
674
675#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
676pub struct ConversationConnections {
677    #[serde(
678        default,
679        deserialize_with = "crate::de::opt_object",
680        skip_serializing_if = "Option::is_none"
681    )]
682    pub team: Option<Team>,
683    #[serde(
684        default,
685        deserialize_with = "crate::de::opt_bool",
686        skip_serializing_if = "Option::is_none"
687    )]
688    pub is_private: Option<bool>,
689}
690
691/// A user (<https://docs.slack.dev/reference/objects/user-object>).
692#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
693pub struct User {
694    #[serde(
695        default,
696        deserialize_with = "crate::de::opt_string",
697        skip_serializing_if = "Option::is_none"
698    )]
699    pub id: Option<String>,
700    #[serde(
701        default,
702        deserialize_with = "crate::de::opt_string",
703        skip_serializing_if = "Option::is_none"
704    )]
705    pub team_id: Option<String>,
706    #[serde(
707        default,
708        deserialize_with = "crate::de::opt_string",
709        skip_serializing_if = "Option::is_none"
710    )]
711    pub name: Option<String>,
712    #[serde(
713        default,
714        deserialize_with = "crate::de::opt_bool",
715        skip_serializing_if = "Option::is_none"
716    )]
717    pub deleted: Option<bool>,
718    #[serde(
719        default,
720        deserialize_with = "crate::de::opt_string",
721        skip_serializing_if = "Option::is_none"
722    )]
723    pub color: Option<String>,
724    #[serde(
725        default,
726        deserialize_with = "crate::de::opt_string",
727        skip_serializing_if = "Option::is_none"
728    )]
729    pub real_name: Option<String>,
730    #[serde(
731        default,
732        deserialize_with = "crate::de::opt_string",
733        skip_serializing_if = "Option::is_none"
734    )]
735    pub tz: Option<String>,
736    #[serde(
737        default,
738        deserialize_with = "crate::de::opt_string",
739        skip_serializing_if = "Option::is_none"
740    )]
741    pub tz_label: Option<String>,
742    #[serde(
743        default,
744        deserialize_with = "crate::de::opt_i64",
745        skip_serializing_if = "Option::is_none"
746    )]
747    pub tz_offset: Option<i64>,
748    #[serde(
749        default,
750        deserialize_with = "crate::de::opt_object",
751        skip_serializing_if = "Option::is_none"
752    )]
753    pub profile: Option<UserProfile>,
754    #[serde(
755        default,
756        deserialize_with = "crate::de::opt_bool",
757        skip_serializing_if = "Option::is_none"
758    )]
759    pub is_admin: Option<bool>,
760    #[serde(
761        default,
762        deserialize_with = "crate::de::opt_bool",
763        skip_serializing_if = "Option::is_none"
764    )]
765    pub is_owner: Option<bool>,
766    #[serde(
767        default,
768        deserialize_with = "crate::de::opt_bool",
769        skip_serializing_if = "Option::is_none"
770    )]
771    pub is_primary_owner: Option<bool>,
772    #[serde(
773        default,
774        deserialize_with = "crate::de::opt_bool",
775        skip_serializing_if = "Option::is_none"
776    )]
777    pub is_restricted: Option<bool>,
778    #[serde(
779        default,
780        deserialize_with = "crate::de::opt_bool",
781        skip_serializing_if = "Option::is_none"
782    )]
783    pub is_ultra_restricted: Option<bool>,
784    #[serde(
785        default,
786        deserialize_with = "crate::de::opt_bool",
787        skip_serializing_if = "Option::is_none"
788    )]
789    pub is_bot: Option<bool>,
790    #[serde(
791        default,
792        deserialize_with = "crate::de::opt_bool",
793        skip_serializing_if = "Option::is_none"
794    )]
795    pub is_app_user: Option<bool>,
796    #[serde(
797        default,
798        deserialize_with = "crate::de::opt_i64",
799        skip_serializing_if = "Option::is_none"
800    )]
801    pub updated: Option<i64>,
802    #[serde(
803        default,
804        deserialize_with = "crate::de::opt_bool",
805        skip_serializing_if = "Option::is_none"
806    )]
807    pub is_email_confirmed: Option<bool>,
808    #[serde(
809        default,
810        deserialize_with = "crate::de::opt_string",
811        skip_serializing_if = "Option::is_none"
812    )]
813    pub who_can_share_contact_card: Option<String>,
814    #[serde(
815        default,
816        deserialize_with = "crate::de::opt_object",
817        skip_serializing_if = "Option::is_none"
818    )]
819    pub enterprise_user: Option<UserEnterpriseUser>,
820    #[serde(
821        default,
822        deserialize_with = "crate::de::opt_string",
823        skip_serializing_if = "Option::is_none"
824    )]
825    pub enterprise_id: Option<String>,
826    #[serde(
827        default,
828        deserialize_with = "crate::de::opt_string",
829        skip_serializing_if = "Option::is_none"
830    )]
831    pub locale: Option<String>,
832    #[serde(
833        default,
834        deserialize_with = "crate::de::opt_bool",
835        skip_serializing_if = "Option::is_none"
836    )]
837    pub is_stranger: Option<bool>,
838    #[serde(
839        default,
840        deserialize_with = "crate::de::opt_bool",
841        skip_serializing_if = "Option::is_none"
842    )]
843    pub is_invited_user: Option<bool>,
844    #[serde(
845        default,
846        deserialize_with = "crate::de::opt_bool",
847        skip_serializing_if = "Option::is_none"
848    )]
849    pub is_workflow_bot: Option<bool>,
850    #[serde(
851        default,
852        deserialize_with = "crate::de::opt_bool",
853        skip_serializing_if = "Option::is_none"
854    )]
855    pub has_2fa: Option<bool>,
856    #[serde(
857        default,
858        deserialize_with = "crate::de::opt_string",
859        skip_serializing_if = "Option::is_none"
860    )]
861    pub two_factor_type: Option<String>,
862    #[serde(
863        default,
864        deserialize_with = "crate::de::opt_string",
865        skip_serializing_if = "Option::is_none"
866    )]
867    pub presence: Option<String>,
868    #[serde(
869        default,
870        deserialize_with = "crate::de::opt_bool",
871        skip_serializing_if = "Option::is_none"
872    )]
873    pub always_active: Option<bool>,
874    #[serde(
875        default,
876        deserialize_with = "crate::de::opt_string",
877        skip_serializing_if = "Option::is_none"
878    )]
879    pub email: Option<String>,
880    #[serde(
881        default,
882        deserialize_with = "crate::de::opt_string",
883        skip_serializing_if = "Option::is_none"
884    )]
885    pub username: Option<String>,
886    #[serde(
887        default,
888        deserialize_with = "crate::de::opt_string",
889        skip_serializing_if = "Option::is_none"
890    )]
891    pub full_name: Option<String>,
892    #[serde(
893        default,
894        deserialize_with = "crate::de::opt_bool",
895        skip_serializing_if = "Option::is_none"
896    )]
897    pub is_active: Option<bool>,
898    #[serde(
899        default,
900        deserialize_with = "crate::de::opt_i64",
901        skip_serializing_if = "Option::is_none"
902    )]
903    pub date_created: Option<i64>,
904    #[serde(
905        default,
906        deserialize_with = "crate::de::opt_i64",
907        skip_serializing_if = "Option::is_none"
908    )]
909    pub deactivated_ts: Option<i64>,
910    #[serde(
911        default,
912        deserialize_with = "crate::de::opt_i64",
913        skip_serializing_if = "Option::is_none"
914    )]
915    pub expiration_ts: Option<i64>,
916    #[serde(
917        default,
918        deserialize_with = "crate::de::vec",
919        skip_serializing_if = "Vec::is_empty"
920    )]
921    pub workspaces: Vec<String>,
922    #[serde(
923        default,
924        deserialize_with = "crate::de::opt_bool",
925        skip_serializing_if = "Option::is_none"
926    )]
927    pub has_sso: Option<bool>,
928}
929
930#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
931pub struct UserEnterpriseUser {
932    #[serde(
933        default,
934        deserialize_with = "crate::de::opt_string",
935        skip_serializing_if = "Option::is_none"
936    )]
937    pub id: Option<String>,
938    #[serde(
939        default,
940        deserialize_with = "crate::de::opt_string",
941        skip_serializing_if = "Option::is_none"
942    )]
943    pub enterprise_id: Option<String>,
944    #[serde(
945        default,
946        deserialize_with = "crate::de::opt_string",
947        skip_serializing_if = "Option::is_none"
948    )]
949    pub enterprise_name: Option<String>,
950    #[serde(
951        default,
952        deserialize_with = "crate::de::opt_bool",
953        skip_serializing_if = "Option::is_none"
954    )]
955    pub is_admin: Option<bool>,
956    #[serde(
957        default,
958        deserialize_with = "crate::de::opt_bool",
959        skip_serializing_if = "Option::is_none"
960    )]
961    pub is_owner: Option<bool>,
962    #[serde(
963        default,
964        deserialize_with = "crate::de::opt_bool",
965        skip_serializing_if = "Option::is_none"
966    )]
967    pub is_primary_owner: Option<bool>,
968    #[serde(
969        default,
970        deserialize_with = "crate::de::vec",
971        skip_serializing_if = "Vec::is_empty"
972    )]
973    pub teams: Vec<String>,
974}
975
976/// A user's profile.
977#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
978pub struct UserProfile {
979    #[serde(
980        default,
981        deserialize_with = "crate::de::opt_string",
982        skip_serializing_if = "Option::is_none"
983    )]
984    pub title: Option<String>,
985    #[serde(
986        default,
987        deserialize_with = "crate::de::opt_string",
988        skip_serializing_if = "Option::is_none"
989    )]
990    pub phone: Option<String>,
991    #[serde(
992        default,
993        deserialize_with = "crate::de::opt_string",
994        skip_serializing_if = "Option::is_none"
995    )]
996    pub skype: Option<String>,
997    #[serde(
998        default,
999        deserialize_with = "crate::de::opt_string",
1000        skip_serializing_if = "Option::is_none"
1001    )]
1002    pub real_name: Option<String>,
1003    #[serde(
1004        default,
1005        deserialize_with = "crate::de::opt_string",
1006        skip_serializing_if = "Option::is_none"
1007    )]
1008    pub real_name_normalized: Option<String>,
1009    #[serde(
1010        default,
1011        deserialize_with = "crate::de::opt_string",
1012        skip_serializing_if = "Option::is_none"
1013    )]
1014    pub display_name: Option<String>,
1015    #[serde(
1016        default,
1017        deserialize_with = "crate::de::opt_string",
1018        skip_serializing_if = "Option::is_none"
1019    )]
1020    pub display_name_normalized: Option<String>,
1021    #[serde(
1022        default,
1023        deserialize_with = "crate::de::opt_object",
1024        skip_serializing_if = "Option::is_none"
1025    )]
1026    pub fields: Option<std::collections::HashMap<String, UserProfileFieldsValue>>,
1027    #[serde(
1028        default,
1029        deserialize_with = "crate::de::opt_string",
1030        skip_serializing_if = "Option::is_none"
1031    )]
1032    pub status_text: Option<String>,
1033    #[serde(
1034        default,
1035        deserialize_with = "crate::de::opt_string",
1036        skip_serializing_if = "Option::is_none"
1037    )]
1038    pub status_emoji: Option<String>,
1039    #[serde(
1040        default,
1041        deserialize_with = "crate::de::vec",
1042        skip_serializing_if = "Vec::is_empty"
1043    )]
1044    pub status_emoji_display_info: Vec<UserProfileStatusEmojiDisplayInfo>,
1045    #[serde(
1046        default,
1047        deserialize_with = "crate::de::opt_i64",
1048        skip_serializing_if = "Option::is_none"
1049    )]
1050    pub status_expiration: Option<i64>,
1051    #[serde(
1052        default,
1053        deserialize_with = "crate::de::opt_string",
1054        skip_serializing_if = "Option::is_none"
1055    )]
1056    pub avatar_hash: Option<String>,
1057    #[serde(
1058        default,
1059        deserialize_with = "crate::de::opt_string",
1060        skip_serializing_if = "Option::is_none"
1061    )]
1062    pub start_date: Option<String>,
1063    #[serde(
1064        default,
1065        deserialize_with = "crate::de::opt_string",
1066        skip_serializing_if = "Option::is_none"
1067    )]
1068    pub image_original: Option<String>,
1069    #[serde(
1070        default,
1071        deserialize_with = "crate::de::opt_bool",
1072        skip_serializing_if = "Option::is_none"
1073    )]
1074    pub is_custom_image: Option<bool>,
1075    #[serde(
1076        default,
1077        deserialize_with = "crate::de::opt_string",
1078        skip_serializing_if = "Option::is_none"
1079    )]
1080    pub email: Option<String>,
1081    #[serde(
1082        default,
1083        deserialize_with = "crate::de::opt_string",
1084        skip_serializing_if = "Option::is_none"
1085    )]
1086    pub pronouns: Option<String>,
1087    #[serde(
1088        default,
1089        deserialize_with = "crate::de::opt_string",
1090        skip_serializing_if = "Option::is_none"
1091    )]
1092    pub huddle_state: Option<String>,
1093    #[serde(
1094        default,
1095        deserialize_with = "crate::de::opt_i64",
1096        skip_serializing_if = "Option::is_none"
1097    )]
1098    pub huddle_state_expiration_ts: Option<i64>,
1099    #[serde(
1100        default,
1101        deserialize_with = "crate::de::opt_string",
1102        skip_serializing_if = "Option::is_none"
1103    )]
1104    pub first_name: Option<String>,
1105    #[serde(
1106        default,
1107        deserialize_with = "crate::de::opt_string",
1108        skip_serializing_if = "Option::is_none"
1109    )]
1110    pub last_name: Option<String>,
1111    #[serde(
1112        default,
1113        deserialize_with = "crate::de::opt_string",
1114        skip_serializing_if = "Option::is_none"
1115    )]
1116    pub image_24: Option<String>,
1117    #[serde(
1118        default,
1119        deserialize_with = "crate::de::opt_string",
1120        skip_serializing_if = "Option::is_none"
1121    )]
1122    pub image_32: Option<String>,
1123    #[serde(
1124        default,
1125        deserialize_with = "crate::de::opt_string",
1126        skip_serializing_if = "Option::is_none"
1127    )]
1128    pub image_48: Option<String>,
1129    #[serde(
1130        default,
1131        deserialize_with = "crate::de::opt_string",
1132        skip_serializing_if = "Option::is_none"
1133    )]
1134    pub image_72: Option<String>,
1135    #[serde(
1136        default,
1137        deserialize_with = "crate::de::opt_string",
1138        skip_serializing_if = "Option::is_none"
1139    )]
1140    pub image_192: Option<String>,
1141    #[serde(
1142        default,
1143        deserialize_with = "crate::de::opt_string",
1144        skip_serializing_if = "Option::is_none"
1145    )]
1146    pub image_512: Option<String>,
1147    #[serde(
1148        default,
1149        deserialize_with = "crate::de::opt_string",
1150        skip_serializing_if = "Option::is_none"
1151    )]
1152    pub image_1024: Option<String>,
1153    #[serde(
1154        default,
1155        deserialize_with = "crate::de::opt_string",
1156        skip_serializing_if = "Option::is_none"
1157    )]
1158    pub status_text_canonical: Option<String>,
1159    #[serde(
1160        default,
1161        deserialize_with = "crate::de::opt_string",
1162        skip_serializing_if = "Option::is_none"
1163    )]
1164    pub team: Option<String>,
1165    #[serde(
1166        default,
1167        deserialize_with = "crate::de::opt_bool",
1168        skip_serializing_if = "Option::is_none"
1169    )]
1170    pub always_active: Option<bool>,
1171    #[serde(
1172        default,
1173        deserialize_with = "crate::de::opt_string",
1174        skip_serializing_if = "Option::is_none"
1175    )]
1176    pub bot_id: Option<String>,
1177    #[serde(
1178        default,
1179        deserialize_with = "crate::de::opt_string",
1180        skip_serializing_if = "Option::is_none"
1181    )]
1182    pub api_app_id: Option<String>,
1183}
1184
1185#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1186pub struct UserProfileFieldsValue {
1187    #[serde(
1188        default,
1189        deserialize_with = "crate::de::opt_string",
1190        skip_serializing_if = "Option::is_none"
1191    )]
1192    pub value: Option<String>,
1193    #[serde(
1194        default,
1195        deserialize_with = "crate::de::opt_string",
1196        skip_serializing_if = "Option::is_none"
1197    )]
1198    pub alt: Option<String>,
1199}
1200
1201#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1202pub struct UserProfileStatusEmojiDisplayInfo {
1203    #[serde(
1204        default,
1205        deserialize_with = "crate::de::opt_string",
1206        skip_serializing_if = "Option::is_none"
1207    )]
1208    pub emoji_name: Option<String>,
1209    #[serde(
1210        default,
1211        deserialize_with = "crate::de::opt_string",
1212        skip_serializing_if = "Option::is_none"
1213    )]
1214    pub display_url: Option<String>,
1215}
1216
1217/// A file (<https://docs.slack.dev/reference/objects/file-object>).
1218#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1219pub struct File {
1220    #[serde(
1221        default,
1222        deserialize_with = "crate::de::opt_string",
1223        skip_serializing_if = "Option::is_none"
1224    )]
1225    pub id: Option<String>,
1226    #[serde(
1227        default,
1228        deserialize_with = "crate::de::opt_i64",
1229        skip_serializing_if = "Option::is_none"
1230    )]
1231    pub created: Option<i64>,
1232    #[serde(
1233        default,
1234        deserialize_with = "crate::de::opt_i64",
1235        skip_serializing_if = "Option::is_none"
1236    )]
1237    pub timestamp: Option<i64>,
1238    #[serde(
1239        default,
1240        deserialize_with = "crate::de::opt_string",
1241        skip_serializing_if = "Option::is_none"
1242    )]
1243    pub name: Option<String>,
1244    #[serde(
1245        default,
1246        deserialize_with = "crate::de::opt_string",
1247        skip_serializing_if = "Option::is_none"
1248    )]
1249    pub title: Option<String>,
1250    #[serde(
1251        default,
1252        deserialize_with = "crate::de::opt_string",
1253        skip_serializing_if = "Option::is_none"
1254    )]
1255    pub mimetype: Option<String>,
1256    #[serde(
1257        default,
1258        deserialize_with = "crate::de::opt_string",
1259        skip_serializing_if = "Option::is_none"
1260    )]
1261    pub filetype: Option<String>,
1262    #[serde(
1263        default,
1264        deserialize_with = "crate::de::opt_string",
1265        skip_serializing_if = "Option::is_none"
1266    )]
1267    pub pretty_type: Option<String>,
1268    #[serde(
1269        default,
1270        deserialize_with = "crate::de::opt_string",
1271        skip_serializing_if = "Option::is_none"
1272    )]
1273    pub user: Option<String>,
1274    #[serde(
1275        default,
1276        deserialize_with = "crate::de::opt_bool",
1277        skip_serializing_if = "Option::is_none"
1278    )]
1279    pub editable: Option<bool>,
1280    #[serde(
1281        default,
1282        deserialize_with = "crate::de::opt_i64",
1283        skip_serializing_if = "Option::is_none"
1284    )]
1285    pub size: Option<i64>,
1286    #[serde(
1287        default,
1288        deserialize_with = "crate::de::opt_string",
1289        skip_serializing_if = "Option::is_none"
1290    )]
1291    pub mode: Option<String>,
1292    #[serde(
1293        default,
1294        deserialize_with = "crate::de::opt_bool",
1295        skip_serializing_if = "Option::is_none"
1296    )]
1297    pub is_external: Option<bool>,
1298    #[serde(
1299        default,
1300        deserialize_with = "crate::de::opt_string",
1301        skip_serializing_if = "Option::is_none"
1302    )]
1303    pub external_type: Option<String>,
1304    #[serde(
1305        default,
1306        deserialize_with = "crate::de::opt_bool",
1307        skip_serializing_if = "Option::is_none"
1308    )]
1309    pub is_public: Option<bool>,
1310    #[serde(
1311        default,
1312        deserialize_with = "crate::de::opt_bool",
1313        skip_serializing_if = "Option::is_none"
1314    )]
1315    pub public_url_shared: Option<bool>,
1316    #[serde(
1317        default,
1318        deserialize_with = "crate::de::opt_bool",
1319        skip_serializing_if = "Option::is_none"
1320    )]
1321    pub display_as_bot: Option<bool>,
1322    #[serde(
1323        default,
1324        deserialize_with = "crate::de::opt_string",
1325        skip_serializing_if = "Option::is_none"
1326    )]
1327    pub username: Option<String>,
1328    #[serde(
1329        default,
1330        deserialize_with = "crate::de::opt_string",
1331        skip_serializing_if = "Option::is_none"
1332    )]
1333    pub url_private: Option<String>,
1334    #[serde(
1335        default,
1336        deserialize_with = "crate::de::opt_string",
1337        skip_serializing_if = "Option::is_none"
1338    )]
1339    pub url_private_download: Option<String>,
1340    #[serde(
1341        default,
1342        deserialize_with = "crate::de::opt_string",
1343        skip_serializing_if = "Option::is_none"
1344    )]
1345    pub thumb_64: Option<String>,
1346    #[serde(
1347        default,
1348        deserialize_with = "crate::de::opt_string",
1349        skip_serializing_if = "Option::is_none"
1350    )]
1351    pub thumb_80: Option<String>,
1352    #[serde(
1353        default,
1354        deserialize_with = "crate::de::opt_string",
1355        skip_serializing_if = "Option::is_none"
1356    )]
1357    pub thumb_360: Option<String>,
1358    #[serde(
1359        default,
1360        deserialize_with = "crate::de::opt_i64",
1361        skip_serializing_if = "Option::is_none"
1362    )]
1363    pub thumb_360_w: Option<i64>,
1364    #[serde(
1365        default,
1366        deserialize_with = "crate::de::opt_i64",
1367        skip_serializing_if = "Option::is_none"
1368    )]
1369    pub thumb_360_h: Option<i64>,
1370    #[serde(
1371        default,
1372        deserialize_with = "crate::de::opt_string",
1373        skip_serializing_if = "Option::is_none"
1374    )]
1375    pub thumb_160: Option<String>,
1376    #[serde(
1377        default,
1378        deserialize_with = "crate::de::opt_string",
1379        skip_serializing_if = "Option::is_none"
1380    )]
1381    pub thumb_360_gif: Option<String>,
1382    #[serde(
1383        default,
1384        deserialize_with = "crate::de::opt_i64",
1385        skip_serializing_if = "Option::is_none"
1386    )]
1387    pub image_exif_rotation: Option<i64>,
1388    #[serde(
1389        default,
1390        deserialize_with = "crate::de::opt_i64",
1391        skip_serializing_if = "Option::is_none"
1392    )]
1393    pub original_w: Option<i64>,
1394    #[serde(
1395        default,
1396        deserialize_with = "crate::de::opt_i64",
1397        skip_serializing_if = "Option::is_none"
1398    )]
1399    pub original_h: Option<i64>,
1400    #[serde(
1401        default,
1402        deserialize_with = "crate::de::opt_string",
1403        skip_serializing_if = "Option::is_none"
1404    )]
1405    pub deanimate_gif: Option<String>,
1406    #[serde(
1407        default,
1408        deserialize_with = "crate::de::opt_string",
1409        skip_serializing_if = "Option::is_none"
1410    )]
1411    pub pjpeg: Option<String>,
1412    #[serde(
1413        default,
1414        deserialize_with = "crate::de::opt_string",
1415        skip_serializing_if = "Option::is_none"
1416    )]
1417    pub permalink: Option<String>,
1418    #[serde(
1419        default,
1420        deserialize_with = "crate::de::opt_string",
1421        skip_serializing_if = "Option::is_none"
1422    )]
1423    pub permalink_public: Option<String>,
1424    #[serde(
1425        default,
1426        deserialize_with = "crate::de::opt_i64",
1427        skip_serializing_if = "Option::is_none"
1428    )]
1429    pub comments_count: Option<i64>,
1430    #[serde(
1431        default,
1432        deserialize_with = "crate::de::opt_bool",
1433        skip_serializing_if = "Option::is_none"
1434    )]
1435    pub is_starred: Option<bool>,
1436    #[serde(
1437        default,
1438        deserialize_with = "crate::de::opt_object",
1439        skip_serializing_if = "Option::is_none"
1440    )]
1441    pub shares: Option<FileShares>,
1442    #[serde(
1443        default,
1444        deserialize_with = "crate::de::vec",
1445        skip_serializing_if = "Vec::is_empty"
1446    )]
1447    pub channels: Vec<String>,
1448    #[serde(
1449        default,
1450        deserialize_with = "crate::de::vec",
1451        skip_serializing_if = "Vec::is_empty"
1452    )]
1453    pub groups: Vec<String>,
1454    #[serde(
1455        default,
1456        deserialize_with = "crate::de::vec",
1457        skip_serializing_if = "Vec::is_empty"
1458    )]
1459    pub ims: Vec<String>,
1460    #[serde(
1461        default,
1462        deserialize_with = "crate::de::opt_bool",
1463        skip_serializing_if = "Option::is_none"
1464    )]
1465    pub has_rich_preview: Option<bool>,
1466    #[serde(
1467        default,
1468        deserialize_with = "crate::de::opt_string",
1469        skip_serializing_if = "Option::is_none"
1470    )]
1471    pub file_access: Option<String>,
1472    #[serde(
1473        default,
1474        deserialize_with = "crate::de::opt_string",
1475        skip_serializing_if = "Option::is_none"
1476    )]
1477    pub user_team: Option<String>,
1478    #[serde(
1479        default,
1480        deserialize_with = "crate::de::opt_string",
1481        skip_serializing_if = "Option::is_none"
1482    )]
1483    pub edit_link: Option<String>,
1484    #[serde(
1485        default,
1486        deserialize_with = "crate::de::opt_string",
1487        skip_serializing_if = "Option::is_none"
1488    )]
1489    pub preview: Option<String>,
1490    #[serde(
1491        default,
1492        deserialize_with = "crate::de::opt_string",
1493        skip_serializing_if = "Option::is_none"
1494    )]
1495    pub preview_highlight: Option<String>,
1496    #[serde(
1497        default,
1498        deserialize_with = "crate::de::opt_i64",
1499        skip_serializing_if = "Option::is_none"
1500    )]
1501    pub lines: Option<i64>,
1502    #[serde(
1503        default,
1504        deserialize_with = "crate::de::opt_i64",
1505        skip_serializing_if = "Option::is_none"
1506    )]
1507    pub lines_more: Option<i64>,
1508    #[serde(
1509        default,
1510        deserialize_with = "crate::de::opt_bool",
1511        skip_serializing_if = "Option::is_none"
1512    )]
1513    pub preview_is_truncated: Option<bool>,
1514    #[serde(
1515        default,
1516        deserialize_with = "crate::de::opt_string",
1517        skip_serializing_if = "Option::is_none"
1518    )]
1519    pub alt_txt: Option<String>,
1520    #[serde(
1521        default,
1522        deserialize_with = "crate::de::opt_string",
1523        skip_serializing_if = "Option::is_none"
1524    )]
1525    pub media_display_type: Option<String>,
1526    #[serde(
1527        default,
1528        deserialize_with = "crate::de::opt_bool",
1529        skip_serializing_if = "Option::is_none"
1530    )]
1531    pub has_more_shares: Option<bool>,
1532    #[serde(
1533        default,
1534        deserialize_with = "crate::de::opt_string",
1535        skip_serializing_if = "Option::is_none"
1536    )]
1537    pub external_id: Option<String>,
1538    #[serde(
1539        default,
1540        deserialize_with = "crate::de::opt_string",
1541        skip_serializing_if = "Option::is_none"
1542    )]
1543    pub external_url: Option<String>,
1544}
1545
1546#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1547pub struct FileShares {
1548    #[serde(
1549        default,
1550        deserialize_with = "crate::de::opt_object",
1551        skip_serializing_if = "Option::is_none"
1552    )]
1553    pub public: Option<std::collections::HashMap<String, Vec<FileSharesPublicValue>>>,
1554}
1555
1556#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1557pub struct FileSharesPublicValue {
1558    #[serde(
1559        default,
1560        deserialize_with = "crate::de::vec",
1561        skip_serializing_if = "Vec::is_empty"
1562    )]
1563    pub reply_users: Vec<String>,
1564    #[serde(
1565        default,
1566        deserialize_with = "crate::de::opt_i64",
1567        skip_serializing_if = "Option::is_none"
1568    )]
1569    pub reply_users_count: Option<i64>,
1570    #[serde(
1571        default,
1572        deserialize_with = "crate::de::opt_i64",
1573        skip_serializing_if = "Option::is_none"
1574    )]
1575    pub reply_count: Option<i64>,
1576    #[serde(
1577        default,
1578        deserialize_with = "crate::de::opt_string",
1579        skip_serializing_if = "Option::is_none"
1580    )]
1581    pub ts: Option<String>,
1582    #[serde(
1583        default,
1584        deserialize_with = "crate::de::opt_string",
1585        skip_serializing_if = "Option::is_none"
1586    )]
1587    pub thread_ts: Option<String>,
1588    #[serde(
1589        default,
1590        deserialize_with = "crate::de::opt_string",
1591        skip_serializing_if = "Option::is_none"
1592    )]
1593    pub latest_reply: Option<String>,
1594    #[serde(
1595        default,
1596        deserialize_with = "crate::de::opt_string",
1597        skip_serializing_if = "Option::is_none"
1598    )]
1599    pub channel_name: Option<String>,
1600    #[serde(
1601        default,
1602        deserialize_with = "crate::de::opt_string",
1603        skip_serializing_if = "Option::is_none"
1604    )]
1605    pub team_id: Option<String>,
1606    #[serde(
1607        default,
1608        deserialize_with = "crate::de::opt_string",
1609        skip_serializing_if = "Option::is_none"
1610    )]
1611    pub share_user_id: Option<String>,
1612    #[serde(
1613        default,
1614        deserialize_with = "crate::de::opt_string",
1615        skip_serializing_if = "Option::is_none"
1616    )]
1617    pub source: Option<String>,
1618}
1619
1620/// A user group (<https://docs.slack.dev/reference/objects/usergroup-object>).
1621#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1622pub struct Usergroup {
1623    #[serde(
1624        default,
1625        deserialize_with = "crate::de::opt_string",
1626        skip_serializing_if = "Option::is_none"
1627    )]
1628    pub id: Option<String>,
1629    #[serde(
1630        default,
1631        deserialize_with = "crate::de::opt_string",
1632        skip_serializing_if = "Option::is_none"
1633    )]
1634    pub team_id: Option<String>,
1635    #[serde(
1636        default,
1637        deserialize_with = "crate::de::opt_bool",
1638        skip_serializing_if = "Option::is_none"
1639    )]
1640    pub is_usergroup: Option<bool>,
1641    #[serde(
1642        default,
1643        deserialize_with = "crate::de::opt_string",
1644        skip_serializing_if = "Option::is_none"
1645    )]
1646    pub name: Option<String>,
1647    #[serde(
1648        default,
1649        deserialize_with = "crate::de::opt_string",
1650        skip_serializing_if = "Option::is_none"
1651    )]
1652    pub description: Option<String>,
1653    #[serde(
1654        default,
1655        deserialize_with = "crate::de::opt_string",
1656        skip_serializing_if = "Option::is_none"
1657    )]
1658    pub handle: Option<String>,
1659    #[serde(
1660        default,
1661        deserialize_with = "crate::de::opt_bool",
1662        skip_serializing_if = "Option::is_none"
1663    )]
1664    pub is_external: Option<bool>,
1665    #[serde(
1666        default,
1667        deserialize_with = "crate::de::opt_i64",
1668        skip_serializing_if = "Option::is_none"
1669    )]
1670    pub date_create: Option<i64>,
1671    #[serde(
1672        default,
1673        deserialize_with = "crate::de::opt_i64",
1674        skip_serializing_if = "Option::is_none"
1675    )]
1676    pub date_update: Option<i64>,
1677    #[serde(
1678        default,
1679        deserialize_with = "crate::de::opt_i64",
1680        skip_serializing_if = "Option::is_none"
1681    )]
1682    pub date_delete: Option<i64>,
1683    #[serde(
1684        default,
1685        deserialize_with = "crate::de::opt_string",
1686        skip_serializing_if = "Option::is_none"
1687    )]
1688    pub auto_type: Option<String>,
1689    #[serde(
1690        default,
1691        deserialize_with = "crate::de::opt_string",
1692        skip_serializing_if = "Option::is_none"
1693    )]
1694    pub created_by: Option<String>,
1695    #[serde(
1696        default,
1697        deserialize_with = "crate::de::opt_string",
1698        skip_serializing_if = "Option::is_none"
1699    )]
1700    pub updated_by: Option<String>,
1701    #[serde(
1702        default,
1703        deserialize_with = "crate::de::opt_string",
1704        skip_serializing_if = "Option::is_none"
1705    )]
1706    pub deleted_by: Option<String>,
1707    #[serde(
1708        default,
1709        deserialize_with = "crate::de::opt_object",
1710        skip_serializing_if = "Option::is_none"
1711    )]
1712    pub prefs: Option<UsergroupPrefs>,
1713    #[serde(
1714        default,
1715        deserialize_with = "crate::de::vec",
1716        skip_serializing_if = "Vec::is_empty"
1717    )]
1718    pub users: Vec<String>,
1719    #[serde(
1720        default,
1721        deserialize_with = "crate::de::opt_i64",
1722        skip_serializing_if = "Option::is_none"
1723    )]
1724    pub user_count: Option<i64>,
1725    #[serde(
1726        default,
1727        deserialize_with = "crate::de::opt_string",
1728        skip_serializing_if = "Option::is_none"
1729    )]
1730    pub enterprise_id: Option<String>,
1731    #[serde(
1732        default,
1733        deserialize_with = "crate::de::opt_bool",
1734        skip_serializing_if = "Option::is_none"
1735    )]
1736    pub is_subteam: Option<bool>,
1737    #[serde(
1738        default,
1739        deserialize_with = "crate::de::opt_bool",
1740        skip_serializing_if = "Option::is_none"
1741    )]
1742    pub auto_provision: Option<bool>,
1743    #[serde(
1744        default,
1745        deserialize_with = "crate::de::opt_string",
1746        skip_serializing_if = "Option::is_none"
1747    )]
1748    pub enterprise_subteam_id: Option<String>,
1749    #[serde(
1750        default,
1751        deserialize_with = "crate::de::opt_bool",
1752        skip_serializing_if = "Option::is_none"
1753    )]
1754    pub is_section: Option<bool>,
1755    #[serde(
1756        default,
1757        deserialize_with = "crate::de::opt_bool",
1758        skip_serializing_if = "Option::is_none"
1759    )]
1760    pub is_editing_restricted: Option<bool>,
1761    #[serde(
1762        default,
1763        deserialize_with = "crate::de::opt_bool",
1764        skip_serializing_if = "Option::is_none"
1765    )]
1766    pub is_membership_locked: Option<bool>,
1767    #[serde(
1768        default,
1769        deserialize_with = "crate::de::opt_bool",
1770        skip_serializing_if = "Option::is_none"
1771    )]
1772    pub is_idp_group: Option<bool>,
1773    #[serde(
1774        default,
1775        deserialize_with = "crate::de::opt_bool",
1776        skip_serializing_if = "Option::is_none"
1777    )]
1778    pub is_visible: Option<bool>,
1779    #[serde(
1780        default,
1781        deserialize_with = "crate::de::opt_bool",
1782        skip_serializing_if = "Option::is_none"
1783    )]
1784    pub is_org_level: Option<bool>,
1785    #[serde(
1786        default,
1787        deserialize_with = "crate::de::opt_i64",
1788        skip_serializing_if = "Option::is_none"
1789    )]
1790    pub channel_count: Option<i64>,
1791    #[serde(
1792        default,
1793        deserialize_with = "crate::de::vec",
1794        skip_serializing_if = "Vec::is_empty"
1795    )]
1796    pub teams: Vec<String>,
1797}
1798
1799#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1800pub struct UsergroupPrefs {
1801    #[serde(
1802        default,
1803        deserialize_with = "crate::de::vec",
1804        skip_serializing_if = "Vec::is_empty"
1805    )]
1806    pub channels: Vec<serde_json::Value>,
1807    #[serde(
1808        default,
1809        deserialize_with = "crate::de::vec",
1810        skip_serializing_if = "Vec::is_empty"
1811    )]
1812    pub groups: Vec<serde_json::Value>,
1813}
1814
1815/// A workspace.
1816#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1817pub struct Team {
1818    #[serde(
1819        default,
1820        deserialize_with = "crate::de::opt_string",
1821        skip_serializing_if = "Option::is_none"
1822    )]
1823    pub id: Option<String>,
1824    #[serde(
1825        default,
1826        deserialize_with = "crate::de::opt_string",
1827        skip_serializing_if = "Option::is_none"
1828    )]
1829    pub name: Option<String>,
1830    #[serde(
1831        default,
1832        deserialize_with = "crate::de::opt_string",
1833        skip_serializing_if = "Option::is_none"
1834    )]
1835    pub domain: Option<String>,
1836    #[serde(
1837        default,
1838        deserialize_with = "crate::de::opt_object",
1839        skip_serializing_if = "Option::is_none"
1840    )]
1841    pub icon: Option<Icons>,
1842    #[serde(
1843        default,
1844        deserialize_with = "crate::de::opt_bool",
1845        skip_serializing_if = "Option::is_none"
1846    )]
1847    pub is_verified: Option<bool>,
1848    #[serde(
1849        default,
1850        deserialize_with = "crate::de::opt_i64",
1851        skip_serializing_if = "Option::is_none"
1852    )]
1853    pub date_created: Option<i64>,
1854    #[serde(
1855        default,
1856        deserialize_with = "crate::de::opt_string",
1857        skip_serializing_if = "Option::is_none"
1858    )]
1859    pub avatar_base_url: Option<String>,
1860    #[serde(
1861        default,
1862        deserialize_with = "crate::de::opt_bool",
1863        skip_serializing_if = "Option::is_none"
1864    )]
1865    pub requires_sponsorship: Option<bool>,
1866    #[serde(
1867        default,
1868        deserialize_with = "crate::de::opt_string",
1869        skip_serializing_if = "Option::is_none"
1870    )]
1871    pub email_domain: Option<String>,
1872    #[serde(
1873        default,
1874        deserialize_with = "crate::de::opt_string",
1875        skip_serializing_if = "Option::is_none"
1876    )]
1877    pub enterprise_id: Option<String>,
1878    #[serde(
1879        default,
1880        deserialize_with = "crate::de::opt_string",
1881        skip_serializing_if = "Option::is_none"
1882    )]
1883    pub enterprise_name: Option<String>,
1884}
1885
1886/// A bot.
1887#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1888pub struct Bot {
1889    #[serde(
1890        default,
1891        deserialize_with = "crate::de::opt_string",
1892        skip_serializing_if = "Option::is_none"
1893    )]
1894    pub id: Option<String>,
1895    #[serde(
1896        default,
1897        deserialize_with = "crate::de::opt_bool",
1898        skip_serializing_if = "Option::is_none"
1899    )]
1900    pub deleted: Option<bool>,
1901    #[serde(
1902        default,
1903        deserialize_with = "crate::de::opt_string",
1904        skip_serializing_if = "Option::is_none"
1905    )]
1906    pub name: Option<String>,
1907    #[serde(
1908        default,
1909        deserialize_with = "crate::de::opt_i64",
1910        skip_serializing_if = "Option::is_none"
1911    )]
1912    pub updated: Option<i64>,
1913    #[serde(
1914        default,
1915        deserialize_with = "crate::de::opt_string",
1916        skip_serializing_if = "Option::is_none"
1917    )]
1918    pub app_id: Option<String>,
1919    #[serde(
1920        default,
1921        deserialize_with = "crate::de::opt_object",
1922        skip_serializing_if = "Option::is_none"
1923    )]
1924    pub icons: Option<Icons>,
1925    #[serde(
1926        default,
1927        deserialize_with = "crate::de::opt_string",
1928        skip_serializing_if = "Option::is_none"
1929    )]
1930    pub team_id: Option<String>,
1931    #[serde(
1932        default,
1933        deserialize_with = "crate::de::opt_string",
1934        skip_serializing_if = "Option::is_none"
1935    )]
1936    pub user_id: Option<String>,
1937}
1938
1939/// A reminder.
1940#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1941pub struct Reminder {
1942    #[serde(
1943        default,
1944        deserialize_with = "crate::de::opt_string",
1945        skip_serializing_if = "Option::is_none"
1946    )]
1947    pub id: Option<String>,
1948    #[serde(
1949        default,
1950        deserialize_with = "crate::de::opt_string",
1951        skip_serializing_if = "Option::is_none"
1952    )]
1953    pub creator: Option<String>,
1954    #[serde(
1955        default,
1956        deserialize_with = "crate::de::opt_string",
1957        skip_serializing_if = "Option::is_none"
1958    )]
1959    pub user: Option<String>,
1960    #[serde(
1961        default,
1962        deserialize_with = "crate::de::opt_string",
1963        skip_serializing_if = "Option::is_none"
1964    )]
1965    pub text: Option<String>,
1966    #[serde(
1967        default,
1968        deserialize_with = "crate::de::opt_bool",
1969        skip_serializing_if = "Option::is_none"
1970    )]
1971    pub recurring: Option<bool>,
1972    #[serde(
1973        default,
1974        deserialize_with = "crate::de::opt_i64",
1975        skip_serializing_if = "Option::is_none"
1976    )]
1977    pub time: Option<i64>,
1978    #[serde(
1979        default,
1980        deserialize_with = "crate::de::opt_i64",
1981        skip_serializing_if = "Option::is_none"
1982    )]
1983    pub complete_ts: Option<i64>,
1984}
1985
1986/// A channel bookmark.
1987#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1988pub struct Bookmark {
1989    #[serde(
1990        default,
1991        deserialize_with = "crate::de::opt_string",
1992        skip_serializing_if = "Option::is_none"
1993    )]
1994    pub id: Option<String>,
1995    #[serde(
1996        default,
1997        deserialize_with = "crate::de::opt_string",
1998        skip_serializing_if = "Option::is_none"
1999    )]
2000    pub channel_id: Option<String>,
2001    #[serde(
2002        default,
2003        deserialize_with = "crate::de::opt_string",
2004        skip_serializing_if = "Option::is_none"
2005    )]
2006    pub title: Option<String>,
2007    #[serde(
2008        default,
2009        deserialize_with = "crate::de::opt_string",
2010        skip_serializing_if = "Option::is_none"
2011    )]
2012    pub link: Option<String>,
2013    #[serde(
2014        default,
2015        deserialize_with = "crate::de::opt_string",
2016        skip_serializing_if = "Option::is_none"
2017    )]
2018    pub emoji: Option<String>,
2019    #[serde(
2020        default,
2021        deserialize_with = "crate::de::opt_string",
2022        skip_serializing_if = "Option::is_none"
2023    )]
2024    pub icon_url: Option<String>,
2025    #[serde(
2026        default,
2027        deserialize_with = "crate::de::opt_string",
2028        skip_serializing_if = "Option::is_none"
2029    )]
2030    pub r#type: Option<String>,
2031    #[serde(default, skip_serializing_if = "Option::is_none")]
2032    pub entity_id: Option<serde_json::Value>,
2033    #[serde(
2034        default,
2035        deserialize_with = "crate::de::opt_i64",
2036        skip_serializing_if = "Option::is_none"
2037    )]
2038    pub date_created: Option<i64>,
2039    #[serde(
2040        default,
2041        deserialize_with = "crate::de::opt_i64",
2042        skip_serializing_if = "Option::is_none"
2043    )]
2044    pub date_updated: Option<i64>,
2045    #[serde(
2046        default,
2047        deserialize_with = "crate::de::opt_string",
2048        skip_serializing_if = "Option::is_none"
2049    )]
2050    pub rank: Option<String>,
2051    #[serde(
2052        default,
2053        deserialize_with = "crate::de::opt_string",
2054        skip_serializing_if = "Option::is_none"
2055    )]
2056    pub last_updated_by_user_id: Option<String>,
2057    #[serde(
2058        default,
2059        deserialize_with = "crate::de::opt_string",
2060        skip_serializing_if = "Option::is_none"
2061    )]
2062    pub last_updated_by_team_id: Option<String>,
2063    #[serde(default, skip_serializing_if = "Option::is_none")]
2064    pub shortcut_id: Option<serde_json::Value>,
2065    #[serde(default, skip_serializing_if = "Option::is_none")]
2066    pub app_id: Option<serde_json::Value>,
2067}
2068
2069/// A view as returned by Slack. To send a view, use [`crate::blocks::View`].
2070#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2071pub struct ViewInfo {
2072    #[serde(
2073        default,
2074        deserialize_with = "crate::de::opt_string",
2075        skip_serializing_if = "Option::is_none"
2076    )]
2077    pub id: Option<String>,
2078    #[serde(
2079        default,
2080        deserialize_with = "crate::de::opt_string",
2081        skip_serializing_if = "Option::is_none"
2082    )]
2083    pub team_id: Option<String>,
2084    #[serde(
2085        default,
2086        deserialize_with = "crate::de::opt_string",
2087        skip_serializing_if = "Option::is_none"
2088    )]
2089    pub r#type: Option<String>,
2090    #[serde(
2091        default,
2092        deserialize_with = "crate::de::opt_object",
2093        skip_serializing_if = "Option::is_none"
2094    )]
2095    pub title: Option<ViewInfoTitle>,
2096    #[serde(
2097        default,
2098        deserialize_with = "crate::de::opt_object",
2099        skip_serializing_if = "Option::is_none"
2100    )]
2101    pub submit: Option<ViewInfoSubmit>,
2102    #[serde(
2103        default,
2104        deserialize_with = "crate::de::vec",
2105        skip_serializing_if = "Vec::is_empty"
2106    )]
2107    pub blocks: Vec<crate::blocks::Block>,
2108    #[serde(
2109        default,
2110        deserialize_with = "crate::de::opt_string",
2111        skip_serializing_if = "Option::is_none"
2112    )]
2113    pub private_metadata: Option<String>,
2114    #[serde(
2115        default,
2116        deserialize_with = "crate::de::opt_string",
2117        skip_serializing_if = "Option::is_none"
2118    )]
2119    pub callback_id: Option<String>,
2120    #[serde(
2121        default,
2122        deserialize_with = "crate::de::opt_string",
2123        skip_serializing_if = "Option::is_none"
2124    )]
2125    pub external_id: Option<String>,
2126    #[serde(
2127        default,
2128        deserialize_with = "crate::de::opt_object",
2129        skip_serializing_if = "Option::is_none"
2130    )]
2131    pub state: Option<ViewInfoState>,
2132    #[serde(
2133        default,
2134        deserialize_with = "crate::de::opt_string",
2135        skip_serializing_if = "Option::is_none"
2136    )]
2137    pub hash: Option<String>,
2138    #[serde(
2139        default,
2140        deserialize_with = "crate::de::opt_bool",
2141        skip_serializing_if = "Option::is_none"
2142    )]
2143    pub clear_on_close: Option<bool>,
2144    #[serde(
2145        default,
2146        deserialize_with = "crate::de::opt_bool",
2147        skip_serializing_if = "Option::is_none"
2148    )]
2149    pub notify_on_close: Option<bool>,
2150    #[serde(
2151        default,
2152        deserialize_with = "crate::de::opt_string",
2153        skip_serializing_if = "Option::is_none"
2154    )]
2155    pub root_view_id: Option<String>,
2156    #[serde(
2157        default,
2158        deserialize_with = "crate::de::opt_string",
2159        skip_serializing_if = "Option::is_none"
2160    )]
2161    pub app_id: Option<String>,
2162    #[serde(
2163        default,
2164        deserialize_with = "crate::de::opt_string",
2165        skip_serializing_if = "Option::is_none"
2166    )]
2167    pub bot_id: Option<String>,
2168    #[serde(
2169        default,
2170        deserialize_with = "crate::de::opt_object",
2171        skip_serializing_if = "Option::is_none"
2172    )]
2173    pub close: Option<ViewInfoClose>,
2174    #[serde(default, skip_serializing_if = "Option::is_none")]
2175    pub previous_view_id: Option<serde_json::Value>,
2176}
2177
2178#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2179pub struct ViewInfoTitle {
2180    #[serde(
2181        default,
2182        deserialize_with = "crate::de::opt_string",
2183        skip_serializing_if = "Option::is_none"
2184    )]
2185    pub r#type: Option<String>,
2186    #[serde(
2187        default,
2188        deserialize_with = "crate::de::opt_string",
2189        skip_serializing_if = "Option::is_none"
2190    )]
2191    pub text: Option<String>,
2192    #[serde(
2193        default,
2194        deserialize_with = "crate::de::opt_bool",
2195        skip_serializing_if = "Option::is_none"
2196    )]
2197    pub emoji: Option<bool>,
2198}
2199
2200#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2201pub struct ViewInfoSubmit {
2202    #[serde(
2203        default,
2204        deserialize_with = "crate::de::opt_string",
2205        skip_serializing_if = "Option::is_none"
2206    )]
2207    pub r#type: Option<String>,
2208    #[serde(
2209        default,
2210        deserialize_with = "crate::de::opt_string",
2211        skip_serializing_if = "Option::is_none"
2212    )]
2213    pub text: Option<String>,
2214    #[serde(
2215        default,
2216        deserialize_with = "crate::de::opt_bool",
2217        skip_serializing_if = "Option::is_none"
2218    )]
2219    pub emoji: Option<bool>,
2220}
2221
2222#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2223pub struct ViewInfoState {
2224    #[serde(
2225        default,
2226        deserialize_with = "crate::de::opt_object",
2227        skip_serializing_if = "Option::is_none"
2228    )]
2229    pub values: Option<
2230        std::collections::HashMap<String, std::collections::HashMap<String, serde_json::Value>>,
2231    >,
2232}
2233
2234#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2235pub struct ViewInfoClose {
2236    #[serde(
2237        default,
2238        deserialize_with = "crate::de::opt_string",
2239        skip_serializing_if = "Option::is_none"
2240    )]
2241    pub r#type: Option<String>,
2242    #[serde(
2243        default,
2244        deserialize_with = "crate::de::opt_string",
2245        skip_serializing_if = "Option::is_none"
2246    )]
2247    pub text: Option<String>,
2248    #[serde(
2249        default,
2250        deserialize_with = "crate::de::opt_bool",
2251        skip_serializing_if = "Option::is_none"
2252    )]
2253    pub emoji: Option<bool>,
2254}
2255
2256/// An emoji reaction.
2257#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2258pub struct Reaction {
2259    #[serde(
2260        default,
2261        deserialize_with = "crate::de::opt_string",
2262        skip_serializing_if = "Option::is_none"
2263    )]
2264    pub name: Option<String>,
2265    #[serde(
2266        default,
2267        deserialize_with = "crate::de::opt_i64",
2268        skip_serializing_if = "Option::is_none"
2269    )]
2270    pub count: Option<i64>,
2271    #[serde(
2272        default,
2273        deserialize_with = "crate::de::vec",
2274        skip_serializing_if = "Vec::is_empty"
2275    )]
2276    pub users: Vec<String>,
2277}
2278
2279/// A legacy attachment on a received message. To send one, use [`crate::blocks::Attachment`].
2280#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2281pub struct MessageAttachment {
2282    #[serde(
2283        default,
2284        deserialize_with = "crate::de::opt_string",
2285        skip_serializing_if = "Option::is_none"
2286    )]
2287    pub text: Option<String>,
2288    #[serde(
2289        default,
2290        deserialize_with = "crate::de::opt_i64",
2291        skip_serializing_if = "Option::is_none"
2292    )]
2293    pub id: Option<i64>,
2294    #[serde(
2295        default,
2296        deserialize_with = "crate::de::opt_string",
2297        skip_serializing_if = "Option::is_none"
2298    )]
2299    pub fallback: Option<String>,
2300    #[serde(
2301        default,
2302        deserialize_with = "crate::de::opt_string",
2303        skip_serializing_if = "Option::is_none"
2304    )]
2305    pub service_name: Option<String>,
2306    #[serde(
2307        default,
2308        deserialize_with = "crate::de::opt_string",
2309        skip_serializing_if = "Option::is_none"
2310    )]
2311    pub thumb_url: Option<String>,
2312    #[serde(
2313        default,
2314        deserialize_with = "crate::de::opt_i64",
2315        skip_serializing_if = "Option::is_none"
2316    )]
2317    pub thumb_width: Option<i64>,
2318    #[serde(
2319        default,
2320        deserialize_with = "crate::de::opt_i64",
2321        skip_serializing_if = "Option::is_none"
2322    )]
2323    pub thumb_height: Option<i64>,
2324    #[serde(
2325        default,
2326        deserialize_with = "crate::de::opt_string",
2327        skip_serializing_if = "Option::is_none"
2328    )]
2329    pub color: Option<String>,
2330    #[serde(
2331        default,
2332        deserialize_with = "crate::de::opt_i64",
2333        skip_serializing_if = "Option::is_none"
2334    )]
2335    pub ts: Option<i64>,
2336    #[serde(
2337        default,
2338        deserialize_with = "crate::de::opt_string",
2339        skip_serializing_if = "Option::is_none"
2340    )]
2341    pub pretext: Option<String>,
2342    #[serde(
2343        default,
2344        deserialize_with = "crate::de::vec",
2345        skip_serializing_if = "Vec::is_empty"
2346    )]
2347    pub mrkdwn_in: Vec<String>,
2348}
2349
2350/// A channel topic or purpose.
2351#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2352pub struct Topic {
2353    #[serde(
2354        default,
2355        deserialize_with = "crate::de::opt_string",
2356        skip_serializing_if = "Option::is_none"
2357    )]
2358    pub value: Option<String>,
2359    #[serde(
2360        default,
2361        deserialize_with = "crate::de::opt_string",
2362        skip_serializing_if = "Option::is_none"
2363    )]
2364    pub creator: Option<String>,
2365    #[serde(
2366        default,
2367        deserialize_with = "crate::de::opt_i64",
2368        skip_serializing_if = "Option::is_none"
2369    )]
2370    pub last_set: Option<i64>,
2371}
2372
2373/// Icon image URLs.
2374#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2375pub struct Icons {
2376    #[serde(
2377        default,
2378        deserialize_with = "crate::de::opt_string",
2379        skip_serializing_if = "Option::is_none"
2380    )]
2381    pub image_36: Option<String>,
2382    #[serde(
2383        default,
2384        deserialize_with = "crate::de::opt_string",
2385        skip_serializing_if = "Option::is_none"
2386    )]
2387    pub image_32: Option<String>,
2388    #[serde(
2389        default,
2390        deserialize_with = "crate::de::opt_string",
2391        skip_serializing_if = "Option::is_none"
2392    )]
2393    pub image_48: Option<String>,
2394    #[serde(
2395        default,
2396        deserialize_with = "crate::de::opt_string",
2397        skip_serializing_if = "Option::is_none"
2398    )]
2399    pub image_64: Option<String>,
2400    #[serde(
2401        default,
2402        deserialize_with = "crate::de::opt_string",
2403        skip_serializing_if = "Option::is_none"
2404    )]
2405    pub image_72: Option<String>,
2406    #[serde(
2407        default,
2408        deserialize_with = "crate::de::opt_string",
2409        skip_serializing_if = "Option::is_none"
2410    )]
2411    pub image_96: Option<String>,
2412    #[serde(
2413        default,
2414        deserialize_with = "crate::de::opt_string",
2415        skip_serializing_if = "Option::is_none"
2416    )]
2417    pub image_128: Option<String>,
2418    #[serde(
2419        default,
2420        deserialize_with = "crate::de::opt_string",
2421        skip_serializing_if = "Option::is_none"
2422    )]
2423    pub image_192: Option<String>,
2424    #[serde(
2425        default,
2426        deserialize_with = "crate::de::opt_string",
2427        skip_serializing_if = "Option::is_none"
2428    )]
2429    pub image_512: Option<String>,
2430    #[serde(
2431        default,
2432        deserialize_with = "crate::de::opt_string",
2433        skip_serializing_if = "Option::is_none"
2434    )]
2435    pub image_1024: Option<String>,
2436    #[serde(
2437        default,
2438        deserialize_with = "crate::de::opt_string",
2439        skip_serializing_if = "Option::is_none"
2440    )]
2441    pub image_original: Option<String>,
2442    #[serde(
2443        default,
2444        deserialize_with = "crate::de::opt_string",
2445        skip_serializing_if = "Option::is_none"
2446    )]
2447    pub image_34: Option<String>,
2448    #[serde(
2449        default,
2450        deserialize_with = "crate::de::opt_string",
2451        skip_serializing_if = "Option::is_none"
2452    )]
2453    pub image_44: Option<String>,
2454    #[serde(
2455        default,
2456        deserialize_with = "crate::de::opt_string",
2457        skip_serializing_if = "Option::is_none"
2458    )]
2459    pub image_68: Option<String>,
2460    #[serde(
2461        default,
2462        deserialize_with = "crate::de::opt_string",
2463        skip_serializing_if = "Option::is_none"
2464    )]
2465    pub image_88: Option<String>,
2466    #[serde(
2467        default,
2468        deserialize_with = "crate::de::opt_string",
2469        skip_serializing_if = "Option::is_none"
2470    )]
2471    pub image_102: Option<String>,
2472    #[serde(
2473        default,
2474        deserialize_with = "crate::de::opt_string",
2475        skip_serializing_if = "Option::is_none"
2476    )]
2477    pub image_132: Option<String>,
2478    #[serde(
2479        default,
2480        deserialize_with = "crate::de::opt_string",
2481        skip_serializing_if = "Option::is_none"
2482    )]
2483    pub image_230: Option<String>,
2484    #[serde(
2485        default,
2486        deserialize_with = "crate::de::opt_bool",
2487        skip_serializing_if = "Option::is_none"
2488    )]
2489    pub image_default: Option<bool>,
2490    #[serde(
2491        default,
2492        deserialize_with = "crate::de::opt_string",
2493        skip_serializing_if = "Option::is_none"
2494    )]
2495    pub emoji: Option<String>,
2496}
2497
2498/// A canvas.
2499#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2500pub struct Canvas {
2501    #[serde(
2502        default,
2503        deserialize_with = "crate::de::opt_string",
2504        skip_serializing_if = "Option::is_none"
2505    )]
2506    pub file_id: Option<String>,
2507    #[serde(
2508        default,
2509        deserialize_with = "crate::de::opt_bool",
2510        skip_serializing_if = "Option::is_none"
2511    )]
2512    pub is_empty: Option<bool>,
2513    #[serde(
2514        default,
2515        deserialize_with = "crate::de::opt_string",
2516        skip_serializing_if = "Option::is_none"
2517    )]
2518    pub quip_thread_id: Option<String>,
2519}
2520
2521/// An Enterprise Grid organization.
2522#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
2523pub struct Enterprise {
2524    #[serde(
2525        default,
2526        deserialize_with = "crate::de::opt_string",
2527        skip_serializing_if = "Option::is_none"
2528    )]
2529    pub name: Option<String>,
2530    #[serde(
2531        default,
2532        deserialize_with = "crate::de::opt_string",
2533        skip_serializing_if = "Option::is_none"
2534    )]
2535    pub id: Option<String>,
2536}