slack_web_api/blocks/
select.rs

1use serde::{Deserialize, Serialize};
2
3use super::composition::{
4    ConfirmationDialog, ConversationFilter, OptionGroup, OptionObject, TextObject,
5};
6use super::tag::{Tag, Tagged};
7
8/// A select menu with static options (either `options` or `option_groups`). <https://docs.slack.dev/reference/block-kit/block-elements/select-menu-element>
9#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10pub struct StaticSelectElement {
11    r#type: Tag<Self>,
12    #[serde(skip_serializing_if = "Option::is_none")]
13    pub action_id: Option<String>,
14    #[serde(default, skip_serializing_if = "Vec::is_empty")]
15    pub options: Vec<OptionObject>,
16    #[serde(default, skip_serializing_if = "Vec::is_empty")]
17    pub option_groups: Vec<OptionGroup>,
18    #[serde(skip_serializing_if = "Option::is_none")]
19    pub initial_option: Option<OptionObject>,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    pub confirm: Option<ConfirmationDialog>,
22    #[serde(skip_serializing_if = "Option::is_none")]
23    pub focus_on_load: Option<bool>,
24    #[serde(skip_serializing_if = "Option::is_none")]
25    pub placeholder: Option<TextObject>,
26}
27
28impl Tagged for StaticSelectElement {
29    const TAG: &'static str = "static_select";
30}
31
32impl StaticSelectElement {
33    pub fn new(options: Vec<OptionObject>) -> Self {
34        Self {
35            r#type: Tag::default(),
36            action_id: None,
37            options,
38            option_groups: Vec::new(),
39            initial_option: None,
40            confirm: None,
41            focus_on_load: None,
42            placeholder: None,
43        }
44    }
45
46    pub fn from_option_groups(option_groups: Vec<OptionGroup>) -> Self {
47        Self {
48            option_groups,
49            ..Self::new(Vec::new())
50        }
51    }
52
53    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
54        self.action_id = Some(action_id.into());
55        self
56    }
57
58    pub fn option_groups(mut self, option_groups: Vec<OptionGroup>) -> Self {
59        self.option_groups = option_groups;
60        self
61    }
62
63    pub fn initial_option(mut self, initial_option: OptionObject) -> Self {
64        self.initial_option = Some(initial_option);
65        self
66    }
67
68    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
69        self.confirm = Some(confirm);
70        self
71    }
72
73    pub fn focus_on_load(mut self, focus_on_load: bool) -> Self {
74        self.focus_on_load = Some(focus_on_load);
75        self
76    }
77
78    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
79        self.placeholder = Some(placeholder.into());
80        self
81    }
82}
83
84/// A select menu that loads options from an external data source. <https://docs.slack.dev/reference/block-kit/block-elements/select-menu-element>
85#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
86pub struct ExternalSelectElement {
87    r#type: Tag<Self>,
88    #[serde(skip_serializing_if = "Option::is_none")]
89    pub action_id: Option<String>,
90    #[serde(skip_serializing_if = "Option::is_none")]
91    pub initial_option: Option<OptionObject>,
92    #[serde(skip_serializing_if = "Option::is_none")]
93    pub min_query_length: Option<u32>,
94    #[serde(skip_serializing_if = "Option::is_none")]
95    pub confirm: Option<ConfirmationDialog>,
96    #[serde(skip_serializing_if = "Option::is_none")]
97    pub focus_on_load: Option<bool>,
98    #[serde(skip_serializing_if = "Option::is_none")]
99    pub placeholder: Option<TextObject>,
100}
101
102impl Tagged for ExternalSelectElement {
103    const TAG: &'static str = "external_select";
104}
105
106impl ExternalSelectElement {
107    pub fn new() -> Self {
108        Self::default()
109    }
110
111    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
112        self.action_id = Some(action_id.into());
113        self
114    }
115
116    pub fn initial_option(mut self, initial_option: OptionObject) -> Self {
117        self.initial_option = Some(initial_option);
118        self
119    }
120
121    pub fn min_query_length(mut self, min_query_length: u32) -> Self {
122        self.min_query_length = Some(min_query_length);
123        self
124    }
125
126    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
127        self.confirm = Some(confirm);
128        self
129    }
130
131    pub fn focus_on_load(mut self, focus_on_load: bool) -> Self {
132        self.focus_on_load = Some(focus_on_load);
133        self
134    }
135
136    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
137        self.placeholder = Some(placeholder.into());
138        self
139    }
140}
141
142/// A select menu of users. <https://docs.slack.dev/reference/block-kit/block-elements/select-menu-element>
143#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
144pub struct UsersSelectElement {
145    r#type: Tag<Self>,
146    #[serde(skip_serializing_if = "Option::is_none")]
147    pub action_id: Option<String>,
148    #[serde(skip_serializing_if = "Option::is_none")]
149    pub initial_user: Option<String>,
150    #[serde(skip_serializing_if = "Option::is_none")]
151    pub confirm: Option<ConfirmationDialog>,
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub focus_on_load: Option<bool>,
154    #[serde(skip_serializing_if = "Option::is_none")]
155    pub placeholder: Option<TextObject>,
156}
157
158impl Tagged for UsersSelectElement {
159    const TAG: &'static str = "users_select";
160}
161
162impl UsersSelectElement {
163    pub fn new() -> Self {
164        Self::default()
165    }
166
167    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
168        self.action_id = Some(action_id.into());
169        self
170    }
171
172    pub fn initial_user(mut self, initial_user: impl Into<String>) -> Self {
173        self.initial_user = Some(initial_user.into());
174        self
175    }
176
177    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
178        self.confirm = Some(confirm);
179        self
180    }
181
182    pub fn focus_on_load(mut self, focus_on_load: bool) -> Self {
183        self.focus_on_load = Some(focus_on_load);
184        self
185    }
186
187    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
188        self.placeholder = Some(placeholder.into());
189        self
190    }
191}
192
193/// A select menu of conversations. <https://docs.slack.dev/reference/block-kit/block-elements/select-menu-element>
194#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
195pub struct ConversationsSelectElement {
196    r#type: Tag<Self>,
197    #[serde(skip_serializing_if = "Option::is_none")]
198    pub action_id: Option<String>,
199    #[serde(skip_serializing_if = "Option::is_none")]
200    pub initial_conversation: Option<String>,
201    #[serde(skip_serializing_if = "Option::is_none")]
202    pub default_to_current_conversation: Option<bool>,
203    #[serde(skip_serializing_if = "Option::is_none")]
204    pub confirm: Option<ConfirmationDialog>,
205    #[serde(skip_serializing_if = "Option::is_none")]
206    pub response_url_enabled: Option<bool>,
207    #[serde(skip_serializing_if = "Option::is_none")]
208    pub filter: Option<ConversationFilter>,
209    #[serde(skip_serializing_if = "Option::is_none")]
210    pub focus_on_load: Option<bool>,
211    #[serde(skip_serializing_if = "Option::is_none")]
212    pub placeholder: Option<TextObject>,
213}
214
215impl Tagged for ConversationsSelectElement {
216    const TAG: &'static str = "conversations_select";
217}
218
219impl ConversationsSelectElement {
220    pub fn new() -> Self {
221        Self::default()
222    }
223
224    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
225        self.action_id = Some(action_id.into());
226        self
227    }
228
229    pub fn initial_conversation(mut self, initial_conversation: impl Into<String>) -> Self {
230        self.initial_conversation = Some(initial_conversation.into());
231        self
232    }
233
234    pub fn default_to_current_conversation(
235        mut self,
236        default_to_current_conversation: bool,
237    ) -> Self {
238        self.default_to_current_conversation = Some(default_to_current_conversation);
239        self
240    }
241
242    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
243        self.confirm = Some(confirm);
244        self
245    }
246
247    pub fn response_url_enabled(mut self, response_url_enabled: bool) -> Self {
248        self.response_url_enabled = Some(response_url_enabled);
249        self
250    }
251
252    pub fn filter(mut self, filter: ConversationFilter) -> Self {
253        self.filter = Some(filter);
254        self
255    }
256
257    pub fn focus_on_load(mut self, focus_on_load: bool) -> Self {
258        self.focus_on_load = Some(focus_on_load);
259        self
260    }
261
262    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
263        self.placeholder = Some(placeholder.into());
264        self
265    }
266}
267
268/// A select menu of public channels. <https://docs.slack.dev/reference/block-kit/block-elements/select-menu-element>
269#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
270pub struct ChannelsSelectElement {
271    r#type: Tag<Self>,
272    #[serde(skip_serializing_if = "Option::is_none")]
273    pub action_id: Option<String>,
274    #[serde(skip_serializing_if = "Option::is_none")]
275    pub initial_channel: Option<String>,
276    #[serde(skip_serializing_if = "Option::is_none")]
277    pub confirm: Option<ConfirmationDialog>,
278    #[serde(skip_serializing_if = "Option::is_none")]
279    pub response_url_enabled: Option<bool>,
280    #[serde(skip_serializing_if = "Option::is_none")]
281    pub focus_on_load: Option<bool>,
282    #[serde(skip_serializing_if = "Option::is_none")]
283    pub placeholder: Option<TextObject>,
284}
285
286impl Tagged for ChannelsSelectElement {
287    const TAG: &'static str = "channels_select";
288}
289
290impl ChannelsSelectElement {
291    pub fn new() -> Self {
292        Self::default()
293    }
294
295    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
296        self.action_id = Some(action_id.into());
297        self
298    }
299
300    pub fn initial_channel(mut self, initial_channel: impl Into<String>) -> Self {
301        self.initial_channel = Some(initial_channel.into());
302        self
303    }
304
305    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
306        self.confirm = Some(confirm);
307        self
308    }
309
310    pub fn response_url_enabled(mut self, response_url_enabled: bool) -> Self {
311        self.response_url_enabled = Some(response_url_enabled);
312        self
313    }
314
315    pub fn focus_on_load(mut self, focus_on_load: bool) -> Self {
316        self.focus_on_load = Some(focus_on_load);
317        self
318    }
319
320    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
321        self.placeholder = Some(placeholder.into());
322        self
323    }
324}
325
326/// A multi-select menu with static options (either `options` or `option_groups`). <https://docs.slack.dev/reference/block-kit/block-elements/multi-select-menu-element>
327#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
328pub struct MultiStaticSelectElement {
329    r#type: Tag<Self>,
330    #[serde(skip_serializing_if = "Option::is_none")]
331    pub action_id: Option<String>,
332    #[serde(default, skip_serializing_if = "Vec::is_empty")]
333    pub options: Vec<OptionObject>,
334    #[serde(default, skip_serializing_if = "Vec::is_empty")]
335    pub option_groups: Vec<OptionGroup>,
336    #[serde(default, skip_serializing_if = "Vec::is_empty")]
337    pub initial_options: Vec<OptionObject>,
338    #[serde(skip_serializing_if = "Option::is_none")]
339    pub confirm: Option<ConfirmationDialog>,
340    #[serde(skip_serializing_if = "Option::is_none")]
341    pub max_selected_items: Option<u32>,
342    #[serde(skip_serializing_if = "Option::is_none")]
343    pub focus_on_load: Option<bool>,
344    #[serde(skip_serializing_if = "Option::is_none")]
345    pub placeholder: Option<TextObject>,
346}
347
348impl Tagged for MultiStaticSelectElement {
349    const TAG: &'static str = "multi_static_select";
350}
351
352impl MultiStaticSelectElement {
353    pub fn new(options: Vec<OptionObject>) -> Self {
354        Self {
355            r#type: Tag::default(),
356            action_id: None,
357            options,
358            option_groups: Vec::new(),
359            initial_options: Vec::new(),
360            confirm: None,
361            max_selected_items: None,
362            focus_on_load: None,
363            placeholder: None,
364        }
365    }
366
367    pub fn from_option_groups(option_groups: Vec<OptionGroup>) -> Self {
368        Self {
369            option_groups,
370            ..Self::new(Vec::new())
371        }
372    }
373
374    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
375        self.action_id = Some(action_id.into());
376        self
377    }
378
379    pub fn option_groups(mut self, option_groups: Vec<OptionGroup>) -> Self {
380        self.option_groups = option_groups;
381        self
382    }
383
384    pub fn initial_options(mut self, initial_options: Vec<OptionObject>) -> Self {
385        self.initial_options = initial_options;
386        self
387    }
388
389    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
390        self.confirm = Some(confirm);
391        self
392    }
393
394    pub fn max_selected_items(mut self, max_selected_items: u32) -> Self {
395        self.max_selected_items = Some(max_selected_items);
396        self
397    }
398
399    pub fn focus_on_load(mut self, focus_on_load: bool) -> Self {
400        self.focus_on_load = Some(focus_on_load);
401        self
402    }
403
404    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
405        self.placeholder = Some(placeholder.into());
406        self
407    }
408}
409
410/// A multi-select menu that loads options from an external data source. <https://docs.slack.dev/reference/block-kit/block-elements/multi-select-menu-element>
411#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
412pub struct MultiExternalSelectElement {
413    r#type: Tag<Self>,
414    #[serde(skip_serializing_if = "Option::is_none")]
415    pub action_id: Option<String>,
416    #[serde(skip_serializing_if = "Option::is_none")]
417    pub min_query_length: Option<u32>,
418    #[serde(default, skip_serializing_if = "Vec::is_empty")]
419    pub initial_options: Vec<OptionObject>,
420    #[serde(skip_serializing_if = "Option::is_none")]
421    pub confirm: Option<ConfirmationDialog>,
422    #[serde(skip_serializing_if = "Option::is_none")]
423    pub max_selected_items: Option<u32>,
424    #[serde(skip_serializing_if = "Option::is_none")]
425    pub placeholder: Option<TextObject>,
426}
427
428impl Tagged for MultiExternalSelectElement {
429    const TAG: &'static str = "multi_external_select";
430}
431
432impl MultiExternalSelectElement {
433    pub fn new() -> Self {
434        Self::default()
435    }
436
437    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
438        self.action_id = Some(action_id.into());
439        self
440    }
441
442    pub fn min_query_length(mut self, min_query_length: u32) -> Self {
443        self.min_query_length = Some(min_query_length);
444        self
445    }
446
447    pub fn initial_options(mut self, initial_options: Vec<OptionObject>) -> Self {
448        self.initial_options = initial_options;
449        self
450    }
451
452    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
453        self.confirm = Some(confirm);
454        self
455    }
456
457    pub fn max_selected_items(mut self, max_selected_items: u32) -> Self {
458        self.max_selected_items = Some(max_selected_items);
459        self
460    }
461
462    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
463        self.placeholder = Some(placeholder.into());
464        self
465    }
466}
467
468/// A multi-select menu of users. <https://docs.slack.dev/reference/block-kit/block-elements/multi-select-menu-element>
469#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
470pub struct MultiUsersSelectElement {
471    r#type: Tag<Self>,
472    #[serde(skip_serializing_if = "Option::is_none")]
473    pub action_id: Option<String>,
474    #[serde(default, skip_serializing_if = "Vec::is_empty")]
475    pub initial_users: Vec<String>,
476    #[serde(skip_serializing_if = "Option::is_none")]
477    pub confirm: Option<ConfirmationDialog>,
478    #[serde(skip_serializing_if = "Option::is_none")]
479    pub max_selected_items: Option<u32>,
480    #[serde(skip_serializing_if = "Option::is_none")]
481    pub focus_on_load: Option<bool>,
482    #[serde(skip_serializing_if = "Option::is_none")]
483    pub placeholder: Option<TextObject>,
484}
485
486impl Tagged for MultiUsersSelectElement {
487    const TAG: &'static str = "multi_users_select";
488}
489
490impl MultiUsersSelectElement {
491    pub fn new() -> Self {
492        Self::default()
493    }
494
495    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
496        self.action_id = Some(action_id.into());
497        self
498    }
499
500    pub fn initial_users(mut self, initial_users: Vec<String>) -> Self {
501        self.initial_users = initial_users;
502        self
503    }
504
505    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
506        self.confirm = Some(confirm);
507        self
508    }
509
510    pub fn max_selected_items(mut self, max_selected_items: u32) -> Self {
511        self.max_selected_items = Some(max_selected_items);
512        self
513    }
514
515    pub fn focus_on_load(mut self, focus_on_load: bool) -> Self {
516        self.focus_on_load = Some(focus_on_load);
517        self
518    }
519
520    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
521        self.placeholder = Some(placeholder.into());
522        self
523    }
524}
525
526/// A multi-select menu of conversations. <https://docs.slack.dev/reference/block-kit/block-elements/multi-select-menu-element>
527#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
528pub struct MultiConversationsSelectElement {
529    r#type: Tag<Self>,
530    #[serde(skip_serializing_if = "Option::is_none")]
531    pub action_id: Option<String>,
532    #[serde(default, skip_serializing_if = "Vec::is_empty")]
533    pub initial_conversations: Vec<String>,
534    #[serde(skip_serializing_if = "Option::is_none")]
535    pub default_to_current_conversation: Option<bool>,
536    #[serde(skip_serializing_if = "Option::is_none")]
537    pub confirm: Option<ConfirmationDialog>,
538    #[serde(skip_serializing_if = "Option::is_none")]
539    pub max_selected_items: Option<u32>,
540    #[serde(skip_serializing_if = "Option::is_none")]
541    pub filter: Option<ConversationFilter>,
542    #[serde(skip_serializing_if = "Option::is_none")]
543    pub focus_on_load: Option<bool>,
544    #[serde(skip_serializing_if = "Option::is_none")]
545    pub placeholder: Option<TextObject>,
546}
547
548impl Tagged for MultiConversationsSelectElement {
549    const TAG: &'static str = "multi_conversations_select";
550}
551
552impl MultiConversationsSelectElement {
553    pub fn new() -> Self {
554        Self::default()
555    }
556
557    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
558        self.action_id = Some(action_id.into());
559        self
560    }
561
562    pub fn initial_conversations(mut self, initial_conversations: Vec<String>) -> Self {
563        self.initial_conversations = initial_conversations;
564        self
565    }
566
567    pub fn default_to_current_conversation(
568        mut self,
569        default_to_current_conversation: bool,
570    ) -> Self {
571        self.default_to_current_conversation = Some(default_to_current_conversation);
572        self
573    }
574
575    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
576        self.confirm = Some(confirm);
577        self
578    }
579
580    pub fn max_selected_items(mut self, max_selected_items: u32) -> Self {
581        self.max_selected_items = Some(max_selected_items);
582        self
583    }
584
585    pub fn filter(mut self, filter: ConversationFilter) -> Self {
586        self.filter = Some(filter);
587        self
588    }
589
590    pub fn focus_on_load(mut self, focus_on_load: bool) -> Self {
591        self.focus_on_load = Some(focus_on_load);
592        self
593    }
594
595    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
596        self.placeholder = Some(placeholder.into());
597        self
598    }
599}
600
601/// A multi-select menu of public channels. <https://docs.slack.dev/reference/block-kit/block-elements/multi-select-menu-element>
602#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
603pub struct MultiChannelsSelectElement {
604    r#type: Tag<Self>,
605    #[serde(skip_serializing_if = "Option::is_none")]
606    pub action_id: Option<String>,
607    #[serde(default, skip_serializing_if = "Vec::is_empty")]
608    pub initial_channels: Vec<String>,
609    #[serde(skip_serializing_if = "Option::is_none")]
610    pub confirm: Option<ConfirmationDialog>,
611    #[serde(skip_serializing_if = "Option::is_none")]
612    pub max_selected_items: Option<u32>,
613    #[serde(skip_serializing_if = "Option::is_none")]
614    pub focus_on_load: Option<bool>,
615    #[serde(skip_serializing_if = "Option::is_none")]
616    pub placeholder: Option<TextObject>,
617}
618
619impl Tagged for MultiChannelsSelectElement {
620    const TAG: &'static str = "multi_channels_select";
621}
622
623impl MultiChannelsSelectElement {
624    pub fn new() -> Self {
625        Self::default()
626    }
627
628    pub fn action_id(mut self, action_id: impl Into<String>) -> Self {
629        self.action_id = Some(action_id.into());
630        self
631    }
632
633    pub fn initial_channels(mut self, initial_channels: Vec<String>) -> Self {
634        self.initial_channels = initial_channels;
635        self
636    }
637
638    pub fn confirm(mut self, confirm: ConfirmationDialog) -> Self {
639        self.confirm = Some(confirm);
640        self
641    }
642
643    pub fn max_selected_items(mut self, max_selected_items: u32) -> Self {
644        self.max_selected_items = Some(max_selected_items);
645        self
646    }
647
648    pub fn focus_on_load(mut self, focus_on_load: bool) -> Self {
649        self.focus_on_load = Some(focus_on_load);
650        self
651    }
652
653    pub fn placeholder(mut self, placeholder: impl Into<TextObject>) -> Self {
654        self.placeholder = Some(placeholder.into());
655        self
656    }
657}
slack_web_api/blocks/select.rs

slack_web_api/blocks/
select.rs
