1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum AssignBotError {
22 Status400(crate::models::AppError),
23 Status401(crate::models::AppError),
24 Status403(crate::models::AppError),
25 UnknownValue(serde_json::Value),
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum ConvertBotToUserError {
32 Status400(crate::models::AppError),
33 Status401(crate::models::AppError),
34 Status403(crate::models::AppError),
35 Status404(crate::models::AppError),
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum ConvertUserToBotError {
43 Status400(crate::models::AppError),
44 Status401(crate::models::AppError),
45 Status403(crate::models::AppError),
46 Status404(crate::models::AppError),
47 UnknownValue(serde_json::Value),
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
52#[serde(untagged)]
53pub enum CreateBotError {
54 Status400(crate::models::AppError),
55 Status401(crate::models::AppError),
56 Status403(crate::models::AppError),
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum DeleteBotIconImageError {
64 Status400(crate::models::AppError),
65 Status401(crate::models::AppError),
66 Status403(crate::models::AppError),
67 Status404(crate::models::AppError),
68 Status500(crate::models::AppError),
69 Status501(crate::models::AppError),
70 UnknownValue(serde_json::Value),
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum DisableBotError {
77 Status400(crate::models::AppError),
78 Status401(crate::models::AppError),
79 Status403(crate::models::AppError),
80 UnknownValue(serde_json::Value),
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum EnableBotError {
87 Status400(crate::models::AppError),
88 Status401(crate::models::AppError),
89 Status403(crate::models::AppError),
90 UnknownValue(serde_json::Value),
91}
92
93#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum GetBotError {
97 Status400(crate::models::AppError),
98 Status401(crate::models::AppError),
99 Status403(crate::models::AppError),
100 UnknownValue(serde_json::Value),
101}
102
103#[derive(Debug, Clone, Serialize, Deserialize)]
105#[serde(untagged)]
106pub enum GetBotIconImageError {
107 Status400(crate::models::AppError),
108 Status401(crate::models::AppError),
109 Status403(crate::models::AppError),
110 Status404(crate::models::AppError),
111 Status500(crate::models::AppError),
112 Status501(crate::models::AppError),
113 UnknownValue(serde_json::Value),
114}
115
116#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum GetBotsError {
120 Status400(crate::models::AppError),
121 Status401(crate::models::AppError),
122 Status403(crate::models::AppError),
123 UnknownValue(serde_json::Value),
124}
125
126#[derive(Debug, Clone, Serialize, Deserialize)]
128#[serde(untagged)]
129pub enum PatchBotError {
130 Status400(crate::models::AppError),
131 Status401(crate::models::AppError),
132 Status403(crate::models::AppError),
133 UnknownValue(serde_json::Value),
134}
135
136#[derive(Debug, Clone, Serialize, Deserialize)]
138#[serde(untagged)]
139pub enum SetBotIconImageError {
140 Status400(crate::models::AppError),
141 Status401(crate::models::AppError),
142 Status403(crate::models::AppError),
143 Status413(crate::models::AppError),
144 Status500(crate::models::AppError),
145 Status501(crate::models::AppError),
146 UnknownValue(serde_json::Value),
147}
148
149
150pub async fn assign_bot(configuration: &configuration::Configuration, bot_user_id: &str, user_id: &str) -> Result<crate::models::Bot, Error<AssignBotError>> {
152 let local_var_configuration = configuration;
153
154 let local_var_client = &local_var_configuration.client;
155
156 let local_var_uri_str = format!("{}/bots/{bot_user_id}/assign/{user_id}", local_var_configuration.base_path, bot_user_id=crate::apis::urlencode(bot_user_id), user_id=crate::apis::urlencode(user_id));
157 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
158
159 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
160 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
161 }
162 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
163 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
164 };
165
166 let local_var_req = local_var_req_builder.build()?;
167 let local_var_resp = local_var_client.execute(local_var_req).await?;
168
169 let local_var_status = local_var_resp.status();
170 let local_var_content = local_var_resp.text().await?;
171
172 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
173 serde_json::from_str(&local_var_content).map_err(Error::from)
174 } else {
175 let local_var_entity: Option<AssignBotError> = serde_json::from_str(&local_var_content).ok();
176 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
177 Err(Error::ResponseError(local_var_error))
178 }
179}
180
181pub async fn convert_bot_to_user(configuration: &configuration::Configuration, bot_user_id: &str, convert_bot_to_user_request: crate::models::ConvertBotToUserRequest, set_system_admin: Option<bool>) -> Result<crate::models::StatusOk, Error<ConvertBotToUserError>> {
183 let local_var_configuration = configuration;
184
185 let local_var_client = &local_var_configuration.client;
186
187 let local_var_uri_str = format!("{}/bots/{bot_user_id}/convert_to_user", local_var_configuration.base_path, bot_user_id=crate::apis::urlencode(bot_user_id));
188 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
189
190 if let Some(ref local_var_str) = set_system_admin {
191 local_var_req_builder = local_var_req_builder.query(&[("set_system_admin", &local_var_str.to_string())]);
192 }
193 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
194 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
195 }
196 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
197 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
198 };
199 local_var_req_builder = local_var_req_builder.json(&convert_bot_to_user_request);
200
201 let local_var_req = local_var_req_builder.build()?;
202 let local_var_resp = local_var_client.execute(local_var_req).await?;
203
204 let local_var_status = local_var_resp.status();
205 let local_var_content = local_var_resp.text().await?;
206
207 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
208 serde_json::from_str(&local_var_content).map_err(Error::from)
209 } else {
210 let local_var_entity: Option<ConvertBotToUserError> = serde_json::from_str(&local_var_content).ok();
211 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
212 Err(Error::ResponseError(local_var_error))
213 }
214}
215
216pub async fn convert_user_to_bot(configuration: &configuration::Configuration, user_id: &str) -> Result<crate::models::StatusOk, Error<ConvertUserToBotError>> {
218 let local_var_configuration = configuration;
219
220 let local_var_client = &local_var_configuration.client;
221
222 let local_var_uri_str = format!("{}/users/{user_id}/convert_to_bot", local_var_configuration.base_path, user_id=crate::apis::urlencode(user_id));
223 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
224
225 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
226 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
227 }
228 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
229 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
230 };
231
232 let local_var_req = local_var_req_builder.build()?;
233 let local_var_resp = local_var_client.execute(local_var_req).await?;
234
235 let local_var_status = local_var_resp.status();
236 let local_var_content = local_var_resp.text().await?;
237
238 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
239 serde_json::from_str(&local_var_content).map_err(Error::from)
240 } else {
241 let local_var_entity: Option<ConvertUserToBotError> = serde_json::from_str(&local_var_content).ok();
242 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
243 Err(Error::ResponseError(local_var_error))
244 }
245}
246
247pub async fn create_bot(configuration: &configuration::Configuration, create_bot_request: crate::models::CreateBotRequest) -> Result<crate::models::Bot, Error<CreateBotError>> {
249 let local_var_configuration = configuration;
250
251 let local_var_client = &local_var_configuration.client;
252
253 let local_var_uri_str = format!("{}/bots", local_var_configuration.base_path);
254 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
255
256 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
257 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
258 }
259 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
260 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
261 };
262 local_var_req_builder = local_var_req_builder.json(&create_bot_request);
263
264 let local_var_req = local_var_req_builder.build()?;
265 let local_var_resp = local_var_client.execute(local_var_req).await?;
266
267 let local_var_status = local_var_resp.status();
268 let local_var_content = local_var_resp.text().await?;
269
270 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
271 serde_json::from_str(&local_var_content).map_err(Error::from)
272 } else {
273 let local_var_entity: Option<CreateBotError> = serde_json::from_str(&local_var_content).ok();
274 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
275 Err(Error::ResponseError(local_var_error))
276 }
277}
278
279pub async fn delete_bot_icon_image(configuration: &configuration::Configuration, bot_user_id: &str) -> Result<crate::models::StatusOk, Error<DeleteBotIconImageError>> {
281 let local_var_configuration = configuration;
282
283 let local_var_client = &local_var_configuration.client;
284
285 let local_var_uri_str = format!("{}/bots/{bot_user_id}/icon", local_var_configuration.base_path, bot_user_id=crate::apis::urlencode(bot_user_id));
286 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
287
288 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
289 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
290 }
291 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
292 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
293 };
294
295 let local_var_req = local_var_req_builder.build()?;
296 let local_var_resp = local_var_client.execute(local_var_req).await?;
297
298 let local_var_status = local_var_resp.status();
299 let local_var_content = local_var_resp.text().await?;
300
301 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
302 serde_json::from_str(&local_var_content).map_err(Error::from)
303 } else {
304 let local_var_entity: Option<DeleteBotIconImageError> = serde_json::from_str(&local_var_content).ok();
305 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
306 Err(Error::ResponseError(local_var_error))
307 }
308}
309
310pub async fn disable_bot(configuration: &configuration::Configuration, bot_user_id: &str) -> Result<crate::models::Bot, Error<DisableBotError>> {
312 let local_var_configuration = configuration;
313
314 let local_var_client = &local_var_configuration.client;
315
316 let local_var_uri_str = format!("{}/bots/{bot_user_id}/disable", local_var_configuration.base_path, bot_user_id=crate::apis::urlencode(bot_user_id));
317 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
318
319 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
320 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
321 }
322 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
323 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
324 };
325
326 let local_var_req = local_var_req_builder.build()?;
327 let local_var_resp = local_var_client.execute(local_var_req).await?;
328
329 let local_var_status = local_var_resp.status();
330 let local_var_content = local_var_resp.text().await?;
331
332 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
333 serde_json::from_str(&local_var_content).map_err(Error::from)
334 } else {
335 let local_var_entity: Option<DisableBotError> = serde_json::from_str(&local_var_content).ok();
336 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
337 Err(Error::ResponseError(local_var_error))
338 }
339}
340
341pub async fn enable_bot(configuration: &configuration::Configuration, bot_user_id: &str) -> Result<crate::models::Bot, Error<EnableBotError>> {
343 let local_var_configuration = configuration;
344
345 let local_var_client = &local_var_configuration.client;
346
347 let local_var_uri_str = format!("{}/bots/{bot_user_id}/enable", local_var_configuration.base_path, bot_user_id=crate::apis::urlencode(bot_user_id));
348 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
349
350 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
351 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
352 }
353 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
354 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
355 };
356
357 let local_var_req = local_var_req_builder.build()?;
358 let local_var_resp = local_var_client.execute(local_var_req).await?;
359
360 let local_var_status = local_var_resp.status();
361 let local_var_content = local_var_resp.text().await?;
362
363 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
364 serde_json::from_str(&local_var_content).map_err(Error::from)
365 } else {
366 let local_var_entity: Option<EnableBotError> = serde_json::from_str(&local_var_content).ok();
367 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
368 Err(Error::ResponseError(local_var_error))
369 }
370}
371
372pub async fn get_bot(configuration: &configuration::Configuration, bot_user_id: &str, include_deleted: Option<bool>) -> Result<crate::models::Bot, Error<GetBotError>> {
374 let local_var_configuration = configuration;
375
376 let local_var_client = &local_var_configuration.client;
377
378 let local_var_uri_str = format!("{}/bots/{bot_user_id}", local_var_configuration.base_path, bot_user_id=crate::apis::urlencode(bot_user_id));
379 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
380
381 if let Some(ref local_var_str) = include_deleted {
382 local_var_req_builder = local_var_req_builder.query(&[("include_deleted", &local_var_str.to_string())]);
383 }
384 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
385 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
386 }
387 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
388 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
389 };
390
391 let local_var_req = local_var_req_builder.build()?;
392 let local_var_resp = local_var_client.execute(local_var_req).await?;
393
394 let local_var_status = local_var_resp.status();
395 let local_var_content = local_var_resp.text().await?;
396
397 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
398 serde_json::from_str(&local_var_content).map_err(Error::from)
399 } else {
400 let local_var_entity: Option<GetBotError> = serde_json::from_str(&local_var_content).ok();
401 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
402 Err(Error::ResponseError(local_var_error))
403 }
404}
405
406pub async fn get_bot_icon_image(configuration: &configuration::Configuration, bot_user_id: &str) -> Result<(), Error<GetBotIconImageError>> {
408 let local_var_configuration = configuration;
409
410 let local_var_client = &local_var_configuration.client;
411
412 let local_var_uri_str = format!("{}/bots/{bot_user_id}/icon", local_var_configuration.base_path, bot_user_id=crate::apis::urlencode(bot_user_id));
413 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
414
415 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
416 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
417 }
418 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
419 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
420 };
421
422 let local_var_req = local_var_req_builder.build()?;
423 let local_var_resp = local_var_client.execute(local_var_req).await?;
424
425 let local_var_status = local_var_resp.status();
426 let local_var_content = local_var_resp.text().await?;
427
428 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
429 Ok(())
430 } else {
431 let local_var_entity: Option<GetBotIconImageError> = serde_json::from_str(&local_var_content).ok();
432 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
433 Err(Error::ResponseError(local_var_error))
434 }
435}
436
437pub async fn get_bots(configuration: &configuration::Configuration, page: Option<i32>, per_page: Option<i32>, include_deleted: Option<bool>, only_orphaned: Option<bool>) -> Result<Vec<crate::models::Bot>, Error<GetBotsError>> {
439 let local_var_configuration = configuration;
440
441 let local_var_client = &local_var_configuration.client;
442
443 let local_var_uri_str = format!("{}/bots", local_var_configuration.base_path);
444 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
445
446 if let Some(ref local_var_str) = page {
447 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
448 }
449 if let Some(ref local_var_str) = per_page {
450 local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
451 }
452 if let Some(ref local_var_str) = include_deleted {
453 local_var_req_builder = local_var_req_builder.query(&[("include_deleted", &local_var_str.to_string())]);
454 }
455 if let Some(ref local_var_str) = only_orphaned {
456 local_var_req_builder = local_var_req_builder.query(&[("only_orphaned", &local_var_str.to_string())]);
457 }
458 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
459 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
460 }
461 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
462 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
463 };
464
465 let local_var_req = local_var_req_builder.build()?;
466 let local_var_resp = local_var_client.execute(local_var_req).await?;
467
468 let local_var_status = local_var_resp.status();
469 let local_var_content = local_var_resp.text().await?;
470
471 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
472 serde_json::from_str(&local_var_content).map_err(Error::from)
473 } else {
474 let local_var_entity: Option<GetBotsError> = serde_json::from_str(&local_var_content).ok();
475 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
476 Err(Error::ResponseError(local_var_error))
477 }
478}
479
480pub async fn patch_bot(configuration: &configuration::Configuration, bot_user_id: &str, create_bot_request: crate::models::CreateBotRequest) -> Result<crate::models::Bot, Error<PatchBotError>> {
482 let local_var_configuration = configuration;
483
484 let local_var_client = &local_var_configuration.client;
485
486 let local_var_uri_str = format!("{}/bots/{bot_user_id}", local_var_configuration.base_path, bot_user_id=crate::apis::urlencode(bot_user_id));
487 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
488
489 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
490 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
491 }
492 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
493 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
494 };
495 local_var_req_builder = local_var_req_builder.json(&create_bot_request);
496
497 let local_var_req = local_var_req_builder.build()?;
498 let local_var_resp = local_var_client.execute(local_var_req).await?;
499
500 let local_var_status = local_var_resp.status();
501 let local_var_content = local_var_resp.text().await?;
502
503 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
504 serde_json::from_str(&local_var_content).map_err(Error::from)
505 } else {
506 let local_var_entity: Option<PatchBotError> = serde_json::from_str(&local_var_content).ok();
507 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
508 Err(Error::ResponseError(local_var_error))
509 }
510}
511
512pub async fn set_bot_icon_image(configuration: &configuration::Configuration, bot_user_id: &str, image: std::path::PathBuf) -> Result<crate::models::StatusOk, Error<SetBotIconImageError>> {
514 let local_var_configuration = configuration;
515
516 let local_var_client = &local_var_configuration.client;
517
518 let local_var_uri_str = format!("{}/bots/{bot_user_id}/icon", local_var_configuration.base_path, bot_user_id=crate::apis::urlencode(bot_user_id));
519 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
520
521 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
522 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
523 }
524 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
525 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
526 };
527 let mut local_var_form = reqwest::multipart::Form::new();
528 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
530
531 let local_var_req = local_var_req_builder.build()?;
532 let local_var_resp = local_var_client.execute(local_var_req).await?;
533
534 let local_var_status = local_var_resp.status();
535 let local_var_content = local_var_resp.text().await?;
536
537 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
538 serde_json::from_str(&local_var_content).map_err(Error::from)
539 } else {
540 let local_var_entity: Option<SetBotIconImageError> = serde_json::from_str(&local_var_content).ok();
541 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
542 Err(Error::ResponseError(local_var_error))
543 }
544}
545