Skip to main content

slack_web_api/api/
stars.rs

1// このファイルは codegen/generate.py が生成する。手で編集しない
2
3#![allow(unused_imports)]
4
5use crate::objects::*;
6use crate::{
7    CursorPaginated, NextCursor, ResponseMetadata, SlackApiMethod, SlackClient, SlackError,
8};
9use serde::{Deserialize, Serialize};
10
11/// Arguments for the Slack Web API method [`stars.add`](https://docs.slack.dev/reference/methods/stars.add): Save an item for later. Formerly known as adding a star.
12///
13/// Send it with [`SlackClient::stars_add`].
14#[doc(alias = "stars.add")]
15#[derive(Debug, Clone, PartialEq, Serialize, Default)]
16#[non_exhaustive]
17pub struct StarsAddRequest {
18    /// Channel to add star to, or channel where the message to add star to was posted (used with `timestamp`).
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub channel: Option<String>,
21    /// File to add star to.
22    #[serde(skip_serializing_if = "Option::is_none")]
23    pub file: Option<String>,
24    /// File comment to add star to.
25    #[serde(skip_serializing_if = "Option::is_none")]
26    pub file_comment: Option<String>,
27    /// Timestamp of the message to add star to.
28    #[serde(skip_serializing_if = "Option::is_none")]
29    pub timestamp: Option<String>,
30}
31
32impl StarsAddRequest {
33    pub fn new() -> Self {
34        Self {
35            channel: None,
36            file: None,
37            file_comment: None,
38            timestamp: None,
39        }
40    }
41
42    pub fn channel(mut self, channel: impl Into<String>) -> Self {
43        self.channel = Some(channel.into());
44        self
45    }
46
47    pub fn file(mut self, file: impl Into<String>) -> Self {
48        self.file = Some(file.into());
49        self
50    }
51
52    pub fn file_comment(mut self, file_comment: impl Into<String>) -> Self {
53        self.file_comment = Some(file_comment.into());
54        self
55    }
56
57    pub fn timestamp(mut self, timestamp: impl Into<String>) -> Self {
58        self.timestamp = Some(timestamp.into());
59        self
60    }
61}
62
63impl SlackApiMethod for StarsAddRequest {
64    const METHOD: &'static str = "stars.add";
65    type Response = StarsAddResponse;
66}
67
68/// Successful response of the Slack Web API method [`stars.add`](https://docs.slack.dev/reference/methods/stars.add).
69#[doc(alias = "stars.add")]
70#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
71pub struct StarsAddResponse {
72    /// Fields returned by Slack. This method has no documented response example.
73    #[serde(flatten)]
74    pub extra: serde_json::Map<String, serde_json::Value>,
75    #[serde(
76        default,
77        deserialize_with = "crate::de::opt_object",
78        skip_serializing_if = "Option::is_none"
79    )]
80    pub response_metadata: Option<ResponseMetadata>,
81    #[serde(
82        default,
83        deserialize_with = "crate::de::opt_string",
84        skip_serializing_if = "Option::is_none"
85    )]
86    pub warning: Option<String>,
87}
88
89/// Arguments for the Slack Web API method [`stars.list`](https://docs.slack.dev/reference/methods/stars.list): Listed a user's saved items, formerly known as stars.
90///
91/// Send it with [`SlackClient::stars_list`].
92#[doc(alias = "stars.list")]
93#[derive(Debug, Clone, PartialEq, Serialize, Default)]
94#[non_exhaustive]
95pub struct StarsListRequest {
96    #[serde(skip_serializing_if = "Option::is_none")]
97    pub count: Option<i64>,
98    /// Parameter for pagination. Set `cursor` equal to the `next_cursor` attribute returned by the previous request's `response_metadata`. This parameter is optional, but pagination is mandatory: the default value simply fetches the first "page" of the collection. See [pagination](https://docs.slack.dev/apis/web-api/pagination.md) for more details.
99    #[serde(skip_serializing_if = "Option::is_none")]
100    pub cursor: Option<String>,
101    /// The maximum number of items to return. Fewer than the requested number of items may be returned, even if the end of the list hasn't been reached.
102    #[serde(skip_serializing_if = "Option::is_none")]
103    pub limit: Option<i64>,
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub page: Option<i64>,
106    /// encoded team id to list stars in, required if org token is used
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub team_id: Option<String>,
109}
110
111impl StarsListRequest {
112    pub fn new() -> Self {
113        Self {
114            count: None,
115            cursor: None,
116            limit: None,
117            page: None,
118            team_id: None,
119        }
120    }
121
122    pub fn count(mut self, count: i64) -> Self {
123        self.count = Some(count);
124        self
125    }
126
127    pub fn cursor(mut self, cursor: impl Into<String>) -> Self {
128        self.cursor = Some(cursor.into());
129        self
130    }
131
132    pub fn limit(mut self, limit: i64) -> Self {
133        self.limit = Some(limit);
134        self
135    }
136
137    pub fn page(mut self, page: i64) -> Self {
138        self.page = Some(page);
139        self
140    }
141
142    pub fn team_id(mut self, team_id: impl Into<String>) -> Self {
143        self.team_id = Some(team_id.into());
144        self
145    }
146}
147
148impl SlackApiMethod for StarsListRequest {
149    const METHOD: &'static str = "stars.list";
150    type Response = StarsListResponse;
151}
152
153impl CursorPaginated for StarsListRequest {
154    fn set_cursor(&mut self, cursor: String) {
155        self.cursor = Some(cursor);
156    }
157}
158
159impl NextCursor for StarsListResponse {
160    fn next_cursor(&self) -> Option<&str> {
161        self.response_metadata.as_ref()?.next_cursor.as_deref()
162    }
163}
164
165/// Successful response of the Slack Web API method [`stars.list`](https://docs.slack.dev/reference/methods/stars.list).
166#[doc(alias = "stars.list")]
167#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
168pub struct StarsListResponse {
169    #[serde(
170        default,
171        deserialize_with = "crate::de::vec",
172        skip_serializing_if = "Vec::is_empty"
173    )]
174    pub items: Vec<StarsListResponseItems>,
175    #[serde(
176        default,
177        deserialize_with = "crate::de::opt_object",
178        skip_serializing_if = "Option::is_none"
179    )]
180    pub paging: Option<StarsListResponsePaging>,
181    #[serde(
182        default,
183        deserialize_with = "crate::de::opt_object",
184        skip_serializing_if = "Option::is_none"
185    )]
186    pub response_metadata: Option<ResponseMetadata>,
187    #[serde(
188        default,
189        deserialize_with = "crate::de::opt_string",
190        skip_serializing_if = "Option::is_none"
191    )]
192    pub warning: Option<String>,
193}
194
195#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
196pub struct StarsListResponseItems {
197    #[serde(
198        default,
199        deserialize_with = "crate::de::opt_string",
200        skip_serializing_if = "Option::is_none"
201    )]
202    pub r#type: Option<String>,
203    #[serde(
204        default,
205        deserialize_with = "crate::de::opt_string",
206        skip_serializing_if = "Option::is_none"
207    )]
208    pub channel: Option<String>,
209    #[serde(
210        default,
211        deserialize_with = "crate::de::opt_object",
212        skip_serializing_if = "Option::is_none"
213    )]
214    pub message: Option<Message>,
215    #[serde(
216        default,
217        deserialize_with = "crate::de::opt_i64",
218        skip_serializing_if = "Option::is_none"
219    )]
220    pub date_create: Option<i64>,
221}
222
223#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
224pub struct StarsListResponsePaging {
225    #[serde(
226        default,
227        deserialize_with = "crate::de::opt_i64",
228        skip_serializing_if = "Option::is_none"
229    )]
230    pub per_page: Option<i64>,
231    #[serde(
232        default,
233        deserialize_with = "crate::de::opt_i64",
234        skip_serializing_if = "Option::is_none"
235    )]
236    pub spill: Option<i64>,
237    #[serde(
238        default,
239        deserialize_with = "crate::de::opt_i64",
240        skip_serializing_if = "Option::is_none"
241    )]
242    pub page: Option<i64>,
243    #[serde(
244        default,
245        deserialize_with = "crate::de::opt_i64",
246        skip_serializing_if = "Option::is_none"
247    )]
248    pub total: Option<i64>,
249    #[serde(
250        default,
251        deserialize_with = "crate::de::opt_i64",
252        skip_serializing_if = "Option::is_none"
253    )]
254    pub pages: Option<i64>,
255}
256
257/// Arguments for the Slack Web API method [`stars.remove`](https://docs.slack.dev/reference/methods/stars.remove): Removes a saved item (star) from an item.
258///
259/// Send it with [`SlackClient::stars_remove`].
260#[doc(alias = "stars.remove")]
261#[derive(Debug, Clone, PartialEq, Serialize, Default)]
262#[non_exhaustive]
263pub struct StarsRemoveRequest {
264    /// Channel to remove star from, or channel where the message to remove star from was posted (used with `timestamp`).
265    #[serde(skip_serializing_if = "Option::is_none")]
266    pub channel: Option<String>,
267    /// File to remove star from.
268    #[serde(skip_serializing_if = "Option::is_none")]
269    pub file: Option<String>,
270    /// File comment to remove star from.
271    #[serde(skip_serializing_if = "Option::is_none")]
272    pub file_comment: Option<String>,
273    /// Timestamp of the message to remove star from.
274    #[serde(skip_serializing_if = "Option::is_none")]
275    pub timestamp: Option<String>,
276}
277
278impl StarsRemoveRequest {
279    pub fn new() -> Self {
280        Self {
281            channel: None,
282            file: None,
283            file_comment: None,
284            timestamp: None,
285        }
286    }
287
288    pub fn channel(mut self, channel: impl Into<String>) -> Self {
289        self.channel = Some(channel.into());
290        self
291    }
292
293    pub fn file(mut self, file: impl Into<String>) -> Self {
294        self.file = Some(file.into());
295        self
296    }
297
298    pub fn file_comment(mut self, file_comment: impl Into<String>) -> Self {
299        self.file_comment = Some(file_comment.into());
300        self
301    }
302
303    pub fn timestamp(mut self, timestamp: impl Into<String>) -> Self {
304        self.timestamp = Some(timestamp.into());
305        self
306    }
307}
308
309impl SlackApiMethod for StarsRemoveRequest {
310    const METHOD: &'static str = "stars.remove";
311    type Response = StarsRemoveResponse;
312}
313
314/// Successful response of the Slack Web API method [`stars.remove`](https://docs.slack.dev/reference/methods/stars.remove).
315#[doc(alias = "stars.remove")]
316#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
317pub struct StarsRemoveResponse {
318    /// Fields returned by Slack. This method has no documented response example.
319    #[serde(flatten)]
320    pub extra: serde_json::Map<String, serde_json::Value>,
321    #[serde(
322        default,
323        deserialize_with = "crate::de::opt_object",
324        skip_serializing_if = "Option::is_none"
325    )]
326    pub response_metadata: Option<ResponseMetadata>,
327    #[serde(
328        default,
329        deserialize_with = "crate::de::opt_string",
330        skip_serializing_if = "Option::is_none"
331    )]
332    pub warning: Option<String>,
333}
334
335impl SlackClient {
336    /// Calls the Slack Web API method [`stars.add`](https://docs.slack.dev/reference/methods/stars.add): Save an item for later. Formerly known as adding a star.
337    ///
338    /// Required scopes:
339    ///
340    /// - user token: `stars:write`
341    ///
342    /// Rate limit: Tier 2 (<https://docs.slack.dev/apis/web-api/rate-limits>).
343    ///
344    /// # Errors
345    ///
346    /// Returns [`SlackError::Api`] when Slack answers `"ok": false`; see [`SlackClient::call`] for the other cases.
347    #[doc(alias = "stars.add")]
348    pub async fn stars_add(
349        &self,
350        request: &StarsAddRequest,
351    ) -> Result<StarsAddResponse, SlackError> {
352        self.call(request).await
353    }
354
355    /// Calls the Slack Web API method [`stars.list`](https://docs.slack.dev/reference/methods/stars.list): Listed a user's saved items, formerly known as stars.
356    ///
357    /// Required scopes:
358    ///
359    /// - user token: `stars:read`
360    ///
361    /// Rate limit: Tier 3 (<https://docs.slack.dev/apis/web-api/rate-limits>).
362    ///
363    /// # Errors
364    ///
365    /// Returns [`SlackError::Api`] when Slack answers `"ok": false`; see [`SlackClient::call`] for the other cases.
366    #[doc(alias = "stars.list")]
367    pub async fn stars_list(
368        &self,
369        request: &StarsListRequest,
370    ) -> Result<StarsListResponse, SlackError> {
371        self.call(request).await
372    }
373
374    /// Calls the Slack Web API method [`stars.remove`](https://docs.slack.dev/reference/methods/stars.remove): Removes a saved item (star) from an item.
375    ///
376    /// Required scopes:
377    ///
378    /// - user token: `stars:write`
379    ///
380    /// Rate limit: Tier 2 (<https://docs.slack.dev/apis/web-api/rate-limits>).
381    ///
382    /// # Errors
383    ///
384    /// Returns [`SlackError::Api`] when Slack answers `"ok": false`; see [`SlackClient::call`] for the other cases.
385    #[doc(alias = "stars.remove")]
386    pub async fn stars_remove(
387        &self,
388        request: &StarsRemoveRequest,
389    ) -> Result<StarsRemoveResponse, SlackError> {
390        self.call(request).await
391    }
392}