1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17#[derive(Clone, Debug)]
19pub struct CreateAliasParams {
20 pub create_alias_options: crate::models::CreateAliasOptions
22}
23
24#[derive(Clone, Debug)]
26pub struct DeleteAliasParams {
27 pub alias_id: String
29}
30
31#[derive(Clone, Debug)]
33pub struct GetAliasParams {
34 pub alias_id: String
36}
37
38#[derive(Clone, Debug)]
40pub struct GetAliasEmailsParams {
41 pub alias_id: String,
43 pub before: Option<String>,
45 pub page: Option<i32>,
47 pub since: Option<String>,
49 pub size: Option<i32>,
51 pub sort: Option<String>
53}
54
55#[derive(Clone, Debug)]
57pub struct GetAliasThreadsParams {
58 pub alias_id: String,
60 pub before: Option<String>,
62 pub page: Option<i32>,
64 pub since: Option<String>,
66 pub size: Option<i32>,
68 pub sort: Option<String>
70}
71
72#[derive(Clone, Debug)]
74pub struct GetAliasesParams {
75 pub before: Option<String>,
77 pub page: Option<i32>,
79 pub since: Option<String>,
81 pub size: Option<i32>,
83 pub sort: Option<String>
85}
86
87#[derive(Clone, Debug)]
89pub struct ReplyToAliasEmailParams {
90 pub alias_id: String,
92 pub email_id: String,
94 pub reply_to_alias_email_options: crate::models::ReplyToAliasEmailOptions
96}
97
98#[derive(Clone, Debug)]
100pub struct SendAliasEmailParams {
101 pub alias_id: String,
103 pub send_email_options: Option<crate::models::SendEmailOptions>
105}
106
107#[derive(Clone, Debug)]
109pub struct UpdateAliasParams {
110 pub alias_id: String,
112 pub update_alias_options: crate::models::UpdateAliasOptions
114}
115
116
117#[derive(Debug, Clone, Serialize, Deserialize)]
119#[serde(untagged)]
120pub enum CreateAliasError {
121 Status401(),
122 Status403(),
123 Status404(),
124 UnknownValue(serde_json::Value),
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(untagged)]
130pub enum DeleteAliasError {
131 Status401(),
132 Status403(),
133 UnknownValue(serde_json::Value),
134}
135
136#[derive(Debug, Clone, Serialize, Deserialize)]
138#[serde(untagged)]
139pub enum GetAliasError {
140 Status401(),
141 Status403(),
142 Status404(),
143 UnknownValue(serde_json::Value),
144}
145
146#[derive(Debug, Clone, Serialize, Deserialize)]
148#[serde(untagged)]
149pub enum GetAliasEmailsError {
150 Status401(),
151 Status403(),
152 Status404(),
153 UnknownValue(serde_json::Value),
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum GetAliasThreadsError {
160 Status401(),
161 Status403(),
162 Status404(),
163 UnknownValue(serde_json::Value),
164}
165
166#[derive(Debug, Clone, Serialize, Deserialize)]
168#[serde(untagged)]
169pub enum GetAliasesError {
170 Status401(),
171 Status403(),
172 Status404(),
173 UnknownValue(serde_json::Value),
174}
175
176#[derive(Debug, Clone, Serialize, Deserialize)]
178#[serde(untagged)]
179pub enum ReplyToAliasEmailError {
180 Status401(),
181 Status403(),
182 Status404(),
183 UnknownValue(serde_json::Value),
184}
185
186#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum SendAliasEmailError {
190 Status401(),
191 Status403(),
192 Status404(),
193 UnknownValue(serde_json::Value),
194}
195
196#[derive(Debug, Clone, Serialize, Deserialize)]
198#[serde(untagged)]
199pub enum UpdateAliasError {
200 Status401(),
201 Status403(),
202 Status404(),
203 UnknownValue(serde_json::Value),
204}
205
206
207pub async fn create_alias(configuration: &configuration::Configuration, params: CreateAliasParams) -> Result<crate::models::AliasDto, Error<CreateAliasError>> {
209 let create_alias_options = params.create_alias_options;
211
212
213 let local_var_client = &configuration.client;
214
215 let local_var_uri_str = format!("{}/aliases", configuration.base_path);
216 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
217
218 if let Some(ref local_var_user_agent) = configuration.user_agent {
219 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
220 }
221 if let Some(ref local_var_apikey) = configuration.api_key {
222 let local_var_key = local_var_apikey.key.clone();
223 let local_var_value = match local_var_apikey.prefix {
224 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
225 None => local_var_key,
226 };
227 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
228 };
229 local_var_req_builder = local_var_req_builder.json(&create_alias_options);
230
231 let local_var_req = local_var_req_builder.build()?;
232 let local_var_resp = local_var_client.execute(local_var_req).await?;
233
234 let local_var_status = local_var_resp.status();
235 let local_var_content = local_var_resp.text().await?;
236
237 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
238 serde_json::from_str(&local_var_content).map_err(Error::from)
239 } else {
240 let local_var_entity: Option<CreateAliasError> = serde_json::from_str(&local_var_content).ok();
241 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
242 Err(Error::ResponseError(local_var_error))
243 }
244}
245
246pub async fn delete_alias(configuration: &configuration::Configuration, params: DeleteAliasParams) -> Result<(), Error<DeleteAliasError>> {
247 let alias_id = params.alias_id;
249
250
251 let local_var_client = &configuration.client;
252
253 let local_var_uri_str = format!("{}/aliases/{aliasId}", configuration.base_path, aliasId=alias_id);
254 let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
255
256 if let Some(ref local_var_user_agent) = 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_apikey) = configuration.api_key {
260 let local_var_key = local_var_apikey.key.clone();
261 let local_var_value = match local_var_apikey.prefix {
262 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
263 None => local_var_key,
264 };
265 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
266 };
267
268 let local_var_req = local_var_req_builder.build()?;
269 let local_var_resp = local_var_client.execute(local_var_req).await?;
270
271 let local_var_status = local_var_resp.status();
272 let local_var_content = local_var_resp.text().await?;
273
274 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
275 Ok(())
276 } else {
277 let local_var_entity: Option<DeleteAliasError> = serde_json::from_str(&local_var_content).ok();
278 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
279 Err(Error::ResponseError(local_var_error))
280 }
281}
282
283pub async fn get_alias(configuration: &configuration::Configuration, params: GetAliasParams) -> Result<crate::models::AliasDto, Error<GetAliasError>> {
285 let alias_id = params.alias_id;
287
288
289 let local_var_client = &configuration.client;
290
291 let local_var_uri_str = format!("{}/aliases/{aliasId}", configuration.base_path, aliasId=alias_id);
292 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
293
294 if let Some(ref local_var_user_agent) = configuration.user_agent {
295 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
296 }
297 if let Some(ref local_var_apikey) = configuration.api_key {
298 let local_var_key = local_var_apikey.key.clone();
299 let local_var_value = match local_var_apikey.prefix {
300 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
301 None => local_var_key,
302 };
303 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
304 };
305
306 let local_var_req = local_var_req_builder.build()?;
307 let local_var_resp = local_var_client.execute(local_var_req).await?;
308
309 let local_var_status = local_var_resp.status();
310 let local_var_content = local_var_resp.text().await?;
311
312 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
313 serde_json::from_str(&local_var_content).map_err(Error::from)
314 } else {
315 let local_var_entity: Option<GetAliasError> = serde_json::from_str(&local_var_content).ok();
316 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
317 Err(Error::ResponseError(local_var_error))
318 }
319}
320
321pub async fn get_alias_emails(configuration: &configuration::Configuration, params: GetAliasEmailsParams) -> Result<crate::models::PageEmailProjection, Error<GetAliasEmailsError>> {
323 let alias_id = params.alias_id;
325 let before = params.before;
326 let page = params.page;
327 let since = params.since;
328 let size = params.size;
329 let sort = params.sort;
330
331
332 let local_var_client = &configuration.client;
333
334 let local_var_uri_str = format!("{}/aliases/{aliasId}/emails", configuration.base_path, aliasId=alias_id);
335 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
336
337 if let Some(ref local_var_str) = before {
338 local_var_req_builder = local_var_req_builder.query(&[("before", &local_var_str.to_string())]);
339 }
340 if let Some(ref local_var_str) = page {
341 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
342 }
343 if let Some(ref local_var_str) = since {
344 local_var_req_builder = local_var_req_builder.query(&[("since", &local_var_str.to_string())]);
345 }
346 if let Some(ref local_var_str) = size {
347 local_var_req_builder = local_var_req_builder.query(&[("size", &local_var_str.to_string())]);
348 }
349 if let Some(ref local_var_str) = sort {
350 local_var_req_builder = local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
351 }
352 if let Some(ref local_var_user_agent) = configuration.user_agent {
353 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
354 }
355 if let Some(ref local_var_apikey) = configuration.api_key {
356 let local_var_key = local_var_apikey.key.clone();
357 let local_var_value = match local_var_apikey.prefix {
358 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
359 None => local_var_key,
360 };
361 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
362 };
363
364 let local_var_req = local_var_req_builder.build()?;
365 let local_var_resp = local_var_client.execute(local_var_req).await?;
366
367 let local_var_status = local_var_resp.status();
368 let local_var_content = local_var_resp.text().await?;
369
370 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
371 serde_json::from_str(&local_var_content).map_err(Error::from)
372 } else {
373 let local_var_entity: Option<GetAliasEmailsError> = serde_json::from_str(&local_var_content).ok();
374 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
375 Err(Error::ResponseError(local_var_error))
376 }
377}
378
379pub async fn get_alias_threads(configuration: &configuration::Configuration, params: GetAliasThreadsParams) -> Result<crate::models::PageThreadProjection, Error<GetAliasThreadsError>> {
381 let alias_id = params.alias_id;
383 let before = params.before;
384 let page = params.page;
385 let since = params.since;
386 let size = params.size;
387 let sort = params.sort;
388
389
390 let local_var_client = &configuration.client;
391
392 let local_var_uri_str = format!("{}/aliases/{aliasId}/threads", configuration.base_path, aliasId=alias_id);
393 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
394
395 if let Some(ref local_var_str) = before {
396 local_var_req_builder = local_var_req_builder.query(&[("before", &local_var_str.to_string())]);
397 }
398 if let Some(ref local_var_str) = page {
399 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
400 }
401 if let Some(ref local_var_str) = since {
402 local_var_req_builder = local_var_req_builder.query(&[("since", &local_var_str.to_string())]);
403 }
404 if let Some(ref local_var_str) = size {
405 local_var_req_builder = local_var_req_builder.query(&[("size", &local_var_str.to_string())]);
406 }
407 if let Some(ref local_var_str) = sort {
408 local_var_req_builder = local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
409 }
410 if let Some(ref local_var_user_agent) = configuration.user_agent {
411 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
412 }
413 if let Some(ref local_var_apikey) = configuration.api_key {
414 let local_var_key = local_var_apikey.key.clone();
415 let local_var_value = match local_var_apikey.prefix {
416 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
417 None => local_var_key,
418 };
419 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
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 serde_json::from_str(&local_var_content).map_err(Error::from)
430 } else {
431 let local_var_entity: Option<GetAliasThreadsError> = 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_aliases(configuration: &configuration::Configuration, params: GetAliasesParams) -> Result<crate::models::PageAlias, Error<GetAliasesError>> {
439 let before = params.before;
441 let page = params.page;
442 let since = params.since;
443 let size = params.size;
444 let sort = params.sort;
445
446
447 let local_var_client = &configuration.client;
448
449 let local_var_uri_str = format!("{}/aliases", configuration.base_path);
450 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
451
452 if let Some(ref local_var_str) = before {
453 local_var_req_builder = local_var_req_builder.query(&[("before", &local_var_str.to_string())]);
454 }
455 if let Some(ref local_var_str) = page {
456 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
457 }
458 if let Some(ref local_var_str) = since {
459 local_var_req_builder = local_var_req_builder.query(&[("since", &local_var_str.to_string())]);
460 }
461 if let Some(ref local_var_str) = size {
462 local_var_req_builder = local_var_req_builder.query(&[("size", &local_var_str.to_string())]);
463 }
464 if let Some(ref local_var_str) = sort {
465 local_var_req_builder = local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
466 }
467 if let Some(ref local_var_user_agent) = configuration.user_agent {
468 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
469 }
470 if let Some(ref local_var_apikey) = configuration.api_key {
471 let local_var_key = local_var_apikey.key.clone();
472 let local_var_value = match local_var_apikey.prefix {
473 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
474 None => local_var_key,
475 };
476 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
477 };
478
479 let local_var_req = local_var_req_builder.build()?;
480 let local_var_resp = local_var_client.execute(local_var_req).await?;
481
482 let local_var_status = local_var_resp.status();
483 let local_var_content = local_var_resp.text().await?;
484
485 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
486 serde_json::from_str(&local_var_content).map_err(Error::from)
487 } else {
488 let local_var_entity: Option<GetAliasesError> = serde_json::from_str(&local_var_content).ok();
489 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
490 Err(Error::ResponseError(local_var_error))
491 }
492}
493
494pub async fn reply_to_alias_email(configuration: &configuration::Configuration, params: ReplyToAliasEmailParams) -> Result<crate::models::SentEmailDto, Error<ReplyToAliasEmailError>> {
496 let alias_id = params.alias_id;
498 let email_id = params.email_id;
499 let reply_to_alias_email_options = params.reply_to_alias_email_options;
500
501
502 let local_var_client = &configuration.client;
503
504 let local_var_uri_str = format!("{}/aliases/{aliasId}/emails/{emailId}", configuration.base_path, aliasId=alias_id, emailId=email_id);
505 let mut local_var_req_builder = local_var_client.put(local_var_uri_str.as_str());
506
507 if let Some(ref local_var_user_agent) = configuration.user_agent {
508 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
509 }
510 if let Some(ref local_var_apikey) = configuration.api_key {
511 let local_var_key = local_var_apikey.key.clone();
512 let local_var_value = match local_var_apikey.prefix {
513 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
514 None => local_var_key,
515 };
516 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
517 };
518 local_var_req_builder = local_var_req_builder.json(&reply_to_alias_email_options);
519
520 let local_var_req = local_var_req_builder.build()?;
521 let local_var_resp = local_var_client.execute(local_var_req).await?;
522
523 let local_var_status = local_var_resp.status();
524 let local_var_content = local_var_resp.text().await?;
525
526 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
527 serde_json::from_str(&local_var_content).map_err(Error::from)
528 } else {
529 let local_var_entity: Option<ReplyToAliasEmailError> = serde_json::from_str(&local_var_content).ok();
530 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
531 Err(Error::ResponseError(local_var_error))
532 }
533}
534
535pub async fn send_alias_email(configuration: &configuration::Configuration, params: SendAliasEmailParams) -> Result<crate::models::SentEmailDto, Error<SendAliasEmailError>> {
537 let alias_id = params.alias_id;
539 let send_email_options = params.send_email_options;
540
541
542 let local_var_client = &configuration.client;
543
544 let local_var_uri_str = format!("{}/aliases/{aliasId}/emails", configuration.base_path, aliasId=alias_id);
545 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
546
547 if let Some(ref local_var_user_agent) = configuration.user_agent {
548 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
549 }
550 if let Some(ref local_var_apikey) = configuration.api_key {
551 let local_var_key = local_var_apikey.key.clone();
552 let local_var_value = match local_var_apikey.prefix {
553 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
554 None => local_var_key,
555 };
556 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
557 };
558 local_var_req_builder = local_var_req_builder.json(&send_email_options);
559
560 let local_var_req = local_var_req_builder.build()?;
561 let local_var_resp = local_var_client.execute(local_var_req).await?;
562
563 let local_var_status = local_var_resp.status();
564 let local_var_content = local_var_resp.text().await?;
565
566 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
567 serde_json::from_str(&local_var_content).map_err(Error::from)
568 } else {
569 let local_var_entity: Option<SendAliasEmailError> = serde_json::from_str(&local_var_content).ok();
570 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
571 Err(Error::ResponseError(local_var_error))
572 }
573}
574
575pub async fn update_alias(configuration: &configuration::Configuration, params: UpdateAliasParams) -> Result<(), Error<UpdateAliasError>> {
576 let alias_id = params.alias_id;
578 let update_alias_options = params.update_alias_options;
579
580
581 let local_var_client = &configuration.client;
582
583 let local_var_uri_str = format!("{}/aliases/{aliasId}", configuration.base_path, aliasId=alias_id);
584 let mut local_var_req_builder = local_var_client.put(local_var_uri_str.as_str());
585
586 if let Some(ref local_var_user_agent) = configuration.user_agent {
587 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
588 }
589 if let Some(ref local_var_apikey) = configuration.api_key {
590 let local_var_key = local_var_apikey.key.clone();
591 let local_var_value = match local_var_apikey.prefix {
592 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
593 None => local_var_key,
594 };
595 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
596 };
597 local_var_req_builder = local_var_req_builder.json(&update_alias_options);
598
599 let local_var_req = local_var_req_builder.build()?;
600 let local_var_resp = local_var_client.execute(local_var_req).await?;
601
602 let local_var_status = local_var_resp.status();
603 let local_var_content = local_var_resp.text().await?;
604
605 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
606 Ok(())
607 } else {
608 let local_var_entity: Option<UpdateAliasError> = serde_json::from_str(&local_var_content).ok();
609 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
610 Err(Error::ResponseError(local_var_error))
611 }
612}
613