1use reqwest;
12use serde::{Deserialize, Serialize};
13
14use super::{configuration, Error};
15use crate::{apis::ResponseContent, models};
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum OrganizationSponsorshipRedeemPostError {
21 UnknownValue(serde_json::Value),
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum OrganizationSponsorshipSponsoredSponsoredOrgIdDeleteError {
28 UnknownValue(serde_json::Value),
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum OrganizationSponsorshipSponsoredSponsoredOrgIdRemovePostError {
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
42#[serde(untagged)]
43pub enum OrganizationSponsorshipSponsoringOrgIdFamiliesForEnterprisePostError {
44 UnknownValue(serde_json::Value),
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
50#[serde(untagged)]
51pub enum OrganizationSponsorshipSponsoringOrgIdFamiliesForEnterpriseResendPostError {
52 UnknownValue(serde_json::Value),
53}
54
55#[derive(Debug, Clone, Serialize, Deserialize)]
57#[serde(untagged)]
58pub enum OrganizationSponsorshipSponsoringOrgIdSyncStatusGetError {
59 UnknownValue(serde_json::Value),
60}
61
62#[derive(Debug, Clone, Serialize, Deserialize)]
64#[serde(untagged)]
65pub enum OrganizationSponsorshipSponsoringOrganizationIdDeleteError {
66 UnknownValue(serde_json::Value),
67}
68
69#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum OrganizationSponsorshipSponsoringOrganizationIdDeletePostError {
74 UnknownValue(serde_json::Value),
75}
76
77#[derive(Debug, Clone, Serialize, Deserialize)]
79#[serde(untagged)]
80pub enum OrganizationSponsorshipSyncPostError {
81 UnknownValue(serde_json::Value),
82}
83
84#[derive(Debug, Clone, Serialize, Deserialize)]
86#[serde(untagged)]
87pub enum OrganizationSponsorshipValidateTokenPostError {
88 UnknownValue(serde_json::Value),
89}
90
91pub async fn organization_sponsorship_redeem_post(
92 configuration: &configuration::Configuration,
93 sponsorship_token: Option<&str>,
94 organization_sponsorship_redeem_request_model: Option<
95 models::OrganizationSponsorshipRedeemRequestModel,
96 >,
97) -> Result<(), Error<OrganizationSponsorshipRedeemPostError>> {
98 let local_var_configuration = configuration;
99
100 let local_var_client = &local_var_configuration.client;
101
102 let local_var_uri_str = format!(
103 "{}/organization/sponsorship/redeem",
104 local_var_configuration.base_path
105 );
106 let mut local_var_req_builder =
107 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
108
109 if let Some(ref local_var_str) = sponsorship_token {
110 local_var_req_builder =
111 local_var_req_builder.query(&[("sponsorshipToken", &local_var_str.to_string())]);
112 }
113 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
114 local_var_req_builder =
115 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
116 }
117 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
118 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
119 };
120 local_var_req_builder =
121 local_var_req_builder.json(&organization_sponsorship_redeem_request_model);
122
123 let local_var_req = local_var_req_builder.build()?;
124 let local_var_resp = local_var_client.execute(local_var_req).await?;
125
126 let local_var_status = local_var_resp.status();
127 let local_var_content = local_var_resp.text().await?;
128
129 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
130 Ok(())
131 } else {
132 let local_var_entity: Option<OrganizationSponsorshipRedeemPostError> =
133 serde_json::from_str(&local_var_content).ok();
134 let local_var_error = ResponseContent {
135 status: local_var_status,
136 content: local_var_content,
137 entity: local_var_entity,
138 };
139 Err(Error::ResponseError(local_var_error))
140 }
141}
142
143pub async fn organization_sponsorship_sponsored_sponsored_org_id_delete(
144 configuration: &configuration::Configuration,
145 sponsored_org_id: uuid::Uuid,
146) -> Result<(), Error<OrganizationSponsorshipSponsoredSponsoredOrgIdDeleteError>> {
147 let local_var_configuration = configuration;
148
149 let local_var_client = &local_var_configuration.client;
150
151 let local_var_uri_str = format!(
152 "{}/organization/sponsorship/sponsored/{sponsoredOrgId}",
153 local_var_configuration.base_path,
154 sponsoredOrgId = crate::apis::urlencode(sponsored_org_id.to_string())
155 );
156 let mut local_var_req_builder =
157 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
158
159 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
160 local_var_req_builder =
161 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
162 }
163 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
164 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
165 };
166
167 let local_var_req = local_var_req_builder.build()?;
168 let local_var_resp = local_var_client.execute(local_var_req).await?;
169
170 let local_var_status = local_var_resp.status();
171 let local_var_content = local_var_resp.text().await?;
172
173 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
174 Ok(())
175 } else {
176 let local_var_entity: Option<OrganizationSponsorshipSponsoredSponsoredOrgIdDeleteError> =
177 serde_json::from_str(&local_var_content).ok();
178 let local_var_error = ResponseContent {
179 status: local_var_status,
180 content: local_var_content,
181 entity: local_var_entity,
182 };
183 Err(Error::ResponseError(local_var_error))
184 }
185}
186
187pub async fn organization_sponsorship_sponsored_sponsored_org_id_remove_post(
188 configuration: &configuration::Configuration,
189 sponsored_org_id: uuid::Uuid,
190) -> Result<(), Error<OrganizationSponsorshipSponsoredSponsoredOrgIdRemovePostError>> {
191 let local_var_configuration = configuration;
192
193 let local_var_client = &local_var_configuration.client;
194
195 let local_var_uri_str = format!(
196 "{}/organization/sponsorship/sponsored/{sponsoredOrgId}/remove",
197 local_var_configuration.base_path,
198 sponsoredOrgId = crate::apis::urlencode(sponsored_org_id.to_string())
199 );
200 let mut local_var_req_builder =
201 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
202
203 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
204 local_var_req_builder =
205 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
206 }
207 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
208 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
209 };
210
211 let local_var_req = local_var_req_builder.build()?;
212 let local_var_resp = local_var_client.execute(local_var_req).await?;
213
214 let local_var_status = local_var_resp.status();
215 let local_var_content = local_var_resp.text().await?;
216
217 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
218 Ok(())
219 } else {
220 let local_var_entity: Option<
221 OrganizationSponsorshipSponsoredSponsoredOrgIdRemovePostError,
222 > = serde_json::from_str(&local_var_content).ok();
223 let local_var_error = ResponseContent {
224 status: local_var_status,
225 content: local_var_content,
226 entity: local_var_entity,
227 };
228 Err(Error::ResponseError(local_var_error))
229 }
230}
231
232pub async fn organization_sponsorship_sponsoring_org_id_families_for_enterprise_post(
233 configuration: &configuration::Configuration,
234 sponsoring_org_id: uuid::Uuid,
235 organization_sponsorship_create_request_model: Option<
236 models::OrganizationSponsorshipCreateRequestModel,
237 >,
238) -> Result<(), Error<OrganizationSponsorshipSponsoringOrgIdFamiliesForEnterprisePostError>> {
239 let local_var_configuration = configuration;
240
241 let local_var_client = &local_var_configuration.client;
242
243 let local_var_uri_str = format!(
244 "{}/organization/sponsorship/{sponsoringOrgId}/families-for-enterprise",
245 local_var_configuration.base_path,
246 sponsoringOrgId = crate::apis::urlencode(sponsoring_org_id.to_string())
247 );
248 let mut local_var_req_builder =
249 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
250
251 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
252 local_var_req_builder =
253 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
254 }
255 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
256 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
257 };
258 local_var_req_builder =
259 local_var_req_builder.json(&organization_sponsorship_create_request_model);
260
261 let local_var_req = local_var_req_builder.build()?;
262 let local_var_resp = local_var_client.execute(local_var_req).await?;
263
264 let local_var_status = local_var_resp.status();
265 let local_var_content = local_var_resp.text().await?;
266
267 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
268 Ok(())
269 } else {
270 let local_var_entity: Option<
271 OrganizationSponsorshipSponsoringOrgIdFamiliesForEnterprisePostError,
272 > = serde_json::from_str(&local_var_content).ok();
273 let local_var_error = ResponseContent {
274 status: local_var_status,
275 content: local_var_content,
276 entity: local_var_entity,
277 };
278 Err(Error::ResponseError(local_var_error))
279 }
280}
281
282pub async fn organization_sponsorship_sponsoring_org_id_families_for_enterprise_resend_post(
283 configuration: &configuration::Configuration,
284 sponsoring_org_id: uuid::Uuid,
285) -> Result<(), Error<OrganizationSponsorshipSponsoringOrgIdFamiliesForEnterpriseResendPostError>> {
286 let local_var_configuration = configuration;
287
288 let local_var_client = &local_var_configuration.client;
289
290 let local_var_uri_str = format!(
291 "{}/organization/sponsorship/{sponsoringOrgId}/families-for-enterprise/resend",
292 local_var_configuration.base_path,
293 sponsoringOrgId = crate::apis::urlencode(sponsoring_org_id.to_string())
294 );
295 let mut local_var_req_builder =
296 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
297
298 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
299 local_var_req_builder =
300 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
301 }
302 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
303 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
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 Ok(())
314 } else {
315 let local_var_entity: Option<
316 OrganizationSponsorshipSponsoringOrgIdFamiliesForEnterpriseResendPostError,
317 > = serde_json::from_str(&local_var_content).ok();
318 let local_var_error = ResponseContent {
319 status: local_var_status,
320 content: local_var_content,
321 entity: local_var_entity,
322 };
323 Err(Error::ResponseError(local_var_error))
324 }
325}
326
327pub async fn organization_sponsorship_sponsoring_org_id_sync_status_get(
328 configuration: &configuration::Configuration,
329 sponsoring_org_id: uuid::Uuid,
330) -> Result<(), Error<OrganizationSponsorshipSponsoringOrgIdSyncStatusGetError>> {
331 let local_var_configuration = configuration;
332
333 let local_var_client = &local_var_configuration.client;
334
335 let local_var_uri_str = format!(
336 "{}/organization/sponsorship/{sponsoringOrgId}/sync-status",
337 local_var_configuration.base_path,
338 sponsoringOrgId = crate::apis::urlencode(sponsoring_org_id.to_string())
339 );
340 let mut local_var_req_builder =
341 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
342
343 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
344 local_var_req_builder =
345 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
346 }
347 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
348 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
349 };
350
351 let local_var_req = local_var_req_builder.build()?;
352 let local_var_resp = local_var_client.execute(local_var_req).await?;
353
354 let local_var_status = local_var_resp.status();
355 let local_var_content = local_var_resp.text().await?;
356
357 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
358 Ok(())
359 } else {
360 let local_var_entity: Option<OrganizationSponsorshipSponsoringOrgIdSyncStatusGetError> =
361 serde_json::from_str(&local_var_content).ok();
362 let local_var_error = ResponseContent {
363 status: local_var_status,
364 content: local_var_content,
365 entity: local_var_entity,
366 };
367 Err(Error::ResponseError(local_var_error))
368 }
369}
370
371pub async fn organization_sponsorship_sponsoring_organization_id_delete(
372 configuration: &configuration::Configuration,
373 sponsoring_organization_id: uuid::Uuid,
374) -> Result<(), Error<OrganizationSponsorshipSponsoringOrganizationIdDeleteError>> {
375 let local_var_configuration = configuration;
376
377 let local_var_client = &local_var_configuration.client;
378
379 let local_var_uri_str = format!(
380 "{}/organization/sponsorship/{sponsoringOrganizationId}",
381 local_var_configuration.base_path,
382 sponsoringOrganizationId = crate::apis::urlencode(sponsoring_organization_id.to_string())
383 );
384 let mut local_var_req_builder =
385 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
386
387 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
388 local_var_req_builder =
389 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
390 }
391 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
392 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
393 };
394
395 let local_var_req = local_var_req_builder.build()?;
396 let local_var_resp = local_var_client.execute(local_var_req).await?;
397
398 let local_var_status = local_var_resp.status();
399 let local_var_content = local_var_resp.text().await?;
400
401 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
402 Ok(())
403 } else {
404 let local_var_entity: Option<OrganizationSponsorshipSponsoringOrganizationIdDeleteError> =
405 serde_json::from_str(&local_var_content).ok();
406 let local_var_error = ResponseContent {
407 status: local_var_status,
408 content: local_var_content,
409 entity: local_var_entity,
410 };
411 Err(Error::ResponseError(local_var_error))
412 }
413}
414
415pub async fn organization_sponsorship_sponsoring_organization_id_delete_post(
416 configuration: &configuration::Configuration,
417 sponsoring_organization_id: uuid::Uuid,
418) -> Result<(), Error<OrganizationSponsorshipSponsoringOrganizationIdDeletePostError>> {
419 let local_var_configuration = configuration;
420
421 let local_var_client = &local_var_configuration.client;
422
423 let local_var_uri_str = format!(
424 "{}/organization/sponsorship/{sponsoringOrganizationId}/delete",
425 local_var_configuration.base_path,
426 sponsoringOrganizationId = crate::apis::urlencode(sponsoring_organization_id.to_string())
427 );
428 let mut local_var_req_builder =
429 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
430
431 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
432 local_var_req_builder =
433 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
434 }
435 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
436 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
437 };
438
439 let local_var_req = local_var_req_builder.build()?;
440 let local_var_resp = local_var_client.execute(local_var_req).await?;
441
442 let local_var_status = local_var_resp.status();
443 let local_var_content = local_var_resp.text().await?;
444
445 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
446 Ok(())
447 } else {
448 let local_var_entity: Option<
449 OrganizationSponsorshipSponsoringOrganizationIdDeletePostError,
450 > = serde_json::from_str(&local_var_content).ok();
451 let local_var_error = ResponseContent {
452 status: local_var_status,
453 content: local_var_content,
454 entity: local_var_entity,
455 };
456 Err(Error::ResponseError(local_var_error))
457 }
458}
459
460pub async fn organization_sponsorship_sync_post(
461 configuration: &configuration::Configuration,
462 organization_sponsorship_sync_request_model: Option<
463 models::OrganizationSponsorshipSyncRequestModel,
464 >,
465) -> Result<
466 models::OrganizationSponsorshipSyncResponseModel,
467 Error<OrganizationSponsorshipSyncPostError>,
468> {
469 let local_var_configuration = configuration;
470
471 let local_var_client = &local_var_configuration.client;
472
473 let local_var_uri_str = format!(
474 "{}/organization/sponsorship/sync",
475 local_var_configuration.base_path
476 );
477 let mut local_var_req_builder =
478 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
479
480 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
481 local_var_req_builder =
482 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
483 }
484 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
485 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
486 };
487 local_var_req_builder =
488 local_var_req_builder.json(&organization_sponsorship_sync_request_model);
489
490 let local_var_req = local_var_req_builder.build()?;
491 let local_var_resp = local_var_client.execute(local_var_req).await?;
492
493 let local_var_status = local_var_resp.status();
494 let local_var_content = local_var_resp.text().await?;
495
496 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
497 serde_json::from_str(&local_var_content).map_err(Error::from)
498 } else {
499 let local_var_entity: Option<OrganizationSponsorshipSyncPostError> =
500 serde_json::from_str(&local_var_content).ok();
501 let local_var_error = ResponseContent {
502 status: local_var_status,
503 content: local_var_content,
504 entity: local_var_entity,
505 };
506 Err(Error::ResponseError(local_var_error))
507 }
508}
509
510pub async fn organization_sponsorship_validate_token_post(
511 configuration: &configuration::Configuration,
512 sponsorship_token: Option<&str>,
513) -> Result<
514 models::PreValidateSponsorshipResponseModel,
515 Error<OrganizationSponsorshipValidateTokenPostError>,
516> {
517 let local_var_configuration = configuration;
518
519 let local_var_client = &local_var_configuration.client;
520
521 let local_var_uri_str = format!(
522 "{}/organization/sponsorship/validate-token",
523 local_var_configuration.base_path
524 );
525 let mut local_var_req_builder =
526 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
527
528 if let Some(ref local_var_str) = sponsorship_token {
529 local_var_req_builder =
530 local_var_req_builder.query(&[("sponsorshipToken", &local_var_str.to_string())]);
531 }
532 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
533 local_var_req_builder =
534 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
535 }
536 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
537 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
538 };
539
540 let local_var_req = local_var_req_builder.build()?;
541 let local_var_resp = local_var_client.execute(local_var_req).await?;
542
543 let local_var_status = local_var_resp.status();
544 let local_var_content = local_var_resp.text().await?;
545
546 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
547 serde_json::from_str(&local_var_content).map_err(Error::from)
548 } else {
549 let local_var_entity: Option<OrganizationSponsorshipValidateTokenPostError> =
550 serde_json::from_str(&local_var_content).ok();
551 let local_var_error = ResponseContent {
552 status: local_var_status,
553 content: local_var_content,
554 entity: local_var_entity,
555 };
556 Err(Error::ResponseError(local_var_error))
557 }
558}