loops_sdk/
lib.rs

1#![recursion_limit = "1024"]
2/// Generated by Sideko (sideko.dev)
3mod auth;
4pub mod blocking;
5pub mod error_enums;
6pub mod request_types;
7pub mod result;
8pub mod schemas;
9use request_types::*;
10use reqwest::multipart as reqwest_multipart;
11use reqwest::Client as ReqwestClient;
12use reqwest::RequestBuilder as ReqwestRequestBuilder;
13use schemas::*;
14use std::collections::BTreeMap;
15
16#[derive(Clone, Debug)]
17pub struct Client {
18    pub base_url: String,
19    auth: BTreeMap<String, auth::AuthProvider>,
20}
21
22impl Default for Client {
23    fn default() -> Self {
24        Self {
25            base_url: "https://app.loops.so/api/v1".to_string(),
26            auth: BTreeMap::new(),
27        }
28    }
29}
30
31impl Client {
32    /// Authentication  builder function to store bearer credentials in the client
33    pub fn with_api_key(mut self, val: &str) -> Self {
34        self.auth.insert(
35            "apiKey".to_string(),
36            auth::AuthProvider::Bearer(val.to_string()),
37        );
38        self
39    }
40    fn builder_with_auth(
41        &self,
42        mut req_builder: ReqwestRequestBuilder,
43        auth_names: &[&str],
44    ) -> ReqwestRequestBuilder {
45        for auth_name in auth_names {
46            if let Some(provider) = self.auth.get(&auth_name.to_string()) {
47                req_builder = provider.add_auth(req_builder);
48            }
49        }
50        req_builder
51    }
52    fn async_multipart_file(&self, path: &str) -> std::io::Result<reqwest_multipart::Part> {
53        let path: &std::path::Path = path.as_ref();
54        let file_name = path
55            .file_name()
56            .map(|filename| filename.to_string_lossy().into_owned());
57        let file_bytes = std::fs::read(path)?;
58        Ok(reqwest_multipart::Part::bytes(file_bytes).file_name(file_name.unwrap_or_default()))
59    }
60    /// Retrieve a list of your account's custom contact properties.
61    pub async fn get_contacts_custom_fields(
62        &self,
63    ) -> result::Result<Vec<CustomField>, error_enums::GetContactsCustomFieldsErrors> {
64        let endpoint = "/contacts/customFields";
65        let url = format!("{}{}", self.base_url, endpoint);
66        let query_params: Vec<(&str, String)> = vec![];
67        let unauthed_builder = ReqwestClient::default().get(&url).query(&query_params);
68        let authed_builder = self.builder_with_auth(unauthed_builder, &["apiKey"]);
69        let response = authed_builder
70            .send()
71            .await
72            .map_err(result::Error::Dispatch)?;
73        let status_code = response.status().as_u16();
74        match status_code {
75            200 => {
76                let response_text = response.text().await.unwrap_or_default();
77                let data = serde_json::from_str::<Vec<CustomField>>(&response_text).map_err(
78                    |serde_err| result::Error::UnexpectedResponseBody {
79                        status_code,
80                        method: "GET".to_string(),
81                        url: url.to_string(),
82                        response_text,
83                        expected_signature: "Vec<CustomField>".to_string(),
84                        serde_err,
85                    },
86                )?;
87                Ok(data)
88            }
89            405 => {
90                let response_text = response.text().await.unwrap_or_default();
91                let data = serde_json::from_str::<serde_json::Value>(&response_text).map_err(
92                    |serde_err| result::Error::UnexpectedResponseBody {
93                        status_code,
94                        method: "GET".to_string(),
95                        url: url.to_string(),
96                        response_text,
97                        expected_signature: "serde_json::Value".to_string(),
98                        serde_err,
99                    },
100                )?;
101                Err(result::Error::Response {
102                    status_code,
103                    method: "GET".to_string(),
104                    url: url.to_string(),
105                    data: error_enums::GetContactsCustomFieldsErrors::Status405(data),
106                })
107            }
108            _ => {
109                let expected_status_codes: Vec<String> = vec!["200".to_string(), "405".to_string()];
110                Err(result::Error::UnexpectedStatus {
111                    status_code,
112                    method: "".to_string(),
113                    url: url.to_string(),
114                    response,
115                    expected_status_codes,
116                })
117            }
118        }
119    }
120    /// Search for a contact by `email`.
121    pub async fn get_contacts_find(
122        &self,
123        request: GetContactsFindRequest,
124    ) -> result::Result<Vec<Contact>, error_enums::GetContactsFindErrors> {
125        let endpoint = "/contacts/find";
126        let url = format!("{}{}", self.base_url, endpoint);
127        let mut query_params: Vec<(&str, String)> = vec![];
128        query_params.push(("email", format!("{}", &request.email)));
129        let unauthed_builder = ReqwestClient::default().get(&url).query(&query_params);
130        let authed_builder = self.builder_with_auth(unauthed_builder, &["apiKey"]);
131        let response = authed_builder
132            .send()
133            .await
134            .map_err(result::Error::Dispatch)?;
135        let status_code = response.status().as_u16();
136        match status_code {
137            200 => {
138                let response_text = response.text().await.unwrap_or_default();
139                let data =
140                    serde_json::from_str::<Vec<Contact>>(&response_text).map_err(|serde_err| {
141                        result::Error::UnexpectedResponseBody {
142                            status_code,
143                            method: "GET".to_string(),
144                            url: url.to_string(),
145                            response_text,
146                            expected_signature: "Vec<Contact>".to_string(),
147                            serde_err,
148                        }
149                    })?;
150                Ok(data)
151            }
152            400 => {
153                let response_text = response.text().await.unwrap_or_default();
154                let data = serde_json::from_str::<ContactFailureResponse>(&response_text).map_err(
155                    |serde_err| result::Error::UnexpectedResponseBody {
156                        status_code,
157                        method: "GET".to_string(),
158                        url: url.to_string(),
159                        response_text,
160                        expected_signature: "ContactFailureResponse".to_string(),
161                        serde_err,
162                    },
163                )?;
164                Err(result::Error::Response {
165                    status_code,
166                    method: "GET".to_string(),
167                    url: url.to_string(),
168                    data: error_enums::GetContactsFindErrors::Status400(data),
169                })
170            }
171            405 => {
172                let response_text = response.text().await.unwrap_or_default();
173                let data = serde_json::from_str::<serde_json::Value>(&response_text).map_err(
174                    |serde_err| result::Error::UnexpectedResponseBody {
175                        status_code,
176                        method: "GET".to_string(),
177                        url: url.to_string(),
178                        response_text,
179                        expected_signature: "serde_json::Value".to_string(),
180                        serde_err,
181                    },
182                )?;
183                Err(result::Error::Response {
184                    status_code,
185                    method: "GET".to_string(),
186                    url: url.to_string(),
187                    data: error_enums::GetContactsFindErrors::Status405(data),
188                })
189            }
190            _ => {
191                let expected_status_codes: Vec<String> =
192                    vec!["200".to_string(), "400".to_string(), "405".to_string()];
193                Err(result::Error::UnexpectedStatus {
194                    status_code,
195                    method: "".to_string(),
196                    url: url.to_string(),
197                    response,
198                    expected_status_codes,
199                })
200            }
201        }
202    }
203    /// Add a contact to your audience.
204    pub async fn post_contacts_create(
205        &self,
206        request: PostContactsCreateRequest,
207    ) -> result::Result<ContactSuccessResponse, error_enums::PostContactsCreateErrors> {
208        let endpoint = "/contacts/create";
209        let url = format!("{}{}", self.base_url, endpoint);
210        let query_params: Vec<(&str, String)> = vec![];
211        let unauthed_builder = ReqwestClient::default().post(&url).query(&query_params);
212        let authed_builder = self.builder_with_auth(unauthed_builder, &["apiKey"]);
213        let request_body: serde_json::Value =
214            serde_json::to_value(request.data).map_err(result::Error::Serialize)?;
215        let response = authed_builder
216            .json(&request_body)
217            .send()
218            .await
219            .map_err(result::Error::Dispatch)?;
220        let status_code = response.status().as_u16();
221        match status_code {
222            200 => {
223                let response_text = response.text().await.unwrap_or_default();
224                let data = serde_json::from_str::<ContactSuccessResponse>(&response_text).map_err(
225                    |serde_err| result::Error::UnexpectedResponseBody {
226                        status_code,
227                        method: "POST".to_string(),
228                        url: url.to_string(),
229                        response_text,
230                        expected_signature: "ContactSuccessResponse".to_string(),
231                        serde_err,
232                    },
233                )?;
234                Ok(data)
235            }
236            400 => {
237                let response_text = response.text().await.unwrap_or_default();
238                let data = serde_json::from_str::<ContactFailureResponse>(&response_text).map_err(
239                    |serde_err| result::Error::UnexpectedResponseBody {
240                        status_code,
241                        method: "POST".to_string(),
242                        url: url.to_string(),
243                        response_text,
244                        expected_signature: "ContactFailureResponse".to_string(),
245                        serde_err,
246                    },
247                )?;
248                Err(result::Error::Response {
249                    status_code,
250                    method: "POST".to_string(),
251                    url: url.to_string(),
252                    data: error_enums::PostContactsCreateErrors::Status400(data),
253                })
254            }
255            405 => {
256                let response_text = response.text().await.unwrap_or_default();
257                let data = serde_json::from_str::<ContactFailureResponse>(&response_text).map_err(
258                    |serde_err| result::Error::UnexpectedResponseBody {
259                        status_code,
260                        method: "POST".to_string(),
261                        url: url.to_string(),
262                        response_text,
263                        expected_signature: "ContactFailureResponse".to_string(),
264                        serde_err,
265                    },
266                )?;
267                Err(result::Error::Response {
268                    status_code,
269                    method: "POST".to_string(),
270                    url: url.to_string(),
271                    data: error_enums::PostContactsCreateErrors::Status405(data),
272                })
273            }
274            409 => {
275                let response_text = response.text().await.unwrap_or_default();
276                let data = serde_json::from_str::<ContactFailureResponse>(&response_text).map_err(
277                    |serde_err| result::Error::UnexpectedResponseBody {
278                        status_code,
279                        method: "POST".to_string(),
280                        url: url.to_string(),
281                        response_text,
282                        expected_signature: "ContactFailureResponse".to_string(),
283                        serde_err,
284                    },
285                )?;
286                Err(result::Error::Response {
287                    status_code,
288                    method: "POST".to_string(),
289                    url: url.to_string(),
290                    data: error_enums::PostContactsCreateErrors::Status409(data),
291                })
292            }
293            _ => {
294                let expected_status_codes: Vec<String> = vec![
295                    "200".to_string(),
296                    "400".to_string(),
297                    "405".to_string(),
298                    "409".to_string(),
299                ];
300                Err(result::Error::UnexpectedStatus {
301                    status_code,
302                    method: "".to_string(),
303                    url: url.to_string(),
304                    response,
305                    expected_status_codes,
306                })
307            }
308        }
309    }
310    /// Delete a contact by `email` or `userId`.
311    pub async fn post_contacts_delete(
312        &self,
313        request: PostContactsDeleteRequest,
314    ) -> result::Result<ContactDeleteResponse, error_enums::PostContactsDeleteErrors> {
315        let endpoint = "/contacts/delete";
316        let url = format!("{}{}", self.base_url, endpoint);
317        let query_params: Vec<(&str, String)> = vec![];
318        let unauthed_builder = ReqwestClient::default().post(&url).query(&query_params);
319        let authed_builder = self.builder_with_auth(unauthed_builder, &["apiKey"]);
320        let request_body: serde_json::Value =
321            serde_json::to_value(request.data).map_err(result::Error::Serialize)?;
322        let response = authed_builder
323            .json(&request_body)
324            .send()
325            .await
326            .map_err(result::Error::Dispatch)?;
327        let status_code = response.status().as_u16();
328        match status_code {
329            200 => {
330                let response_text = response.text().await.unwrap_or_default();
331                let data = serde_json::from_str::<ContactDeleteResponse>(&response_text).map_err(
332                    |serde_err| result::Error::UnexpectedResponseBody {
333                        status_code,
334                        method: "POST".to_string(),
335                        url: url.to_string(),
336                        response_text,
337                        expected_signature: "ContactDeleteResponse".to_string(),
338                        serde_err,
339                    },
340                )?;
341                Ok(data)
342            }
343            400 => {
344                let response_text = response.text().await.unwrap_or_default();
345                let data = serde_json::from_str::<ContactFailureResponse>(&response_text).map_err(
346                    |serde_err| result::Error::UnexpectedResponseBody {
347                        status_code,
348                        method: "POST".to_string(),
349                        url: url.to_string(),
350                        response_text,
351                        expected_signature: "ContactFailureResponse".to_string(),
352                        serde_err,
353                    },
354                )?;
355                Err(result::Error::Response {
356                    status_code,
357                    method: "POST".to_string(),
358                    url: url.to_string(),
359                    data: error_enums::PostContactsDeleteErrors::Status400(data),
360                })
361            }
362            404 => {
363                let response_text = response.text().await.unwrap_or_default();
364                let data = serde_json::from_str::<ContactFailureResponse>(&response_text).map_err(
365                    |serde_err| result::Error::UnexpectedResponseBody {
366                        status_code,
367                        method: "POST".to_string(),
368                        url: url.to_string(),
369                        response_text,
370                        expected_signature: "ContactFailureResponse".to_string(),
371                        serde_err,
372                    },
373                )?;
374                Err(result::Error::Response {
375                    status_code,
376                    method: "POST".to_string(),
377                    url: url.to_string(),
378                    data: error_enums::PostContactsDeleteErrors::Status404(data),
379                })
380            }
381            405 => {
382                let response_text = response.text().await.unwrap_or_default();
383                let data = serde_json::from_str::<serde_json::Value>(&response_text).map_err(
384                    |serde_err| result::Error::UnexpectedResponseBody {
385                        status_code,
386                        method: "POST".to_string(),
387                        url: url.to_string(),
388                        response_text,
389                        expected_signature: "serde_json::Value".to_string(),
390                        serde_err,
391                    },
392                )?;
393                Err(result::Error::Response {
394                    status_code,
395                    method: "POST".to_string(),
396                    url: url.to_string(),
397                    data: error_enums::PostContactsDeleteErrors::Status405(data),
398                })
399            }
400            500 => {
401                let response_text = response.text().await.unwrap_or_default();
402                let data = serde_json::from_str::<PostContactsDeleteResponse500>(&response_text)
403                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
404                        status_code,
405                        method: "POST".to_string(),
406                        url: url.to_string(),
407                        response_text,
408                        expected_signature: "PostContactsDeleteResponse500".to_string(),
409                        serde_err,
410                    })?;
411                Err(result::Error::Response {
412                    status_code,
413                    method: "POST".to_string(),
414                    url: url.to_string(),
415                    data: error_enums::PostContactsDeleteErrors::Status500(data),
416                })
417            }
418            _ => {
419                let expected_status_codes: Vec<String> = vec![
420                    "200".to_string(),
421                    "400".to_string(),
422                    "404".to_string(),
423                    "405".to_string(),
424                    "500".to_string(),
425                ];
426                Err(result::Error::UnexpectedStatus {
427                    status_code,
428                    method: "".to_string(),
429                    url: url.to_string(),
430                    response,
431                    expected_status_codes,
432                })
433            }
434        }
435    }
436    /// Send events to trigger emails in Loops.<br>If a contact with the provided `email` doesn't exist, one will be created.
437    pub async fn post_events_send(
438        &self,
439        request: PostEventsSendRequest,
440    ) -> result::Result<EventSuccessResponse, error_enums::PostEventsSendErrors> {
441        let endpoint = "/events/send";
442        let url = format!("{}{}", self.base_url, endpoint);
443        let query_params: Vec<(&str, String)> = vec![];
444        let unauthed_builder = ReqwestClient::default().post(&url).query(&query_params);
445        let authed_builder = self.builder_with_auth(unauthed_builder, &["apiKey"]);
446        let request_body: serde_json::Value =
447            serde_json::to_value(request.data).map_err(result::Error::Serialize)?;
448        let response = authed_builder
449            .json(&request_body)
450            .send()
451            .await
452            .map_err(result::Error::Dispatch)?;
453        let status_code = response.status().as_u16();
454        match status_code {
455            200 => {
456                let response_text = response.text().await.unwrap_or_default();
457                let data = serde_json::from_str::<EventSuccessResponse>(&response_text).map_err(
458                    |serde_err| result::Error::UnexpectedResponseBody {
459                        status_code,
460                        method: "POST".to_string(),
461                        url: url.to_string(),
462                        response_text,
463                        expected_signature: "EventSuccessResponse".to_string(),
464                        serde_err,
465                    },
466                )?;
467                Ok(data)
468            }
469            400 => {
470                let response_text = response.text().await.unwrap_or_default();
471                let data = serde_json::from_str::<EventFailureResponse>(&response_text).map_err(
472                    |serde_err| result::Error::UnexpectedResponseBody {
473                        status_code,
474                        method: "POST".to_string(),
475                        url: url.to_string(),
476                        response_text,
477                        expected_signature: "EventFailureResponse".to_string(),
478                        serde_err,
479                    },
480                )?;
481                Err(result::Error::Response {
482                    status_code,
483                    method: "POST".to_string(),
484                    url: url.to_string(),
485                    data: error_enums::PostEventsSendErrors::Status400(data),
486                })
487            }
488            405 => {
489                let response_text = response.text().await.unwrap_or_default();
490                let data = serde_json::from_str::<serde_json::Value>(&response_text).map_err(
491                    |serde_err| result::Error::UnexpectedResponseBody {
492                        status_code,
493                        method: "POST".to_string(),
494                        url: url.to_string(),
495                        response_text,
496                        expected_signature: "serde_json::Value".to_string(),
497                        serde_err,
498                    },
499                )?;
500                Err(result::Error::Response {
501                    status_code,
502                    method: "POST".to_string(),
503                    url: url.to_string(),
504                    data: error_enums::PostEventsSendErrors::Status405(data),
505                })
506            }
507            _ => {
508                let expected_status_codes: Vec<String> =
509                    vec!["200".to_string(), "400".to_string(), "405".to_string()];
510                Err(result::Error::UnexpectedStatus {
511                    status_code,
512                    method: "".to_string(),
513                    url: url.to_string(),
514                    response,
515                    expected_status_codes,
516                })
517            }
518        }
519    }
520    /// Send a transactional email to a contact.
521    pub async fn post_transactional(
522        &self,
523        request: PostTransactionalRequest,
524    ) -> result::Result<TransactionalSuccessResponse, error_enums::PostTransactionalErrors> {
525        let endpoint = "/transactional";
526        let url = format!("{}{}", self.base_url, endpoint);
527        let query_params: Vec<(&str, String)> = vec![];
528        let unauthed_builder = ReqwestClient::default().post(&url).query(&query_params);
529        let authed_builder = self.builder_with_auth(unauthed_builder, &["apiKey"]);
530        let request_body: serde_json::Value =
531            serde_json::to_value(request.data).map_err(result::Error::Serialize)?;
532        let response = authed_builder
533            .json(&request_body)
534            .send()
535            .await
536            .map_err(result::Error::Dispatch)?;
537        let status_code = response.status().as_u16();
538        match status_code {
539            200 => {
540                let response_text = response.text().await.unwrap_or_default();
541                let data = serde_json::from_str::<TransactionalSuccessResponse>(&response_text)
542                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
543                        status_code,
544                        method: "POST".to_string(),
545                        url: url.to_string(),
546                        response_text,
547                        expected_signature: "TransactionalSuccessResponse".to_string(),
548                        serde_err,
549                    })?;
550                Ok(data)
551            }
552            400 => {
553                let response_text = response.text().await.unwrap_or_default();
554                let data =
555                    serde_json::from_str::<PostTransactionalResponse400Union>(&response_text)
556                        .map_err(|serde_err| result::Error::UnexpectedResponseBody {
557                            status_code,
558                            method: "POST".to_string(),
559                            url: url.to_string(),
560                            response_text,
561                            expected_signature: "PostTransactionalResponse400Union".to_string(),
562                            serde_err,
563                        })?;
564                Err(result::Error::Response {
565                    status_code,
566                    method: "POST".to_string(),
567                    url: url.to_string(),
568                    data: error_enums::PostTransactionalErrors::Status400(data),
569                })
570            }
571            404 => {
572                let response_text = response.text().await.unwrap_or_default();
573                let data = serde_json::from_str::<TransactionalFailure2Response>(&response_text)
574                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
575                        status_code,
576                        method: "POST".to_string(),
577                        url: url.to_string(),
578                        response_text,
579                        expected_signature: "TransactionalFailure2Response".to_string(),
580                        serde_err,
581                    })?;
582                Err(result::Error::Response {
583                    status_code,
584                    method: "POST".to_string(),
585                    url: url.to_string(),
586                    data: error_enums::PostTransactionalErrors::Status404(data),
587                })
588            }
589            405 => {
590                let response_text = response.text().await.unwrap_or_default();
591                let data = serde_json::from_str::<serde_json::Value>(&response_text).map_err(
592                    |serde_err| result::Error::UnexpectedResponseBody {
593                        status_code,
594                        method: "POST".to_string(),
595                        url: url.to_string(),
596                        response_text,
597                        expected_signature: "serde_json::Value".to_string(),
598                        serde_err,
599                    },
600                )?;
601                Err(result::Error::Response {
602                    status_code,
603                    method: "POST".to_string(),
604                    url: url.to_string(),
605                    data: error_enums::PostTransactionalErrors::Status405(data),
606                })
607            }
608            _ => {
609                let expected_status_codes: Vec<String> = vec![
610                    "200".to_string(),
611                    "400".to_string(),
612                    "404".to_string(),
613                    "405".to_string(),
614                ];
615                Err(result::Error::UnexpectedStatus {
616                    status_code,
617                    method: "".to_string(),
618                    url: url.to_string(),
619                    response,
620                    expected_status_codes,
621                })
622            }
623        }
624    }
625    /// Update a contact by `email` or `userId`.<br>If you want to update a contact’s email address, the contact will first need a `userId` value. You can then make a request containing the userId field along with an updated email address.
626    pub async fn put_contacts_update(
627        &self,
628        request: PutContactsUpdateRequest,
629    ) -> result::Result<ContactSuccessResponse, error_enums::PutContactsUpdateErrors> {
630        let endpoint = "/contacts/update";
631        let url = format!("{}{}", self.base_url, endpoint);
632        let query_params: Vec<(&str, String)> = vec![];
633        let unauthed_builder = ReqwestClient::default().put(&url).query(&query_params);
634        let authed_builder = self.builder_with_auth(unauthed_builder, &["apiKey"]);
635        let request_body: serde_json::Value =
636            serde_json::to_value(request.data).map_err(result::Error::Serialize)?;
637        let response = authed_builder
638            .json(&request_body)
639            .send()
640            .await
641            .map_err(result::Error::Dispatch)?;
642        let status_code = response.status().as_u16();
643        match status_code {
644            200 => {
645                let response_text = response.text().await.unwrap_or_default();
646                let data = serde_json::from_str::<ContactSuccessResponse>(&response_text).map_err(
647                    |serde_err| result::Error::UnexpectedResponseBody {
648                        status_code,
649                        method: "PUT".to_string(),
650                        url: url.to_string(),
651                        response_text,
652                        expected_signature: "ContactSuccessResponse".to_string(),
653                        serde_err,
654                    },
655                )?;
656                Ok(data)
657            }
658            400 => {
659                let response_text = response.text().await.unwrap_or_default();
660                let data = serde_json::from_str::<ContactFailureResponse>(&response_text).map_err(
661                    |serde_err| result::Error::UnexpectedResponseBody {
662                        status_code,
663                        method: "PUT".to_string(),
664                        url: url.to_string(),
665                        response_text,
666                        expected_signature: "ContactFailureResponse".to_string(),
667                        serde_err,
668                    },
669                )?;
670                Err(result::Error::Response {
671                    status_code,
672                    method: "PUT".to_string(),
673                    url: url.to_string(),
674                    data: error_enums::PutContactsUpdateErrors::Status400(data),
675                })
676            }
677            405 => {
678                let response_text = response.text().await.unwrap_or_default();
679                let data = serde_json::from_str::<ContactFailureResponse>(&response_text).map_err(
680                    |serde_err| result::Error::UnexpectedResponseBody {
681                        status_code,
682                        method: "PUT".to_string(),
683                        url: url.to_string(),
684                        response_text,
685                        expected_signature: "ContactFailureResponse".to_string(),
686                        serde_err,
687                    },
688                )?;
689                Err(result::Error::Response {
690                    status_code,
691                    method: "PUT".to_string(),
692                    url: url.to_string(),
693                    data: error_enums::PutContactsUpdateErrors::Status405(data),
694                })
695            }
696            _ => {
697                let expected_status_codes: Vec<String> =
698                    vec!["200".to_string(), "400".to_string(), "405".to_string()];
699                Err(result::Error::UnexpectedStatus {
700                    status_code,
701                    method: "".to_string(),
702                    url: url.to_string(),
703                    response,
704                    expected_status_codes,
705                })
706            }
707        }
708    }
709}
loops_sdk/lib.rs

loops_sdk/
lib.rs
