1use anyhow::Result;
2
3use crate::Client;
4#[derive(Clone, Debug)]
5pub struct MessageTemplateFolders {
6 pub client: Client,
7}
8
9impl MessageTemplateFolders {
10 #[doc(hidden)]
11 pub fn new(client: Client) -> Self {
12 Self { client }
13 }
14
15 #[doc = "List folders\n\nList the message template folders.\n\n```rust,no_run\nasync fn \
16 example_message_template_folders_list_folders() -> anyhow::Result<()> {\n let \
17 client = front_api::Client::new_from_env();\n let result: \
18 front_api::types::ListFoldersResponse =\n \
19 client.message_template_folders().list_folders().await?;\n println!(\"{:?}\", \
20 result);\n Ok(())\n}\n```"]
21 #[tracing::instrument]
22 pub async fn list_folders<'a>(
23 &'a self,
24 ) -> Result<crate::types::ListFoldersResponse, crate::types::error::Error> {
25 let mut req = self.client.client.request(
26 http::Method::GET,
27 &format!("{}/{}", self.client.base_url, "message_template_folders"),
28 );
29 req = req.bearer_auth(&self.client.token);
30 let resp = req.send().await?;
31 let status = resp.status();
32 if status.is_success() {
33 let text = resp.text().await.unwrap_or_default();
34 serde_json::from_str(&text).map_err(|err| {
35 crate::types::error::Error::from_serde_error(
36 format_serde_error::SerdeError::new(text.to_string(), err),
37 status,
38 )
39 })
40 } else {
41 Err(crate::types::error::Error::UnexpectedResponse(resp))
42 }
43 }
44
45 #[doc = "Create folder\n\nCreate a new message template folder.\n\n```rust,no_run\nasync fn \
46 example_message_template_folders_create_folder() -> anyhow::Result<()> {\n let \
47 client = front_api::Client::new_from_env();\n let result: \
48 front_api::types::MessageTemplateFolderResponse = client\n \
49 .message_template_folders()\n \
50 .create_folder(&front_api::types::CreateMessageTemplateFolder {\n name: \
51 \"some-string\".to_string(),\n parent_folder_id: \
52 Some(\"some-string\".to_string()),\n })\n .await?;\n \
53 println!(\"{:?}\", result);\n Ok(())\n}\n```"]
54 #[tracing::instrument]
55 pub async fn create_folder<'a>(
56 &'a self,
57 body: &crate::types::CreateMessageTemplateFolder,
58 ) -> Result<crate::types::MessageTemplateFolderResponse, crate::types::error::Error> {
59 let mut req = self.client.client.request(
60 http::Method::POST,
61 &format!("{}/{}", self.client.base_url, "message_template_folders"),
62 );
63 req = req.bearer_auth(&self.client.token);
64 req = req.json(body);
65 let resp = req.send().await?;
66 let status = resp.status();
67 if status.is_success() {
68 let text = resp.text().await.unwrap_or_default();
69 serde_json::from_str(&text).map_err(|err| {
70 crate::types::error::Error::from_serde_error(
71 format_serde_error::SerdeError::new(text.to_string(), err),
72 status,
73 )
74 })
75 } else {
76 Err(crate::types::error::Error::UnexpectedResponse(resp))
77 }
78 }
79
80 #[doc = "List team folders\n\nList the message template folders belonging to the requested \
81 team.\n\n**Parameters:**\n\n- `team_id: &'astr`: The team ID \
82 (required)\n\n```rust,no_run\nasync fn \
83 example_message_template_folders_list_team_folders() -> anyhow::Result<()> {\n let \
84 client = front_api::Client::new_from_env();\n let result: \
85 front_api::types::ListTeamFoldersResponse = client\n \
86 .message_template_folders()\n .list_team_folders(\"some-string\")\n \
87 .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
88 #[tracing::instrument]
89 pub async fn list_team_folders<'a>(
90 &'a self,
91 team_id: &'a str,
92 ) -> Result<crate::types::ListTeamFoldersResponse, crate::types::error::Error> {
93 let mut req = self.client.client.request(
94 http::Method::GET,
95 &format!(
96 "{}/{}",
97 self.client.base_url,
98 "teams/{team_id}/message_template_folders".replace("{team_id}", team_id)
99 ),
100 );
101 req = req.bearer_auth(&self.client.token);
102 let resp = req.send().await?;
103 let status = resp.status();
104 if status.is_success() {
105 let text = resp.text().await.unwrap_or_default();
106 serde_json::from_str(&text).map_err(|err| {
107 crate::types::error::Error::from_serde_error(
108 format_serde_error::SerdeError::new(text.to_string(), err),
109 status,
110 )
111 })
112 } else {
113 Err(crate::types::error::Error::UnexpectedResponse(resp))
114 }
115 }
116
117 #[doc = "Create team folder\n\nCreate a new message template folder belonging to the requested team.\n\n**Parameters:**\n\n- `team_id: &'astr`: The team ID (required)\n\n```rust,no_run\nasync fn example_message_template_folders_create_team_folder() -> anyhow::Result<()> {\n let client = front_api::Client::new_from_env();\n let result: front_api::types::MessageTemplateFolderResponse = client\n .message_template_folders()\n .create_team_folder(\n \"some-string\",\n &front_api::types::CreateMessageTemplateFolder {\n name: \"some-string\".to_string(),\n parent_folder_id: Some(\"some-string\".to_string()),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
118 #[tracing::instrument]
119 pub async fn create_team_folder<'a>(
120 &'a self,
121 team_id: &'a str,
122 body: &crate::types::CreateMessageTemplateFolder,
123 ) -> Result<crate::types::MessageTemplateFolderResponse, crate::types::error::Error> {
124 let mut req = self.client.client.request(
125 http::Method::POST,
126 &format!(
127 "{}/{}",
128 self.client.base_url,
129 "teams/{team_id}/message_template_folders".replace("{team_id}", team_id)
130 ),
131 );
132 req = req.bearer_auth(&self.client.token);
133 req = req.json(body);
134 let resp = req.send().await?;
135 let status = resp.status();
136 if status.is_success() {
137 let text = resp.text().await.unwrap_or_default();
138 serde_json::from_str(&text).map_err(|err| {
139 crate::types::error::Error::from_serde_error(
140 format_serde_error::SerdeError::new(text.to_string(), err),
141 status,
142 )
143 })
144 } else {
145 Err(crate::types::error::Error::UnexpectedResponse(resp))
146 }
147 }
148
149 #[doc = "List teammate folders\n\nList the message template folders belonging to the requested \
150 teammate.\n\n**Parameters:**\n\n- `teammate_id: &'astr`: The teammate ID \
151 (required)\n\n```rust,no_run\nasync fn \
152 example_message_template_folders_list_teammate_folders() -> anyhow::Result<()> {\n \
153 let client = front_api::Client::new_from_env();\n let result: \
154 front_api::types::ListTeammateFoldersResponse = client\n \
155 .message_template_folders()\n .list_teammate_folders(\"some-string\")\n \
156 .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
157 #[tracing::instrument]
158 pub async fn list_teammate_folders<'a>(
159 &'a self,
160 teammate_id: &'a str,
161 ) -> Result<crate::types::ListTeammateFoldersResponse, crate::types::error::Error> {
162 let mut req = self.client.client.request(
163 http::Method::GET,
164 &format!(
165 "{}/{}",
166 self.client.base_url,
167 "teammates/{teammate_id}/message_template_folders"
168 .replace("{teammate_id}", teammate_id)
169 ),
170 );
171 req = req.bearer_auth(&self.client.token);
172 let resp = req.send().await?;
173 let status = resp.status();
174 if status.is_success() {
175 let text = resp.text().await.unwrap_or_default();
176 serde_json::from_str(&text).map_err(|err| {
177 crate::types::error::Error::from_serde_error(
178 format_serde_error::SerdeError::new(text.to_string(), err),
179 status,
180 )
181 })
182 } else {
183 Err(crate::types::error::Error::UnexpectedResponse(resp))
184 }
185 }
186
187 #[doc = "Create teammate folder\n\nCreate a new message template folder belonging to the requested teammate.\n\n**Parameters:**\n\n- `teammate_id: &'astr`: The teammate ID (required)\n\n```rust,no_run\nasync fn example_message_template_folders_create_teammate_folder() -> anyhow::Result<()> {\n let client = front_api::Client::new_from_env();\n let result: front_api::types::MessageTemplateFolderResponse = client\n .message_template_folders()\n .create_teammate_folder(\n \"some-string\",\n &front_api::types::CreateMessageTemplateFolder {\n name: \"some-string\".to_string(),\n parent_folder_id: Some(\"some-string\".to_string()),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
188 #[tracing::instrument]
189 pub async fn create_teammate_folder<'a>(
190 &'a self,
191 teammate_id: &'a str,
192 body: &crate::types::CreateMessageTemplateFolder,
193 ) -> Result<crate::types::MessageTemplateFolderResponse, crate::types::error::Error> {
194 let mut req = self.client.client.request(
195 http::Method::POST,
196 &format!(
197 "{}/{}",
198 self.client.base_url,
199 "teammates/{teammate_id}/message_template_folders"
200 .replace("{teammate_id}", teammate_id)
201 ),
202 );
203 req = req.bearer_auth(&self.client.token);
204 req = req.json(body);
205 let resp = req.send().await?;
206 let status = resp.status();
207 if status.is_success() {
208 let text = resp.text().await.unwrap_or_default();
209 serde_json::from_str(&text).map_err(|err| {
210 crate::types::error::Error::from_serde_error(
211 format_serde_error::SerdeError::new(text.to_string(), err),
212 status,
213 )
214 })
215 } else {
216 Err(crate::types::error::Error::UnexpectedResponse(resp))
217 }
218 }
219
220 #[doc = "Get child folders\n\nFetch the child message templates folders of a message template \
221 folder.\n\n**Parameters:**\n\n- `message_template_folder_id: &'astr`: The message \
222 template folder ID (required)\n\n```rust,no_run\nasync fn \
223 example_message_template_folders_get_child_folders() -> anyhow::Result<()> {\n let \
224 client = front_api::Client::new_from_env();\n let result: \
225 front_api::types::GetChildFoldersResponse = client\n \
226 .message_template_folders()\n .get_child_folders(\"some-string\")\n \
227 .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
228 #[tracing::instrument]
229 pub async fn get_child_folders<'a>(
230 &'a self,
231 message_template_folder_id: &'a str,
232 ) -> Result<crate::types::GetChildFoldersResponse, crate::types::error::Error> {
233 let mut req = self.client.client.request(
234 http::Method::GET,
235 &format!(
236 "{}/{}",
237 self.client.base_url,
238 "message_template_folders/{message_template_folder_id}/message_template_folders"
239 .replace("{message_template_folder_id}", message_template_folder_id)
240 ),
241 );
242 req = req.bearer_auth(&self.client.token);
243 let resp = req.send().await?;
244 let status = resp.status();
245 if status.is_success() {
246 let text = resp.text().await.unwrap_or_default();
247 serde_json::from_str(&text).map_err(|err| {
248 crate::types::error::Error::from_serde_error(
249 format_serde_error::SerdeError::new(text.to_string(), err),
250 status,
251 )
252 })
253 } else {
254 Err(crate::types::error::Error::UnexpectedResponse(resp))
255 }
256 }
257
258 #[doc = "Create child folder\n\nCreate a new message template folder as a child of the given folder\n\n**Parameters:**\n\n- `message_template_folder_id: &'astr`: The parent message template folder ID (required)\n\n```rust,no_run\nasync fn example_message_template_folders_create_child_folder() -> anyhow::Result<()> {\n let client = front_api::Client::new_from_env();\n let result: front_api::types::MessageTemplateFolderResponse = client\n .message_template_folders()\n .create_child_folder(\n \"some-string\",\n &front_api::types::CreateMessageTemplateFolderAsChild {\n name: \"some-string\".to_string(),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
259 #[tracing::instrument]
260 pub async fn create_child_folder<'a>(
261 &'a self,
262 message_template_folder_id: &'a str,
263 body: &crate::types::CreateMessageTemplateFolderAsChild,
264 ) -> Result<crate::types::MessageTemplateFolderResponse, crate::types::error::Error> {
265 let mut req = self.client.client.request(
266 http::Method::POST,
267 &format!(
268 "{}/{}",
269 self.client.base_url,
270 "message_template_folders/{message_template_folder_id}/message_template_folders"
271 .replace("{message_template_folder_id}", message_template_folder_id)
272 ),
273 );
274 req = req.bearer_auth(&self.client.token);
275 req = req.json(body);
276 let resp = req.send().await?;
277 let status = resp.status();
278 if status.is_success() {
279 let text = resp.text().await.unwrap_or_default();
280 serde_json::from_str(&text).map_err(|err| {
281 crate::types::error::Error::from_serde_error(
282 format_serde_error::SerdeError::new(text.to_string(), err),
283 status,
284 )
285 })
286 } else {
287 Err(crate::types::error::Error::UnexpectedResponse(resp))
288 }
289 }
290
291 #[doc = "Get folder\n\nFetch a message template folder.\n\n**Parameters:**\n\n- `message_template_folder_id: &'astr`: The message template folder ID (required)\n\n```rust,no_run\nasync fn example_message_template_folders_get_folder() -> anyhow::Result<()> {\n let client = front_api::Client::new_from_env();\n let result: front_api::types::MessageTemplateFolderResponse = client\n .message_template_folders()\n .get_folder(\"some-string\")\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
292 #[tracing::instrument]
293 pub async fn get_folder<'a>(
294 &'a self,
295 message_template_folder_id: &'a str,
296 ) -> Result<crate::types::MessageTemplateFolderResponse, crate::types::error::Error> {
297 let mut req = self.client.client.request(
298 http::Method::GET,
299 &format!(
300 "{}/{}",
301 self.client.base_url,
302 "message_template_folders/{message_template_folder_id}"
303 .replace("{message_template_folder_id}", message_template_folder_id)
304 ),
305 );
306 req = req.bearer_auth(&self.client.token);
307 let resp = req.send().await?;
308 let status = resp.status();
309 if status.is_success() {
310 let text = resp.text().await.unwrap_or_default();
311 serde_json::from_str(&text).map_err(|err| {
312 crate::types::error::Error::from_serde_error(
313 format_serde_error::SerdeError::new(text.to_string(), err),
314 status,
315 )
316 })
317 } else {
318 Err(crate::types::error::Error::UnexpectedResponse(resp))
319 }
320 }
321
322 #[doc = "Delete folder\n\nDelete a message template folder and child \
323 folders/templates\n\n**Parameters:**\n\n- `message_template_folder_id: &'astr`: The \
324 message template folder id (required)\n\n```rust,no_run\nasync fn \
325 example_message_template_folders_delete_folder() -> anyhow::Result<()> {\n let \
326 client = front_api::Client::new_from_env();\n let result: \
327 front_api::types::DeleteFolderResponse = client\n \
328 .message_template_folders()\n .delete_folder(\"some-string\")\n \
329 .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
330 #[tracing::instrument]
331 pub async fn delete_folder<'a>(
332 &'a self,
333 message_template_folder_id: &'a str,
334 ) -> Result<crate::types::DeleteFolderResponse, crate::types::error::Error> {
335 let mut req = self.client.client.request(
336 http::Method::DELETE,
337 &format!(
338 "{}/{}",
339 self.client.base_url,
340 "message_template_folders/{message_template_folder_id}"
341 .replace("{message_template_folder_id}", message_template_folder_id)
342 ),
343 );
344 req = req.bearer_auth(&self.client.token);
345 let resp = req.send().await?;
346 let status = resp.status();
347 if status.is_success() {
348 let text = resp.text().await.unwrap_or_default();
349 serde_json::from_str(&text).map_err(|err| {
350 crate::types::error::Error::from_serde_error(
351 format_serde_error::SerdeError::new(text.to_string(), err),
352 status,
353 )
354 })
355 } else {
356 Err(crate::types::error::Error::UnexpectedResponse(resp))
357 }
358 }
359
360 #[doc = "Update folder\n\nUpdate message template folder\n\n**Parameters:**\n\n- `message_template_folder_id: &'astr`: The message template folder ID (required)\n\n```rust,no_run\nasync fn example_message_template_folders_update_folder() -> anyhow::Result<()> {\n let client = front_api::Client::new_from_env();\n let result: front_api::types::MessageTemplateFolderResponse = client\n .message_template_folders()\n .update_folder(\n \"some-string\",\n &front_api::types::UpdateMessageTemplateFolder {\n name: Some(\"some-string\".to_string()),\n parent_folder_id: Some(\"some-string\".to_string()),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
361 #[tracing::instrument]
362 pub async fn update_folder<'a>(
363 &'a self,
364 message_template_folder_id: &'a str,
365 body: &crate::types::UpdateMessageTemplateFolder,
366 ) -> Result<crate::types::MessageTemplateFolderResponse, crate::types::error::Error> {
367 let mut req = self.client.client.request(
368 http::Method::PATCH,
369 &format!(
370 "{}/{}",
371 self.client.base_url,
372 "message_template_folders/{message_template_folder_id}"
373 .replace("{message_template_folder_id}", message_template_folder_id)
374 ),
375 );
376 req = req.bearer_auth(&self.client.token);
377 req = req.json(body);
378 let resp = req.send().await?;
379 let status = resp.status();
380 if status.is_success() {
381 let text = resp.text().await.unwrap_or_default();
382 serde_json::from_str(&text).map_err(|err| {
383 crate::types::error::Error::from_serde_error(
384 format_serde_error::SerdeError::new(text.to_string(), err),
385 status,
386 )
387 })
388 } else {
389 Err(crate::types::error::Error::UnexpectedResponse(resp))
390 }
391 }
392}