1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17#[derive(Clone, Debug)]
19pub struct CreateNewInboxForwarderParams {
20 pub create_inbox_forwarder_options: crate::models::CreateInboxForwarderOptions,
22 pub inbox_id: Option<String>
24}
25
26#[derive(Clone, Debug)]
28pub struct DeleteInboxForwarderParams {
29 pub id: String
31}
32
33#[derive(Clone, Debug)]
35pub struct DeleteInboxForwardersParams {
36 pub inbox_id: Option<String>
38}
39
40#[derive(Clone, Debug)]
42pub struct GetInboxForwarderParams {
43 pub id: String
45}
46
47#[derive(Clone, Debug)]
49pub struct GetInboxForwardersParams {
50 pub before: Option<String>,
52 pub inbox_id: Option<String>,
54 pub page: Option<i32>,
56 pub search_filter: Option<String>,
58 pub since: Option<String>,
60 pub size: Option<i32>,
62 pub sort: Option<String>
64}
65
66#[derive(Clone, Debug)]
68pub struct TestInboxForwarderParams {
69 pub id: String,
71 pub inbox_forwarder_test_options: crate::models::InboxForwarderTestOptions
73}
74
75#[derive(Clone, Debug)]
77pub struct TestInboxForwardersForInboxParams {
78 pub inbox_id: String,
80 pub inbox_forwarder_test_options: crate::models::InboxForwarderTestOptions
82}
83
84#[derive(Clone, Debug)]
86pub struct TestNewInboxForwarderParams {
87 pub test_new_inbox_forwarder_options: crate::models::TestNewInboxForwarderOptions
89}
90
91
92#[derive(Debug, Clone, Serialize, Deserialize)]
94#[serde(untagged)]
95pub enum CreateNewInboxForwarderError {
96 Status401(),
97 Status403(),
98 Status404(),
99 UnknownValue(serde_json::Value),
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum DeleteInboxForwarderError {
106 Status401(),
107 Status403(),
108 UnknownValue(serde_json::Value),
109}
110
111#[derive(Debug, Clone, Serialize, Deserialize)]
113#[serde(untagged)]
114pub enum DeleteInboxForwardersError {
115 Status401(),
116 Status403(),
117 UnknownValue(serde_json::Value),
118}
119
120#[derive(Debug, Clone, Serialize, Deserialize)]
122#[serde(untagged)]
123pub enum GetInboxForwarderError {
124 Status401(),
125 Status403(),
126 Status404(),
127 UnknownValue(serde_json::Value),
128}
129
130#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum GetInboxForwardersError {
134 Status401(),
135 Status403(),
136 Status404(),
137 UnknownValue(serde_json::Value),
138}
139
140#[derive(Debug, Clone, Serialize, Deserialize)]
142#[serde(untagged)]
143pub enum TestInboxForwarderError {
144 Status401(),
145 Status403(),
146 Status404(),
147 UnknownValue(serde_json::Value),
148}
149
150#[derive(Debug, Clone, Serialize, Deserialize)]
152#[serde(untagged)]
153pub enum TestInboxForwardersForInboxError {
154 Status401(),
155 Status403(),
156 Status404(),
157 UnknownValue(serde_json::Value),
158}
159
160#[derive(Debug, Clone, Serialize, Deserialize)]
162#[serde(untagged)]
163pub enum TestNewInboxForwarderError {
164 Status401(),
165 Status403(),
166 UnknownValue(serde_json::Value),
167}
168
169
170pub async fn create_new_inbox_forwarder(configuration: &configuration::Configuration, params: CreateNewInboxForwarderParams) -> Result<crate::models::InboxForwarderDto, Error<CreateNewInboxForwarderError>> {
172 let create_inbox_forwarder_options = params.create_inbox_forwarder_options;
174 let inbox_id = params.inbox_id;
175
176
177 let local_var_client = &configuration.client;
178
179 let local_var_uri_str = format!("{}/forwarders", configuration.base_path);
180 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
181
182 if let Some(ref local_var_str) = inbox_id {
183 local_var_req_builder = local_var_req_builder.query(&[("inboxId", &local_var_str.to_string())]);
184 }
185 if let Some(ref local_var_user_agent) = configuration.user_agent {
186 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
187 }
188 if let Some(ref local_var_apikey) = configuration.api_key {
189 let local_var_key = local_var_apikey.key.clone();
190 let local_var_value = match local_var_apikey.prefix {
191 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
192 None => local_var_key,
193 };
194 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
195 };
196 local_var_req_builder = local_var_req_builder.json(&create_inbox_forwarder_options);
197
198 let local_var_req = local_var_req_builder.build()?;
199 let local_var_resp = local_var_client.execute(local_var_req).await?;
200
201 let local_var_status = local_var_resp.status();
202 let local_var_content = local_var_resp.text().await?;
203
204 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
205 serde_json::from_str(&local_var_content).map_err(Error::from)
206 } else {
207 let local_var_entity: Option<CreateNewInboxForwarderError> = serde_json::from_str(&local_var_content).ok();
208 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
209 Err(Error::ResponseError(local_var_error))
210 }
211}
212
213pub async fn delete_inbox_forwarder(configuration: &configuration::Configuration, params: DeleteInboxForwarderParams) -> Result<(), Error<DeleteInboxForwarderError>> {
215 let id = params.id;
217
218
219 let local_var_client = &configuration.client;
220
221 let local_var_uri_str = format!("{}/forwarders/{id}", configuration.base_path, id=id);
222 let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
223
224 if let Some(ref local_var_user_agent) = configuration.user_agent {
225 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
226 }
227 if let Some(ref local_var_apikey) = configuration.api_key {
228 let local_var_key = local_var_apikey.key.clone();
229 let local_var_value = match local_var_apikey.prefix {
230 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
231 None => local_var_key,
232 };
233 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
234 };
235
236 let local_var_req = local_var_req_builder.build()?;
237 let local_var_resp = local_var_client.execute(local_var_req).await?;
238
239 let local_var_status = local_var_resp.status();
240 let local_var_content = local_var_resp.text().await?;
241
242 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
243 Ok(())
244 } else {
245 let local_var_entity: Option<DeleteInboxForwarderError> = serde_json::from_str(&local_var_content).ok();
246 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
247 Err(Error::ResponseError(local_var_error))
248 }
249}
250
251pub async fn delete_inbox_forwarders(configuration: &configuration::Configuration, params: DeleteInboxForwardersParams) -> Result<(), Error<DeleteInboxForwardersError>> {
253 let inbox_id = params.inbox_id;
255
256
257 let local_var_client = &configuration.client;
258
259 let local_var_uri_str = format!("{}/forwarders", configuration.base_path);
260 let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
261
262 if let Some(ref local_var_str) = inbox_id {
263 local_var_req_builder = local_var_req_builder.query(&[("inboxId", &local_var_str.to_string())]);
264 }
265 if let Some(ref local_var_user_agent) = configuration.user_agent {
266 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
267 }
268 if let Some(ref local_var_apikey) = configuration.api_key {
269 let local_var_key = local_var_apikey.key.clone();
270 let local_var_value = match local_var_apikey.prefix {
271 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
272 None => local_var_key,
273 };
274 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
275 };
276
277 let local_var_req = local_var_req_builder.build()?;
278 let local_var_resp = local_var_client.execute(local_var_req).await?;
279
280 let local_var_status = local_var_resp.status();
281 let local_var_content = local_var_resp.text().await?;
282
283 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
284 Ok(())
285 } else {
286 let local_var_entity: Option<DeleteInboxForwardersError> = serde_json::from_str(&local_var_content).ok();
287 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
288 Err(Error::ResponseError(local_var_error))
289 }
290}
291
292pub async fn get_inbox_forwarder(configuration: &configuration::Configuration, params: GetInboxForwarderParams) -> Result<crate::models::InboxForwarderDto, Error<GetInboxForwarderError>> {
294 let id = params.id;
296
297
298 let local_var_client = &configuration.client;
299
300 let local_var_uri_str = format!("{}/forwarders/{id}", configuration.base_path, id=id);
301 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
302
303 if let Some(ref local_var_user_agent) = configuration.user_agent {
304 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
305 }
306 if let Some(ref local_var_apikey) = configuration.api_key {
307 let local_var_key = local_var_apikey.key.clone();
308 let local_var_value = match local_var_apikey.prefix {
309 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
310 None => local_var_key,
311 };
312 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
313 };
314
315 let local_var_req = local_var_req_builder.build()?;
316 let local_var_resp = local_var_client.execute(local_var_req).await?;
317
318 let local_var_status = local_var_resp.status();
319 let local_var_content = local_var_resp.text().await?;
320
321 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
322 serde_json::from_str(&local_var_content).map_err(Error::from)
323 } else {
324 let local_var_entity: Option<GetInboxForwarderError> = serde_json::from_str(&local_var_content).ok();
325 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
326 Err(Error::ResponseError(local_var_error))
327 }
328}
329
330pub async fn get_inbox_forwarders(configuration: &configuration::Configuration, params: GetInboxForwardersParams) -> Result<crate::models::PageInboxForwarderDto, Error<GetInboxForwardersError>> {
332 let before = params.before;
334 let inbox_id = params.inbox_id;
335 let page = params.page;
336 let search_filter = params.search_filter;
337 let since = params.since;
338 let size = params.size;
339 let sort = params.sort;
340
341
342 let local_var_client = &configuration.client;
343
344 let local_var_uri_str = format!("{}/forwarders", configuration.base_path);
345 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
346
347 if let Some(ref local_var_str) = before {
348 local_var_req_builder = local_var_req_builder.query(&[("before", &local_var_str.to_string())]);
349 }
350 if let Some(ref local_var_str) = inbox_id {
351 local_var_req_builder = local_var_req_builder.query(&[("inboxId", &local_var_str.to_string())]);
352 }
353 if let Some(ref local_var_str) = page {
354 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
355 }
356 if let Some(ref local_var_str) = search_filter {
357 local_var_req_builder = local_var_req_builder.query(&[("searchFilter", &local_var_str.to_string())]);
358 }
359 if let Some(ref local_var_str) = since {
360 local_var_req_builder = local_var_req_builder.query(&[("since", &local_var_str.to_string())]);
361 }
362 if let Some(ref local_var_str) = size {
363 local_var_req_builder = local_var_req_builder.query(&[("size", &local_var_str.to_string())]);
364 }
365 if let Some(ref local_var_str) = sort {
366 local_var_req_builder = local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
367 }
368 if let Some(ref local_var_user_agent) = configuration.user_agent {
369 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
370 }
371 if let Some(ref local_var_apikey) = configuration.api_key {
372 let local_var_key = local_var_apikey.key.clone();
373 let local_var_value = match local_var_apikey.prefix {
374 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
375 None => local_var_key,
376 };
377 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
378 };
379
380 let local_var_req = local_var_req_builder.build()?;
381 let local_var_resp = local_var_client.execute(local_var_req).await?;
382
383 let local_var_status = local_var_resp.status();
384 let local_var_content = local_var_resp.text().await?;
385
386 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
387 serde_json::from_str(&local_var_content).map_err(Error::from)
388 } else {
389 let local_var_entity: Option<GetInboxForwardersError> = serde_json::from_str(&local_var_content).ok();
390 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
391 Err(Error::ResponseError(local_var_error))
392 }
393}
394
395pub async fn test_inbox_forwarder(configuration: &configuration::Configuration, params: TestInboxForwarderParams) -> Result<crate::models::InboxForwarderTestResult, Error<TestInboxForwarderError>> {
397 let id = params.id;
399 let inbox_forwarder_test_options = params.inbox_forwarder_test_options;
400
401
402 let local_var_client = &configuration.client;
403
404 let local_var_uri_str = format!("{}/forwarders/{id}/test", configuration.base_path, id=id);
405 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
406
407 if let Some(ref local_var_user_agent) = configuration.user_agent {
408 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
409 }
410 if let Some(ref local_var_apikey) = configuration.api_key {
411 let local_var_key = local_var_apikey.key.clone();
412 let local_var_value = match local_var_apikey.prefix {
413 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
414 None => local_var_key,
415 };
416 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
417 };
418 local_var_req_builder = local_var_req_builder.json(&inbox_forwarder_test_options);
419
420 let local_var_req = local_var_req_builder.build()?;
421 let local_var_resp = local_var_client.execute(local_var_req).await?;
422
423 let local_var_status = local_var_resp.status();
424 let local_var_content = local_var_resp.text().await?;
425
426 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
427 serde_json::from_str(&local_var_content).map_err(Error::from)
428 } else {
429 let local_var_entity: Option<TestInboxForwarderError> = serde_json::from_str(&local_var_content).ok();
430 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
431 Err(Error::ResponseError(local_var_error))
432 }
433}
434
435pub async fn test_inbox_forwarders_for_inbox(configuration: &configuration::Configuration, params: TestInboxForwardersForInboxParams) -> Result<crate::models::InboxForwarderTestResult, Error<TestInboxForwardersForInboxError>> {
437 let inbox_id = params.inbox_id;
439 let inbox_forwarder_test_options = params.inbox_forwarder_test_options;
440
441
442 let local_var_client = &configuration.client;
443
444 let local_var_uri_str = format!("{}/forwarders", configuration.base_path);
445 let mut local_var_req_builder = local_var_client.put(local_var_uri_str.as_str());
446
447 local_var_req_builder = local_var_req_builder.query(&[("inboxId", &inbox_id.to_string())]);
448 if let Some(ref local_var_user_agent) = configuration.user_agent {
449 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
450 }
451 if let Some(ref local_var_apikey) = configuration.api_key {
452 let local_var_key = local_var_apikey.key.clone();
453 let local_var_value = match local_var_apikey.prefix {
454 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
455 None => local_var_key,
456 };
457 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
458 };
459 local_var_req_builder = local_var_req_builder.json(&inbox_forwarder_test_options);
460
461 let local_var_req = local_var_req_builder.build()?;
462 let local_var_resp = local_var_client.execute(local_var_req).await?;
463
464 let local_var_status = local_var_resp.status();
465 let local_var_content = local_var_resp.text().await?;
466
467 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
468 serde_json::from_str(&local_var_content).map_err(Error::from)
469 } else {
470 let local_var_entity: Option<TestInboxForwardersForInboxError> = serde_json::from_str(&local_var_content).ok();
471 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
472 Err(Error::ResponseError(local_var_error))
473 }
474}
475
476pub async fn test_new_inbox_forwarder(configuration: &configuration::Configuration, params: TestNewInboxForwarderParams) -> Result<crate::models::InboxForwarderTestResult, Error<TestNewInboxForwarderError>> {
478 let test_new_inbox_forwarder_options = params.test_new_inbox_forwarder_options;
480
481
482 let local_var_client = &configuration.client;
483
484 let local_var_uri_str = format!("{}/forwarders", configuration.base_path);
485 let mut local_var_req_builder = local_var_client.patch(local_var_uri_str.as_str());
486
487 if let Some(ref local_var_user_agent) = configuration.user_agent {
488 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
489 }
490 if let Some(ref local_var_apikey) = configuration.api_key {
491 let local_var_key = local_var_apikey.key.clone();
492 let local_var_value = match local_var_apikey.prefix {
493 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
494 None => local_var_key,
495 };
496 local_var_req_builder = local_var_req_builder.header("x-api-key", local_var_value);
497 };
498 local_var_req_builder = local_var_req_builder.json(&test_new_inbox_forwarder_options);
499
500 let local_var_req = local_var_req_builder.build()?;
501 let local_var_resp = local_var_client.execute(local_var_req).await?;
502
503 let local_var_status = local_var_resp.status();
504 let local_var_content = local_var_resp.text().await?;
505
506 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
507 serde_json::from_str(&local_var_content).map_err(Error::from)
508 } else {
509 let local_var_entity: Option<TestNewInboxForwarderError> = serde_json::from_str(&local_var_content).ok();
510 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
511 Err(Error::ResponseError(local_var_error))
512 }
513}
514