1use super::types::*;
12use anyhow::Context;
13use reqwest::{Client, Url};
14use validator::Validate;
15pub const BASE_URL: &str = "https://app.loops.so/api";
16#[derive(Debug, Clone)]
17pub struct LoopsOpenApiSpecClient {
18 pub client: Client,
19 pub base_url: Url,
20}
21impl Default for LoopsOpenApiSpecClient {
22 fn default() -> Self {
23 Self::new()
24 }
25}
26impl LoopsOpenApiSpecClient {
27 #[must_use]
29 #[track_caller]
30 pub fn new() -> Self {
31 Self {
32 client: Client::builder().build().expect("client"),
33 base_url: Url::parse(BASE_URL).expect("valid base url"),
34 }
35 }
36 pub fn with_base_url(base_url: impl AsRef<str>) -> anyhow::Result<Self> {
38 Ok(Self {
39 client: Client::builder()
40 .build()
41 .context("building reqwest client")?,
42 base_url: Url::parse(base_url.as_ref()).context("parsing base url")?,
43 })
44 }
45 pub fn with_client(base_url: impl AsRef<str>, client: Client) -> anyhow::Result<Self> {
47 let url = Url::parse(base_url.as_ref()).context("parsing base url")?;
48 Ok(Self {
49 client,
50 base_url: url,
51 })
52 }
53 pub async fn test_api_key(
59 &self,
60 request: TestApiKeyRequest,
61 ) -> anyhow::Result<TestApiKeyResponse> {
62 request.validate().context("parameter validation")?;
63 let mut url = self.base_url.clone();
64 url.path_segments_mut()
65 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
66 .push("v1")
67 .push("api-key");
68 let response = self.client.get(url).send().await?;
69 Ok(TestApiKeyRequest::parse_response(response).await?)
70 }
71 pub async fn get_audience_segment(
77 &self,
78 request: GetAudienceSegmentRequest,
79 ) -> anyhow::Result<GetAudienceSegmentResponse> {
80 request.validate().context("parameter validation")?;
81 let mut url = self.base_url.clone();
82 url.path_segments_mut()
83 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
84 .push("v1")
85 .push("audience-segments")
86 .push(&request.path.audience_segment_id.to_string());
87 let response = self.client.get(url).send().await?;
88 Ok(GetAudienceSegmentRequest::parse_response(response).await?)
89 }
90 pub async fn list_audience_segments(
96 &self,
97 request: ListAudienceSegmentsRequest,
98 ) -> anyhow::Result<ListAudienceSegmentsResponseEnum> {
99 request.validate().context("parameter validation")?;
100 let mut url = self.base_url.clone();
101 url.path_segments_mut()
102 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
103 .push("v1")
104 .push("audience-segments");
105 let response = self.client.get(url).query(&request.query).send().await?;
106 Ok(ListAudienceSegmentsRequest::parse_response(response).await?)
107 }
108 pub async fn create_audience_segment(
114 &self,
115 request: CreateAudienceSegmentRequestParams,
116 ) -> anyhow::Result<GetAudienceSegmentResponse> {
117 request.validate().context("parameter validation")?;
118 let mut url = self.base_url.clone();
119 url.path_segments_mut()
120 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
121 .push("v1")
122 .push("audience-segments");
123 let response = self.client.post(url).json(&request.body).send().await?;
124 Ok(CreateAudienceSegmentRequestParams::parse_response(response).await?)
125 }
126 pub async fn list_campaigns(
132 &self,
133 request: ListCampaignsRequest,
134 ) -> anyhow::Result<ListCampaignsResponseEnum> {
135 request.validate().context("parameter validation")?;
136 let mut url = self.base_url.clone();
137 url.path_segments_mut()
138 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
139 .push("v1")
140 .push("campaigns");
141 let response = self.client.get(url).query(&request.query).send().await?;
142 Ok(ListCampaignsRequest::parse_response(response).await?)
143 }
144 pub async fn create_campaign(
150 &self,
151 request: CreateCampaignRequestParams,
152 ) -> anyhow::Result<CreateCampaignResponseEnum> {
153 request.validate().context("parameter validation")?;
154 let mut url = self.base_url.clone();
155 url.path_segments_mut()
156 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
157 .push("v1")
158 .push("campaigns");
159 let response = self.client.post(url).json(&request.body).send().await?;
160 Ok(CreateCampaignRequestParams::parse_response(response).await?)
161 }
162 pub async fn get_campaign(
168 &self,
169 request: GetCampaignRequest,
170 ) -> anyhow::Result<GetCampaignResponse> {
171 request.validate().context("parameter validation")?;
172 let mut url = self.base_url.clone();
173 url.path_segments_mut()
174 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
175 .push("v1")
176 .push("campaigns")
177 .push(&request.path.campaign_id.to_string());
178 let response = self.client.get(url).send().await?;
179 Ok(GetCampaignRequest::parse_response(response).await?)
180 }
181 pub async fn update_campaign(
187 &self,
188 request: UpdateCampaignRequestParams,
189 ) -> anyhow::Result<UpdateCampaignResponse> {
190 request.validate().context("parameter validation")?;
191 let mut url = self.base_url.clone();
192 url.path_segments_mut()
193 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
194 .push("v1")
195 .push("campaigns")
196 .push(&request.path.campaign_id.to_string());
197 let response = self.client.post(url).json(&request.body).send().await?;
198 Ok(UpdateCampaignRequestParams::parse_response(response).await?)
199 }
200 pub async fn get_campaign_metrics(
206 &self,
207 request: GetCampaignMetricsRequest,
208 ) -> anyhow::Result<GetCampaignMetricsResponse> {
209 request.validate().context("parameter validation")?;
210 let mut url = self.base_url.clone();
211 url.path_segments_mut()
212 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
213 .push("v1")
214 .push("campaigns")
215 .push(&request.path.campaign_id.to_string())
216 .push("metrics");
217 let response = self.client.get(url).send().await?;
218 Ok(GetCampaignMetricsRequest::parse_response(response).await?)
219 }
220 pub async fn list_campaign_groups(
226 &self,
227 request: ListCampaignGroupsRequest,
228 ) -> anyhow::Result<ListCampaignGroupsResponse> {
229 request.validate().context("parameter validation")?;
230 let mut url = self.base_url.clone();
231 url.path_segments_mut()
232 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
233 .push("v1")
234 .push("campaign-groups");
235 let response = self.client.get(url).query(&request.query).send().await?;
236 Ok(ListCampaignGroupsRequest::parse_response(response).await?)
237 }
238 pub async fn create_campaign_group(
244 &self,
245 request: CreateCampaignGroupRequest,
246 ) -> anyhow::Result<CreateCampaignGroupResponse> {
247 request.validate().context("parameter validation")?;
248 let mut url = self.base_url.clone();
249 url.path_segments_mut()
250 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
251 .push("v1")
252 .push("campaign-groups");
253 let response = self.client.post(url).json(&request.body).send().await?;
254 Ok(CreateCampaignGroupRequest::parse_response(response).await?)
255 }
256 pub async fn get_campaign_group(
262 &self,
263 request: GetCampaignGroupRequest,
264 ) -> anyhow::Result<GetCampaignGroupResponse> {
265 request.validate().context("parameter validation")?;
266 let mut url = self.base_url.clone();
267 url.path_segments_mut()
268 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
269 .push("v1")
270 .push("campaign-groups")
271 .push(&request.path.campaign_group_id.to_string());
272 let response = self.client.get(url).send().await?;
273 Ok(GetCampaignGroupRequest::parse_response(response).await?)
274 }
275 pub async fn update_campaign_group(
281 &self,
282 request: UpdateCampaignGroupRequest,
283 ) -> anyhow::Result<GetCampaignGroupResponse> {
284 request.validate().context("parameter validation")?;
285 let mut url = self.base_url.clone();
286 url.path_segments_mut()
287 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
288 .push("v1")
289 .push("campaign-groups")
290 .push(&request.path.campaign_group_id.to_string());
291 let response = self.client.post(url).json(&request.body).send().await?;
292 Ok(UpdateCampaignGroupRequest::parse_response(response).await?)
293 }
294 pub async fn list_dedicated_sending_ips(
304 &self,
305 request: ListDedicatedSendingIpsRequest,
306 ) -> anyhow::Result<ListDedicatedSendingIpsResponse> {
307 request.validate().context("parameter validation")?;
308 let mut url = self.base_url.clone();
309 url.path_segments_mut()
310 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
311 .push("v1")
312 .push("dedicated-sending-ips");
313 let response = self.client.get(url).send().await?;
314 Ok(ListDedicatedSendingIpsRequest::parse_response(response).await?)
315 }
316 pub async fn create_contact(
322 &self,
323 request: CreateContactRequest,
324 ) -> anyhow::Result<CreateContactResponse> {
325 request.validate().context("parameter validation")?;
326 let mut url = self.base_url.clone();
327 url.path_segments_mut()
328 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
329 .push("v1")
330 .push("contacts")
331 .push("create");
332 let response = self.client.post(url).json(&request.body).send().await?;
333 Ok(CreateContactRequest::parse_response(response).await?)
334 }
335 pub async fn update_contact(
347 &self,
348 request: UpdateContactRequest,
349 ) -> anyhow::Result<UpdateContactResponse> {
350 request.validate().context("parameter validation")?;
351 let mut url = self.base_url.clone();
352 url.path_segments_mut()
353 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
354 .push("v1")
355 .push("contacts")
356 .push("update");
357 let response = self.client.put(url).json(&request.body).send().await?;
358 Ok(UpdateContactRequest::parse_response(response).await?)
359 }
360 pub async fn find_contact(
366 &self,
367 request: FindContactRequest,
368 ) -> anyhow::Result<FindContactResponse> {
369 request.validate().context("parameter validation")?;
370 let mut url = self.base_url.clone();
371 url.path_segments_mut()
372 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
373 .push("v1")
374 .push("contacts")
375 .push("find");
376 let response = self.client.get(url).query(&request.query).send().await?;
377 Ok(FindContactRequest::parse_response(response).await?)
378 }
379 pub async fn delete_contact(
385 &self,
386 request: DeleteContactRequest,
387 ) -> anyhow::Result<DeleteContactResponse> {
388 request.validate().context("parameter validation")?;
389 let mut url = self.base_url.clone();
390 url.path_segments_mut()
391 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
392 .push("v1")
393 .push("contacts")
394 .push("delete");
395 let response = self.client.post(url).json(&request.body).send().await?;
396 Ok(DeleteContactRequest::parse_response(response).await?)
397 }
398 pub async fn get_contact_suppression(
404 &self,
405 request: GetContactSuppressionRequest,
406 ) -> anyhow::Result<GetContactSuppressionResponse> {
407 request.validate().context("parameter validation")?;
408 let mut url = self.base_url.clone();
409 url.path_segments_mut()
410 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
411 .push("v1")
412 .push("contacts")
413 .push("suppression");
414 let response = self.client.get(url).query(&request.query).send().await?;
415 Ok(GetContactSuppressionRequest::parse_response(response).await?)
416 }
417 pub async fn remove_contact_suppression(
423 &self,
424 request: RemoveContactSuppressionRequest,
425 ) -> anyhow::Result<RemoveContactSuppressionResponse> {
426 request.validate().context("parameter validation")?;
427 let mut url = self.base_url.clone();
428 url.path_segments_mut()
429 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
430 .push("v1")
431 .push("contacts")
432 .push("suppression");
433 let response = self.client.delete(url).query(&request.query).send().await?;
434 Ok(RemoveContactSuppressionRequest::parse_response(response).await?)
435 }
436 pub async fn list_contact_properties(
442 &self,
443 request: ListContactPropertiesRequest,
444 ) -> anyhow::Result<ListContactPropertiesResponse> {
445 request.validate().context("parameter validation")?;
446 let mut url = self.base_url.clone();
447 url.path_segments_mut()
448 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
449 .push("v1")
450 .push("contacts")
451 .push("properties");
452 let response = self.client.get(url).query(&request.query).send().await?;
453 Ok(ListContactPropertiesRequest::parse_response(response).await?)
454 }
455 pub async fn create_contact_property(
461 &self,
462 request: CreateContactPropertyRequest,
463 ) -> anyhow::Result<CreateContactPropertyResponse> {
464 request.validate().context("parameter validation")?;
465 let mut url = self.base_url.clone();
466 url.path_segments_mut()
467 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
468 .push("v1")
469 .push("contacts")
470 .push("properties");
471 let response = self.client.post(url).json(&request.body).send().await?;
472 Ok(CreateContactPropertyRequest::parse_response(response).await?)
473 }
474 pub async fn get_component(
480 &self,
481 request: GetComponentRequest,
482 ) -> anyhow::Result<GetComponentResponse> {
483 request.validate().context("parameter validation")?;
484 let mut url = self.base_url.clone();
485 url.path_segments_mut()
486 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
487 .push("v1")
488 .push("components")
489 .push(&request.path.component_id.to_string());
490 let response = self.client.get(url).send().await?;
491 Ok(GetComponentRequest::parse_response(response).await?)
492 }
493 pub async fn update_component(
499 &self,
500 request: UpdateComponentRequest,
501 ) -> anyhow::Result<UpdateComponentResponseEnum> {
502 request.validate().context("parameter validation")?;
503 let mut url = self.base_url.clone();
504 url.path_segments_mut()
505 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
506 .push("v1")
507 .push("components")
508 .push(&request.path.component_id.to_string());
509 let response = self.client.post(url).json(&request.body).send().await?;
510 Ok(UpdateComponentRequest::parse_response(response).await?)
511 }
512 pub async fn list_components(
518 &self,
519 request: ListComponentsRequest,
520 ) -> anyhow::Result<ListComponentsResponseEnum> {
521 request.validate().context("parameter validation")?;
522 let mut url = self.base_url.clone();
523 url.path_segments_mut()
524 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
525 .push("v1")
526 .push("components");
527 let response = self.client.get(url).query(&request.query).send().await?;
528 Ok(ListComponentsRequest::parse_response(response).await?)
529 }
530 pub async fn create_component(
536 &self,
537 request: CreateComponentRequest,
538 ) -> anyhow::Result<CreateComponentResponse> {
539 request.validate().context("parameter validation")?;
540 let mut url = self.base_url.clone();
541 url.path_segments_mut()
542 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
543 .push("v1")
544 .push("components");
545 let response = self.client.post(url).json(&request.body).send().await?;
546 Ok(CreateComponentRequest::parse_response(response).await?)
547 }
548 pub async fn get_email_message(
554 &self,
555 request: GetEmailMessageRequest,
556 ) -> anyhow::Result<GetEmailMessageResponse> {
557 request.validate().context("parameter validation")?;
558 let mut url = self.base_url.clone();
559 url.path_segments_mut()
560 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
561 .push("v1")
562 .push("email-messages")
563 .push(&request.path.email_message_id.to_string());
564 let response = self.client.get(url).send().await?;
565 Ok(GetEmailMessageRequest::parse_response(response).await?)
566 }
567 pub async fn update_email_message(
573 &self,
574 request: UpdateEmailMessageRequestParams,
575 ) -> anyhow::Result<UpdateEmailMessageResponse> {
576 request.validate().context("parameter validation")?;
577 let mut url = self.base_url.clone();
578 url.path_segments_mut()
579 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
580 .push("v1")
581 .push("email-messages")
582 .push(&request.path.email_message_id.to_string());
583 let response = self.client.post(url).json(&request.body).send().await?;
584 Ok(UpdateEmailMessageRequestParams::parse_response(response).await?)
585 }
586 pub async fn preview_email_message(
592 &self,
593 request: PreviewEmailMessageRequest,
594 ) -> anyhow::Result<PreviewEmailMessageResponse> {
595 request.validate().context("parameter validation")?;
596 let mut url = self.base_url.clone();
597 url.path_segments_mut()
598 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
599 .push("v1")
600 .push("email-messages")
601 .push(&request.path.email_message_id.to_string())
602 .push("preview");
603 let response = self.client.post(url).json(&request.body).send().await?;
604 Ok(PreviewEmailMessageRequest::parse_response(response).await?)
605 }
606 pub async fn get_email_message_guardian(
612 &self,
613 request: GetEmailMessageGuardianRequest,
614 ) -> anyhow::Result<GetEmailMessageGuardianResponse> {
615 request.validate().context("parameter validation")?;
616 let mut url = self.base_url.clone();
617 url.path_segments_mut()
618 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
619 .push("v1")
620 .push("email-messages")
621 .push(&request.path.email_message_id.to_string())
622 .push("guardian");
623 let response = self.client.get(url).send().await?;
624 Ok(GetEmailMessageGuardianRequest::parse_response(response).await?)
625 }
626 pub async fn send_event(&self, request: SendEventRequest) -> anyhow::Result<SendEventResponse> {
632 request.validate().context("parameter validation")?;
633 let mut url = self.base_url.clone();
634 url.path_segments_mut()
635 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
636 .push("v1")
637 .push("events")
638 .push("send");
639 let response = self
640 .client
641 .post(url)
642 .headers(
643 http::HeaderMap::try_from(&request.header).context("building request headers")?,
644 )
645 .json(&request.body)
646 .send()
647 .await?;
648 Ok(SendEventRequest::parse_response(response).await?)
649 }
650 pub async fn list_event_patterns(
656 &self,
657 request: ListEventPatternsRequest,
658 ) -> anyhow::Result<ListEventPatternsResponseEnum> {
659 request.validate().context("parameter validation")?;
660 let mut url = self.base_url.clone();
661 url.path_segments_mut()
662 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
663 .push("v1")
664 .push("event-patterns");
665 let response = self.client.get(url).query(&request.query).send().await?;
666 Ok(ListEventPatternsRequest::parse_response(response).await?)
667 }
668 pub async fn get_event_pattern_by_name(
674 &self,
675 request: GetEventPatternByNameRequest,
676 ) -> anyhow::Result<GetEventPatternResponse> {
677 request.validate().context("parameter validation")?;
678 let mut url = self.base_url.clone();
679 url.path_segments_mut()
680 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
681 .push("v1")
682 .push("event-patterns")
683 .push("by-name")
684 .push(&request.path.event_name.to_string());
685 let response = self.client.get(url).send().await?;
686 Ok(GetEventPatternByNameRequest::parse_response(response).await?)
687 }
688 pub async fn get_event_pattern(
694 &self,
695 request: GetEventPatternRequest,
696 ) -> anyhow::Result<GetEventPatternResponse> {
697 request.validate().context("parameter validation")?;
698 let mut url = self.base_url.clone();
699 url.path_segments_mut()
700 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
701 .push("v1")
702 .push("event-patterns")
703 .push(&request.path.event_pattern_id.to_string());
704 let response = self.client.get(url).send().await?;
705 Ok(GetEventPatternRequest::parse_response(response).await?)
706 }
707 pub async fn list_mailing_lists(
713 &self,
714 request: ListMailingListsRequest,
715 ) -> anyhow::Result<ListMailingListsResponse> {
716 request.validate().context("parameter validation")?;
717 let mut url = self.base_url.clone();
718 url.path_segments_mut()
719 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
720 .push("v1")
721 .push("lists");
722 let response = self.client.get(url).send().await?;
723 Ok(ListMailingListsRequest::parse_response(response).await?)
724 }
725 pub async fn get_theme(&self, request: GetThemeRequest) -> anyhow::Result<GetThemeResponse> {
731 request.validate().context("parameter validation")?;
732 let mut url = self.base_url.clone();
733 url.path_segments_mut()
734 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
735 .push("v1")
736 .push("themes")
737 .push(&request.path.theme_id.to_string());
738 let response = self.client.get(url).send().await?;
739 Ok(GetThemeRequest::parse_response(response).await?)
740 }
741 pub async fn update_theme(
747 &self,
748 request: UpdateThemeRequest,
749 ) -> anyhow::Result<UpdateThemeResponseEnum> {
750 request.validate().context("parameter validation")?;
751 let mut url = self.base_url.clone();
752 url.path_segments_mut()
753 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
754 .push("v1")
755 .push("themes")
756 .push(&request.path.theme_id.to_string());
757 let response = self.client.post(url).json(&request.body).send().await?;
758 Ok(UpdateThemeRequest::parse_response(response).await?)
759 }
760 pub async fn list_themes(
766 &self,
767 request: ListThemesRequest,
768 ) -> anyhow::Result<ListThemesResponseEnum> {
769 request.validate().context("parameter validation")?;
770 let mut url = self.base_url.clone();
771 url.path_segments_mut()
772 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
773 .push("v1")
774 .push("themes");
775 let response = self.client.get(url).query(&request.query).send().await?;
776 Ok(ListThemesRequest::parse_response(response).await?)
777 }
778 pub async fn create_theme(
784 &self,
785 request: CreateThemeRequest,
786 ) -> anyhow::Result<CreateThemeResponse> {
787 request.validate().context("parameter validation")?;
788 let mut url = self.base_url.clone();
789 url.path_segments_mut()
790 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
791 .push("v1")
792 .push("themes");
793 let response = self.client.post(url).json(&request.body).send().await?;
794 Ok(CreateThemeRequest::parse_response(response).await?)
795 }
796 pub async fn list_published_transactional_emails(
802 &self,
803 request: ListPublishedTransactionalEmailsRequest,
804 ) -> anyhow::Result<ListPublishedTransactionalEmailsResponse> {
805 request.validate().context("parameter validation")?;
806 let mut url = self.base_url.clone();
807 url.path_segments_mut()
808 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
809 .push("v1")
810 .push("transactional");
811 let response = self.client.get(url).query(&request.query).send().await?;
812 Ok(ListPublishedTransactionalEmailsRequest::parse_response(response).await?)
813 }
814 pub async fn send_transactional_email(
822 &self,
823 request: SendTransactionalEmailRequest,
824 ) -> anyhow::Result<SendTransactionalEmailResponse> {
825 request.validate().context("parameter validation")?;
826 let mut url = self.base_url.clone();
827 url.path_segments_mut()
828 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
829 .push("v1")
830 .push("transactional");
831 let response = self
832 .client
833 .post(url)
834 .headers(
835 http::HeaderMap::try_from(&request.header).context("building request headers")?,
836 )
837 .json(&request.body)
838 .send()
839 .await?;
840 Ok(SendTransactionalEmailRequest::parse_response(response).await?)
841 }
842 pub async fn list_transactional_emails(
848 &self,
849 request: ListTransactionalEmailsRequest,
850 ) -> anyhow::Result<ListTransactionalEmailsResponse> {
851 request.validate().context("parameter validation")?;
852 let mut url = self.base_url.clone();
853 url.path_segments_mut()
854 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
855 .push("v1")
856 .push("transactional-emails");
857 let response = self.client.get(url).query(&request.query).send().await?;
858 Ok(ListTransactionalEmailsRequest::parse_response(response).await?)
859 }
860 pub async fn create_transactional_email(
866 &self,
867 request: CreateTransactionalEmailRequest,
868 ) -> anyhow::Result<CreateTransactionalEmailResponse> {
869 request.validate().context("parameter validation")?;
870 let mut url = self.base_url.clone();
871 url.path_segments_mut()
872 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
873 .push("v1")
874 .push("transactional-emails");
875 let response = self.client.post(url).json(&request.body).send().await?;
876 Ok(CreateTransactionalEmailRequest::parse_response(response).await?)
877 }
878 pub async fn get_transactional_email(
884 &self,
885 request: GetTransactionalEmailRequest,
886 ) -> anyhow::Result<GetTransactionalEmailResponse> {
887 request.validate().context("parameter validation")?;
888 let mut url = self.base_url.clone();
889 url.path_segments_mut()
890 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
891 .push("v1")
892 .push("transactional-emails")
893 .push(&request.path.transactional_id.to_string());
894 let response = self.client.get(url).send().await?;
895 Ok(GetTransactionalEmailRequest::parse_response(response).await?)
896 }
897 pub async fn update_transactional_email(
903 &self,
904 request: UpdateTransactionalEmailRequest,
905 ) -> anyhow::Result<GetTransactionalEmailResponse> {
906 request.validate().context("parameter validation")?;
907 let mut url = self.base_url.clone();
908 url.path_segments_mut()
909 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
910 .push("v1")
911 .push("transactional-emails")
912 .push(&request.path.transactional_id.to_string());
913 let response = self.client.post(url).json(&request.body).send().await?;
914 Ok(UpdateTransactionalEmailRequest::parse_response(response).await?)
915 }
916 pub async fn get_transactional_email_metrics(
922 &self,
923 request: GetTransactionalEmailMetricsRequest,
924 ) -> anyhow::Result<GetTransactionalEmailMetricsResponse> {
925 request.validate().context("parameter validation")?;
926 let mut url = self.base_url.clone();
927 url.path_segments_mut()
928 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
929 .push("v1")
930 .push("transactional-emails")
931 .push(&request.path.transactional_id.to_string())
932 .push("metrics");
933 let response = self.client.get(url).send().await?;
934 Ok(GetTransactionalEmailMetricsRequest::parse_response(response).await?)
935 }
936 pub async fn ensure_transactional_draft(
942 &self,
943 request: EnsureTransactionalDraftRequest,
944 ) -> anyhow::Result<EnsureTransactionalDraftResponse> {
945 request.validate().context("parameter validation")?;
946 let mut url = self.base_url.clone();
947 url.path_segments_mut()
948 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
949 .push("v1")
950 .push("transactional-emails")
951 .push(&request.path.transactional_id.to_string())
952 .push("draft");
953 let response = self.client.post(url).send().await?;
954 Ok(EnsureTransactionalDraftRequest::parse_response(response).await?)
955 }
956 pub async fn publish_transactional_email(
962 &self,
963 request: PublishTransactionalEmailRequest,
964 ) -> anyhow::Result<PublishTransactionalEmailResponse> {
965 request.validate().context("parameter validation")?;
966 let mut url = self.base_url.clone();
967 url.path_segments_mut()
968 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
969 .push("v1")
970 .push("transactional-emails")
971 .push(&request.path.transactional_id.to_string())
972 .push("publish");
973 let response = self.client.post(url).send().await?;
974 Ok(PublishTransactionalEmailRequest::parse_response(response).await?)
975 }
976 pub async fn list_transactional_groups(
982 &self,
983 request: ListTransactionalGroupsRequest,
984 ) -> anyhow::Result<ListCampaignGroupsResponse> {
985 request.validate().context("parameter validation")?;
986 let mut url = self.base_url.clone();
987 url.path_segments_mut()
988 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
989 .push("v1")
990 .push("transactional-groups");
991 let response = self.client.get(url).query(&request.query).send().await?;
992 Ok(ListTransactionalGroupsRequest::parse_response(response).await?)
993 }
994 pub async fn create_transactional_group(
1000 &self,
1001 request: CreateTransactionalGroupRequest,
1002 ) -> anyhow::Result<CreateCampaignGroupResponse> {
1003 request.validate().context("parameter validation")?;
1004 let mut url = self.base_url.clone();
1005 url.path_segments_mut()
1006 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1007 .push("v1")
1008 .push("transactional-groups");
1009 let response = self.client.post(url).json(&request.body).send().await?;
1010 Ok(CreateTransactionalGroupRequest::parse_response(response).await?)
1011 }
1012 pub async fn get_transactional_group(
1018 &self,
1019 request: GetTransactionalGroupRequest,
1020 ) -> anyhow::Result<GetCampaignGroupResponse> {
1021 request.validate().context("parameter validation")?;
1022 let mut url = self.base_url.clone();
1023 url.path_segments_mut()
1024 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1025 .push("v1")
1026 .push("transactional-groups")
1027 .push(&request.path.transactional_group_id.to_string());
1028 let response = self.client.get(url).send().await?;
1029 Ok(GetTransactionalGroupRequest::parse_response(response).await?)
1030 }
1031 pub async fn update_transactional_group(
1037 &self,
1038 request: UpdateTransactionalGroupRequest,
1039 ) -> anyhow::Result<GetCampaignGroupResponse> {
1040 request.validate().context("parameter validation")?;
1041 let mut url = self.base_url.clone();
1042 url.path_segments_mut()
1043 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1044 .push("v1")
1045 .push("transactional-groups")
1046 .push(&request.path.transactional_group_id.to_string());
1047 let response = self.client.post(url).json(&request.body).send().await?;
1048 Ok(UpdateTransactionalGroupRequest::parse_response(response).await?)
1049 }
1050 pub async fn create_upload(
1056 &self,
1057 request: CreateUploadRequestParams,
1058 ) -> anyhow::Result<CreateUploadResponseEnum> {
1059 request.validate().context("parameter validation")?;
1060 let mut url = self.base_url.clone();
1061 url.path_segments_mut()
1062 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1063 .push("v1")
1064 .push("uploads");
1065 let response = self.client.post(url).json(&request.body).send().await?;
1066 Ok(CreateUploadRequestParams::parse_response(response).await?)
1067 }
1068 pub async fn complete_upload(
1074 &self,
1075 request: CompleteUploadRequest,
1076 ) -> anyhow::Result<CompleteUploadResponseEnum> {
1077 request.validate().context("parameter validation")?;
1078 let mut url = self.base_url.clone();
1079 url.path_segments_mut()
1080 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1081 .push("v1")
1082 .push("uploads")
1083 .push(&request.path.email_asset_id.to_string())
1084 .push("complete");
1085 let response = self.client.post(url).send().await?;
1086 Ok(CompleteUploadRequest::parse_response(response).await?)
1087 }
1088 pub async fn list_workflow_groups(
1094 &self,
1095 request: ListWorkflowGroupsRequest,
1096 ) -> anyhow::Result<ListCampaignGroupsResponse> {
1097 request.validate().context("parameter validation")?;
1098 let mut url = self.base_url.clone();
1099 url.path_segments_mut()
1100 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1101 .push("v1")
1102 .push("workflow-groups");
1103 let response = self.client.get(url).query(&request.query).send().await?;
1104 Ok(ListWorkflowGroupsRequest::parse_response(response).await?)
1105 }
1106 pub async fn create_workflow_group(
1112 &self,
1113 request: CreateWorkflowGroupRequest,
1114 ) -> anyhow::Result<CreateCampaignGroupResponse> {
1115 request.validate().context("parameter validation")?;
1116 let mut url = self.base_url.clone();
1117 url.path_segments_mut()
1118 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1119 .push("v1")
1120 .push("workflow-groups");
1121 let response = self.client.post(url).json(&request.body).send().await?;
1122 Ok(CreateWorkflowGroupRequest::parse_response(response).await?)
1123 }
1124 pub async fn get_workflow_group(
1130 &self,
1131 request: GetWorkflowGroupRequest,
1132 ) -> anyhow::Result<GetCampaignGroupResponse> {
1133 request.validate().context("parameter validation")?;
1134 let mut url = self.base_url.clone();
1135 url.path_segments_mut()
1136 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1137 .push("v1")
1138 .push("workflow-groups")
1139 .push(&request.path.workflow_group_id.to_string());
1140 let response = self.client.get(url).send().await?;
1141 Ok(GetWorkflowGroupRequest::parse_response(response).await?)
1142 }
1143 pub async fn update_workflow_group(
1149 &self,
1150 request: UpdateWorkflowGroupRequest,
1151 ) -> anyhow::Result<GetCampaignGroupResponse> {
1152 request.validate().context("parameter validation")?;
1153 let mut url = self.base_url.clone();
1154 url.path_segments_mut()
1155 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1156 .push("v1")
1157 .push("workflow-groups")
1158 .push(&request.path.workflow_group_id.to_string());
1159 let response = self.client.post(url).json(&request.body).send().await?;
1160 Ok(UpdateWorkflowGroupRequest::parse_response(response).await?)
1161 }
1162 pub async fn list_workflows(
1168 &self,
1169 request: ListWorkflowsRequest,
1170 ) -> anyhow::Result<ListWorkflowsResponseEnum> {
1171 request.validate().context("parameter validation")?;
1172 let mut url = self.base_url.clone();
1173 url.path_segments_mut()
1174 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1175 .push("v1")
1176 .push("workflows");
1177 let response = self.client.get(url).query(&request.query).send().await?;
1178 Ok(ListWorkflowsRequest::parse_response(response).await?)
1179 }
1180 pub async fn create_workflow(
1186 &self,
1187 request: CreateWorkflowRequestParams,
1188 ) -> anyhow::Result<CreateWorkflowResponse> {
1189 request.validate().context("parameter validation")?;
1190 let mut url = self.base_url.clone();
1191 url.path_segments_mut()
1192 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1193 .push("v1")
1194 .push("workflows");
1195 let response = self.client.post(url).json(&request.body).send().await?;
1196 Ok(CreateWorkflowRequestParams::parse_response(response).await?)
1197 }
1198 pub async fn get_workflow(
1204 &self,
1205 request: GetWorkflowRequest,
1206 ) -> anyhow::Result<GetWorkflowResponse> {
1207 request.validate().context("parameter validation")?;
1208 let mut url = self.base_url.clone();
1209 url.path_segments_mut()
1210 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1211 .push("v1")
1212 .push("workflows")
1213 .push(&request.path.workflow_id.to_string());
1214 let response = self.client.get(url).send().await?;
1215 Ok(GetWorkflowRequest::parse_response(response).await?)
1216 }
1217 pub async fn update_workflow_properties(
1223 &self,
1224 request: UpdateWorkflowPropertiesRequestParams,
1225 ) -> anyhow::Result<UpdateWorkflowPropertiesResponse> {
1226 request.validate().context("parameter validation")?;
1227 let mut url = self.base_url.clone();
1228 url.path_segments_mut()
1229 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1230 .push("v1")
1231 .push("workflows")
1232 .push(&request.path.workflow_id.to_string());
1233 let response = self.client.post(url).json(&request.body).send().await?;
1234 Ok(UpdateWorkflowPropertiesRequestParams::parse_response(response).await?)
1235 }
1236 pub async fn delete_workflow(
1242 &self,
1243 request: DeleteWorkflowRequestParams,
1244 ) -> anyhow::Result<DeleteWorkflowResponse> {
1245 request.validate().context("parameter validation")?;
1246 let mut url = self.base_url.clone();
1247 url.path_segments_mut()
1248 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1249 .push("v1")
1250 .push("workflows")
1251 .push(&request.path.workflow_id.to_string());
1252 let response = self.client.delete(url).json(&request.body).send().await?;
1253 Ok(DeleteWorkflowRequestParams::parse_response(response).await?)
1254 }
1255 pub async fn change_workflow_mailing_list(
1261 &self,
1262 request: ChangeWorkflowMailingListRequestParams,
1263 ) -> anyhow::Result<ChangeWorkflowMailingListResponseEnum> {
1264 request.validate().context("parameter validation")?;
1265 let mut url = self.base_url.clone();
1266 url.path_segments_mut()
1267 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1268 .push("v1")
1269 .push("workflows")
1270 .push(&request.path.workflow_id.to_string())
1271 .push("mailing-list");
1272 let response = self.client.post(url).json(&request.body).send().await?;
1273 Ok(ChangeWorkflowMailingListRequestParams::parse_response(response).await?)
1274 }
1275 pub async fn create_workflow_node(
1285 &self,
1286 request: CreateWorkflowNodeRequestParams,
1287 ) -> anyhow::Result<CreateWorkflowNodeResponseEnum> {
1288 request.validate().context("parameter validation")?;
1289 let mut url = self.base_url.clone();
1290 url.path_segments_mut()
1291 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1292 .push("v1")
1293 .push("workflows")
1294 .push(&request.path.workflow_id.to_string())
1295 .push("nodes");
1296 let response = self.client.post(url).json(&request.body).send().await?;
1297 Ok(CreateWorkflowNodeRequestParams::parse_response(response).await?)
1298 }
1299 pub async fn add_workflow_branch(
1310 &self,
1311 request: AddWorkflowBranchRequestParams,
1312 ) -> anyhow::Result<AddWorkflowBranchResponseEnum> {
1313 request.validate().context("parameter validation")?;
1314 let mut url = self.base_url.clone();
1315 url.path_segments_mut()
1316 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1317 .push("v1")
1318 .push("workflows")
1319 .push(&request.path.workflow_id.to_string())
1320 .push("nodes")
1321 .push(&request.path.node_id.to_string())
1322 .push("add-branch");
1323 let response = self.client.post(url).json(&request.body).send().await?;
1324 Ok(AddWorkflowBranchRequestParams::parse_response(response).await?)
1325 }
1326 pub async fn get_workflow_node(
1332 &self,
1333 request: GetWorkflowNodeRequest,
1334 ) -> anyhow::Result<GetWorkflowNodeResponse> {
1335 request.validate().context("parameter validation")?;
1336 let mut url = self.base_url.clone();
1337 url.path_segments_mut()
1338 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1339 .push("v1")
1340 .push("workflows")
1341 .push(&request.path.workflow_id.to_string())
1342 .push("nodes")
1343 .push(&request.path.node_id.to_string());
1344 let response = self.client.get(url).send().await?;
1345 Ok(GetWorkflowNodeRequest::parse_response(response).await?)
1346 }
1347 pub async fn update_workflow_node(
1353 &self,
1354 request: UpdateWorkflowNodeRequestParams,
1355 ) -> anyhow::Result<UpdateWorkflowNodeResponseEnum> {
1356 request.validate().context("parameter validation")?;
1357 let mut url = self.base_url.clone();
1358 url.path_segments_mut()
1359 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1360 .push("v1")
1361 .push("workflows")
1362 .push(&request.path.workflow_id.to_string())
1363 .push("nodes")
1364 .push(&request.path.node_id.to_string());
1365 let response = self.client.post(url).json(&request.body).send().await?;
1366 Ok(UpdateWorkflowNodeRequestParams::parse_response(response).await?)
1367 }
1368 pub async fn delete_workflow_node(
1374 &self,
1375 request: DeleteWorkflowNodeRequestParams,
1376 ) -> anyhow::Result<DeleteWorkflowNodeResponseEnum> {
1377 request.validate().context("parameter validation")?;
1378 let mut url = self.base_url.clone();
1379 url.path_segments_mut()
1380 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1381 .push("v1")
1382 .push("workflows")
1383 .push(&request.path.workflow_id.to_string())
1384 .push("nodes")
1385 .push(&request.path.node_id.to_string());
1386 let response = self.client.delete(url).json(&request.body).send().await?;
1387 Ok(DeleteWorkflowNodeRequestParams::parse_response(response).await?)
1388 }
1389 pub async fn get_workflow_node_metrics(
1395 &self,
1396 request: GetWorkflowNodeMetricsRequest,
1397 ) -> anyhow::Result<GetWorkflowNodeMetricsResponse> {
1398 request.validate().context("parameter validation")?;
1399 let mut url = self.base_url.clone();
1400 url.path_segments_mut()
1401 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1402 .push("v1")
1403 .push("workflows")
1404 .push(&request.path.workflow_id.to_string())
1405 .push("nodes")
1406 .push(&request.path.node_id.to_string())
1407 .push("metrics");
1408 let response = self.client.get(url).send().await?;
1409 Ok(GetWorkflowNodeMetricsRequest::parse_response(response).await?)
1410 }
1411 pub async fn reroute_node_connection(
1417 &self,
1418 request: RerouteNodeConnectionRequestParams,
1419 ) -> anyhow::Result<RerouteNodeConnectionResponseEnum> {
1420 request.validate().context("parameter validation")?;
1421 let mut url = self.base_url.clone();
1422 url.path_segments_mut()
1423 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1424 .push("v1")
1425 .push("workflows")
1426 .push(&request.path.workflow_id.to_string())
1427 .push("nodes")
1428 .push(&request.path.node_id.to_string())
1429 .push("reroute");
1430 let response = self.client.post(url).json(&request.body).send().await?;
1431 Ok(RerouteNodeConnectionRequestParams::parse_response(response).await?)
1432 }
1433 pub async fn delete_workflow_node_recursively(
1439 &self,
1440 request: DeleteWorkflowNodeRecursivelyRequest,
1441 ) -> anyhow::Result<DeleteWorkflowNodeResponseEnum> {
1442 request.validate().context("parameter validation")?;
1443 let mut url = self.base_url.clone();
1444 url.path_segments_mut()
1445 .map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
1446 .push("v1")
1447 .push("workflows")
1448 .push(&request.path.workflow_id.to_string())
1449 .push("nodes")
1450 .push(&request.path.node_id.to_string())
1451 .push("recursive");
1452 let response = self.client.delete(url).json(&request.body).send().await?;
1453 Ok(DeleteWorkflowNodeRecursivelyRequest::parse_response(response).await?)
1454 }
1455}