1use std::sync::Arc;
12
13use async_trait::async_trait;
14#[cfg(feature = "mockall")]
15use mockall::automock;
16use reqwest;
17use serde::{Deserialize, Serialize, de::Error as _};
18
19use super::{Error, configuration};
20use crate::{
21 apis::{ContentType, ResponseContent},
22 models,
23};
24
25#[cfg_attr(feature = "mockall", automock)]
26#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
27#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
28pub trait AccountsApi: Send + Sync {
29 async fn api_key<'a>(
31 &self,
32 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
33 ) -> Result<models::ApiKeyResponseModel, Error<ApiKeyError>>;
34
35 async fn delete<'a>(
37 &self,
38 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
39 ) -> Result<(), Error<DeleteError>>;
40
41 async fn delete_sso_user<'a>(
43 &self,
44 organization_id: &'a str,
45 ) -> Result<(), Error<DeleteSsoUserError>>;
46
47 async fn get_account_revision_date(&self) -> Result<i64, Error<GetAccountRevisionDateError>>;
49
50 async fn get_keys(&self) -> Result<models::KeysResponseModel, Error<GetKeysError>>;
52
53 async fn get_organizations(
55 &self,
56 ) -> Result<
57 models::ProfileOrganizationResponseModelListResponseModel,
58 Error<GetOrganizationsError>,
59 >;
60
61 async fn get_profile(&self) -> Result<models::ProfileResponseModel, Error<GetProfileError>>;
63
64 async fn get_sso_user_identifier(&self) -> Result<String, Error<GetSsoUserIdentifierError>>;
66
67 async fn get_subscription(
69 &self,
70 ) -> Result<models::SubscriptionResponseModel, Error<GetSubscriptionError>>;
71
72 async fn get_tax_info(&self) -> Result<models::TaxInfoResponseModel, Error<GetTaxInfoError>>;
74
75 async fn post_cancel<'a>(
77 &self,
78 subscription_cancellation_request_model: Option<
79 models::SubscriptionCancellationRequestModel,
80 >,
81 ) -> Result<(), Error<PostCancelError>>;
82
83 async fn post_delete_recover<'a>(
85 &self,
86 delete_recover_request_model: Option<models::DeleteRecoverRequestModel>,
87 ) -> Result<(), Error<PostDeleteRecoverError>>;
88
89 async fn post_delete_recover_token<'a>(
91 &self,
92 verify_delete_recover_request_model: Option<models::VerifyDeleteRecoverRequestModel>,
93 ) -> Result<(), Error<PostDeleteRecoverTokenError>>;
94
95 async fn post_email<'a>(
97 &self,
98 email_request_model: Option<models::EmailRequestModel>,
99 ) -> Result<(), Error<PostEmailError>>;
100
101 async fn post_email_token<'a>(
103 &self,
104 email_token_request_model: Option<models::EmailTokenRequestModel>,
105 ) -> Result<(), Error<PostEmailTokenError>>;
106
107 async fn post_kdf<'a>(
109 &self,
110 kdf_request_model: Option<models::KdfRequestModel>,
111 ) -> Result<(), Error<PostKdfError>>;
112
113 async fn post_keys<'a>(
115 &self,
116 keys_request_model: Option<models::KeysRequestModel>,
117 ) -> Result<models::KeysResponseModel, Error<PostKeysError>>;
118
119 async fn post_license<'a>(
121 &self,
122 license: std::path::PathBuf,
123 ) -> Result<(), Error<PostLicenseError>>;
124
125 async fn post_password<'a>(
127 &self,
128 password_request_model: Option<models::PasswordRequestModel>,
129 ) -> Result<(), Error<PostPasswordError>>;
130
131 async fn post_password_hint<'a>(
133 &self,
134 password_hint_request_model: Option<models::PasswordHintRequestModel>,
135 ) -> Result<(), Error<PostPasswordHintError>>;
136
137 async fn post_payment<'a>(
139 &self,
140 payment_request_model: Option<models::PaymentRequestModel>,
141 ) -> Result<(), Error<PostPaymentError>>;
142
143 async fn post_premium<'a>(
145 &self,
146 payment_method_type: models::PaymentMethodType,
147 payment_token: Option<&'a str>,
148 additional_storage_gb: Option<i32>,
149 country: Option<&'a str>,
150 postal_code: Option<&'a str>,
151 license: Option<std::path::PathBuf>,
152 ) -> Result<models::PaymentResponseModel, Error<PostPremiumError>>;
153
154 async fn post_reinstate(&self) -> Result<(), Error<PostReinstateError>>;
156
157 async fn post_request_otp(&self) -> Result<(), Error<PostRequestOTPError>>;
159
160 async fn post_security_stamp<'a>(
162 &self,
163 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
164 ) -> Result<(), Error<PostSecurityStampError>>;
165
166 async fn post_set_password<'a>(
168 &self,
169 set_password_request_model: Option<models::SetPasswordRequestModel>,
170 ) -> Result<(), Error<PostSetPasswordError>>;
171
172 async fn post_storage<'a>(
174 &self,
175 storage_request_model: Option<models::StorageRequestModel>,
176 ) -> Result<models::PaymentResponseModel, Error<PostStorageError>>;
177
178 async fn post_verify_email(&self) -> Result<(), Error<PostVerifyEmailError>>;
180
181 async fn post_verify_email_token<'a>(
183 &self,
184 verify_email_request_model: Option<models::VerifyEmailRequestModel>,
185 ) -> Result<(), Error<PostVerifyEmailTokenError>>;
186
187 async fn post_verify_password<'a>(
189 &self,
190 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
191 ) -> Result<models::MasterPasswordPolicyResponseModel, Error<PostVerifyPasswordError>>;
192
193 async fn put_avatar<'a>(
195 &self,
196 update_avatar_request_model: Option<models::UpdateAvatarRequestModel>,
197 ) -> Result<models::ProfileResponseModel, Error<PutAvatarError>>;
198
199 async fn put_profile<'a>(
201 &self,
202 update_profile_request_model: Option<models::UpdateProfileRequestModel>,
203 ) -> Result<models::ProfileResponseModel, Error<PutProfileError>>;
204
205 async fn put_tax_info<'a>(
207 &self,
208 tax_info_update_request_model: Option<models::TaxInfoUpdateRequestModel>,
209 ) -> Result<(), Error<PutTaxInfoError>>;
210
211 async fn put_update_tde_password<'a>(
213 &self,
214 update_tde_offboarding_password_request_model: Option<
215 models::UpdateTdeOffboardingPasswordRequestModel,
216 >,
217 ) -> Result<(), Error<PutUpdateTdePasswordError>>;
218
219 async fn put_update_temp_password<'a>(
221 &self,
222 update_temp_password_request_model: Option<models::UpdateTempPasswordRequestModel>,
223 ) -> Result<(), Error<PutUpdateTempPasswordError>>;
224
225 async fn resend_new_device_otp<'a>(
227 &self,
228 unauthenticated_secret_verification_request_model: Option<
229 models::UnauthenticatedSecretVerificationRequestModel,
230 >,
231 ) -> Result<(), Error<ResendNewDeviceOtpError>>;
232
233 async fn rotate_api_key<'a>(
235 &self,
236 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
237 ) -> Result<models::ApiKeyResponseModel, Error<RotateApiKeyError>>;
238
239 async fn set_user_verify_devices<'a>(
241 &self,
242 set_verify_devices_request_model: Option<models::SetVerifyDevicesRequestModel>,
243 ) -> Result<(), Error<SetUserVerifyDevicesError>>;
244
245 async fn verify_otp<'a>(
247 &self,
248 verify_otp_request_model: Option<models::VerifyOtpRequestModel>,
249 ) -> Result<(), Error<VerifyOTPError>>;
250}
251
252pub struct AccountsApiClient {
253 configuration: Arc<configuration::Configuration>,
254}
255
256impl AccountsApiClient {
257 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
258 Self { configuration }
259 }
260}
261
262#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
263#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
264impl AccountsApi for AccountsApiClient {
265 async fn api_key<'a>(
266 &self,
267 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
268 ) -> Result<models::ApiKeyResponseModel, Error<ApiKeyError>> {
269 let local_var_configuration = &self.configuration;
270
271 let local_var_client = &local_var_configuration.client;
272
273 let local_var_uri_str = format!("{}/accounts/api-key", local_var_configuration.base_path);
274 let mut local_var_req_builder =
275 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
276
277 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
278 local_var_req_builder = local_var_req_builder
279 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
280 }
281 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
282 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
283 };
284 local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
285
286 let local_var_req = local_var_req_builder.build()?;
287 let local_var_resp = local_var_client.execute(local_var_req).await?;
288
289 let local_var_status = local_var_resp.status();
290 let local_var_content_type = local_var_resp
291 .headers()
292 .get("content-type")
293 .and_then(|v| v.to_str().ok())
294 .unwrap_or("application/octet-stream");
295 let local_var_content_type = super::ContentType::from(local_var_content_type);
296 let local_var_content = local_var_resp.text().await?;
297
298 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
299 match local_var_content_type {
300 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
301 ContentType::Text => {
302 return Err(Error::from(serde_json::Error::custom(
303 "Received `text/plain` content type response that cannot be converted to `models::ApiKeyResponseModel`",
304 )));
305 }
306 ContentType::Unsupported(local_var_unknown_type) => {
307 return Err(Error::from(serde_json::Error::custom(format!(
308 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ApiKeyResponseModel`"
309 ))));
310 }
311 }
312 } else {
313 let local_var_entity: Option<ApiKeyError> =
314 serde_json::from_str(&local_var_content).ok();
315 let local_var_error = ResponseContent {
316 status: local_var_status,
317 content: local_var_content,
318 entity: local_var_entity,
319 };
320 Err(Error::ResponseError(local_var_error))
321 }
322 }
323
324 async fn delete<'a>(
325 &self,
326 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
327 ) -> Result<(), Error<DeleteError>> {
328 let local_var_configuration = &self.configuration;
329
330 let local_var_client = &local_var_configuration.client;
331
332 let local_var_uri_str = format!("{}/accounts", local_var_configuration.base_path);
333 let mut local_var_req_builder =
334 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
335
336 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
337 local_var_req_builder = local_var_req_builder
338 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
339 }
340 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
341 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
342 };
343 local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
344
345 let local_var_req = local_var_req_builder.build()?;
346 let local_var_resp = local_var_client.execute(local_var_req).await?;
347
348 let local_var_status = local_var_resp.status();
349 let local_var_content = local_var_resp.text().await?;
350
351 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
352 Ok(())
353 } else {
354 let local_var_entity: Option<DeleteError> =
355 serde_json::from_str(&local_var_content).ok();
356 let local_var_error = ResponseContent {
357 status: local_var_status,
358 content: local_var_content,
359 entity: local_var_entity,
360 };
361 Err(Error::ResponseError(local_var_error))
362 }
363 }
364
365 async fn delete_sso_user<'a>(
366 &self,
367 organization_id: &'a str,
368 ) -> Result<(), Error<DeleteSsoUserError>> {
369 let local_var_configuration = &self.configuration;
370
371 let local_var_client = &local_var_configuration.client;
372
373 let local_var_uri_str = format!(
374 "{}/accounts/sso/{organizationId}",
375 local_var_configuration.base_path,
376 organizationId = crate::apis::urlencode(organization_id)
377 );
378 let mut local_var_req_builder =
379 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
380
381 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
382 local_var_req_builder = local_var_req_builder
383 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
384 }
385 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
386 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
387 };
388
389 let local_var_req = local_var_req_builder.build()?;
390 let local_var_resp = local_var_client.execute(local_var_req).await?;
391
392 let local_var_status = local_var_resp.status();
393 let local_var_content = local_var_resp.text().await?;
394
395 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
396 Ok(())
397 } else {
398 let local_var_entity: Option<DeleteSsoUserError> =
399 serde_json::from_str(&local_var_content).ok();
400 let local_var_error = ResponseContent {
401 status: local_var_status,
402 content: local_var_content,
403 entity: local_var_entity,
404 };
405 Err(Error::ResponseError(local_var_error))
406 }
407 }
408
409 async fn get_account_revision_date(&self) -> Result<i64, Error<GetAccountRevisionDateError>> {
410 let local_var_configuration = &self.configuration;
411
412 let local_var_client = &local_var_configuration.client;
413
414 let local_var_uri_str = format!(
415 "{}/accounts/revision-date",
416 local_var_configuration.base_path
417 );
418 let mut local_var_req_builder =
419 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
420
421 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
422 local_var_req_builder = local_var_req_builder
423 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
424 }
425 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
426 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
427 };
428
429 let local_var_req = local_var_req_builder.build()?;
430 let local_var_resp = local_var_client.execute(local_var_req).await?;
431
432 let local_var_status = local_var_resp.status();
433 let local_var_content_type = local_var_resp
434 .headers()
435 .get("content-type")
436 .and_then(|v| v.to_str().ok())
437 .unwrap_or("application/octet-stream");
438 let local_var_content_type = super::ContentType::from(local_var_content_type);
439 let local_var_content = local_var_resp.text().await?;
440
441 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
442 match local_var_content_type {
443 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
444 ContentType::Text => {
445 return Err(Error::from(serde_json::Error::custom(
446 "Received `text/plain` content type response that cannot be converted to `i64`",
447 )));
448 }
449 ContentType::Unsupported(local_var_unknown_type) => {
450 return Err(Error::from(serde_json::Error::custom(format!(
451 "Received `{local_var_unknown_type}` content type response that cannot be converted to `i64`"
452 ))));
453 }
454 }
455 } else {
456 let local_var_entity: Option<GetAccountRevisionDateError> =
457 serde_json::from_str(&local_var_content).ok();
458 let local_var_error = ResponseContent {
459 status: local_var_status,
460 content: local_var_content,
461 entity: local_var_entity,
462 };
463 Err(Error::ResponseError(local_var_error))
464 }
465 }
466
467 async fn get_keys(&self) -> Result<models::KeysResponseModel, Error<GetKeysError>> {
468 let local_var_configuration = &self.configuration;
469
470 let local_var_client = &local_var_configuration.client;
471
472 let local_var_uri_str = format!("{}/accounts/keys", local_var_configuration.base_path);
473 let mut local_var_req_builder =
474 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
475
476 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
477 local_var_req_builder = local_var_req_builder
478 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
479 }
480 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
481 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
482 };
483
484 let local_var_req = local_var_req_builder.build()?;
485 let local_var_resp = local_var_client.execute(local_var_req).await?;
486
487 let local_var_status = local_var_resp.status();
488 let local_var_content_type = local_var_resp
489 .headers()
490 .get("content-type")
491 .and_then(|v| v.to_str().ok())
492 .unwrap_or("application/octet-stream");
493 let local_var_content_type = super::ContentType::from(local_var_content_type);
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 match local_var_content_type {
498 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
499 ContentType::Text => {
500 return Err(Error::from(serde_json::Error::custom(
501 "Received `text/plain` content type response that cannot be converted to `models::KeysResponseModel`",
502 )));
503 }
504 ContentType::Unsupported(local_var_unknown_type) => {
505 return Err(Error::from(serde_json::Error::custom(format!(
506 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::KeysResponseModel`"
507 ))));
508 }
509 }
510 } else {
511 let local_var_entity: Option<GetKeysError> =
512 serde_json::from_str(&local_var_content).ok();
513 let local_var_error = ResponseContent {
514 status: local_var_status,
515 content: local_var_content,
516 entity: local_var_entity,
517 };
518 Err(Error::ResponseError(local_var_error))
519 }
520 }
521
522 async fn get_organizations(
523 &self,
524 ) -> Result<
525 models::ProfileOrganizationResponseModelListResponseModel,
526 Error<GetOrganizationsError>,
527 > {
528 let local_var_configuration = &self.configuration;
529
530 let local_var_client = &local_var_configuration.client;
531
532 let local_var_uri_str = format!(
533 "{}/accounts/organizations",
534 local_var_configuration.base_path
535 );
536 let mut local_var_req_builder =
537 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
538
539 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
540 local_var_req_builder = local_var_req_builder
541 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
542 }
543 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
544 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
545 };
546
547 let local_var_req = local_var_req_builder.build()?;
548 let local_var_resp = local_var_client.execute(local_var_req).await?;
549
550 let local_var_status = local_var_resp.status();
551 let local_var_content_type = local_var_resp
552 .headers()
553 .get("content-type")
554 .and_then(|v| v.to_str().ok())
555 .unwrap_or("application/octet-stream");
556 let local_var_content_type = super::ContentType::from(local_var_content_type);
557 let local_var_content = local_var_resp.text().await?;
558
559 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
560 match local_var_content_type {
561 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
562 ContentType::Text => {
563 return Err(Error::from(serde_json::Error::custom(
564 "Received `text/plain` content type response that cannot be converted to `models::ProfileOrganizationResponseModelListResponseModel`",
565 )));
566 }
567 ContentType::Unsupported(local_var_unknown_type) => {
568 return Err(Error::from(serde_json::Error::custom(format!(
569 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProfileOrganizationResponseModelListResponseModel`"
570 ))));
571 }
572 }
573 } else {
574 let local_var_entity: Option<GetOrganizationsError> =
575 serde_json::from_str(&local_var_content).ok();
576 let local_var_error = ResponseContent {
577 status: local_var_status,
578 content: local_var_content,
579 entity: local_var_entity,
580 };
581 Err(Error::ResponseError(local_var_error))
582 }
583 }
584
585 async fn get_profile(&self) -> Result<models::ProfileResponseModel, Error<GetProfileError>> {
586 let local_var_configuration = &self.configuration;
587
588 let local_var_client = &local_var_configuration.client;
589
590 let local_var_uri_str = format!("{}/accounts/profile", local_var_configuration.base_path);
591 let mut local_var_req_builder =
592 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
593
594 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
595 local_var_req_builder = local_var_req_builder
596 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
597 }
598 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
599 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
600 };
601
602 let local_var_req = local_var_req_builder.build()?;
603 let local_var_resp = local_var_client.execute(local_var_req).await?;
604
605 let local_var_status = local_var_resp.status();
606 let local_var_content_type = local_var_resp
607 .headers()
608 .get("content-type")
609 .and_then(|v| v.to_str().ok())
610 .unwrap_or("application/octet-stream");
611 let local_var_content_type = super::ContentType::from(local_var_content_type);
612 let local_var_content = local_var_resp.text().await?;
613
614 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
615 match local_var_content_type {
616 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
617 ContentType::Text => {
618 return Err(Error::from(serde_json::Error::custom(
619 "Received `text/plain` content type response that cannot be converted to `models::ProfileResponseModel`",
620 )));
621 }
622 ContentType::Unsupported(local_var_unknown_type) => {
623 return Err(Error::from(serde_json::Error::custom(format!(
624 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProfileResponseModel`"
625 ))));
626 }
627 }
628 } else {
629 let local_var_entity: Option<GetProfileError> =
630 serde_json::from_str(&local_var_content).ok();
631 let local_var_error = ResponseContent {
632 status: local_var_status,
633 content: local_var_content,
634 entity: local_var_entity,
635 };
636 Err(Error::ResponseError(local_var_error))
637 }
638 }
639
640 async fn get_sso_user_identifier(&self) -> Result<String, Error<GetSsoUserIdentifierError>> {
641 let local_var_configuration = &self.configuration;
642
643 let local_var_client = &local_var_configuration.client;
644
645 let local_var_uri_str = format!(
646 "{}/accounts/sso/user-identifier",
647 local_var_configuration.base_path
648 );
649 let mut local_var_req_builder =
650 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
651
652 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
653 local_var_req_builder = local_var_req_builder
654 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
655 }
656 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
657 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
658 };
659
660 let local_var_req = local_var_req_builder.build()?;
661 let local_var_resp = local_var_client.execute(local_var_req).await?;
662
663 let local_var_status = local_var_resp.status();
664 let local_var_content_type = local_var_resp
665 .headers()
666 .get("content-type")
667 .and_then(|v| v.to_str().ok())
668 .unwrap_or("application/octet-stream");
669 let local_var_content_type = super::ContentType::from(local_var_content_type);
670 let local_var_content = local_var_resp.text().await?;
671
672 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
673 match local_var_content_type {
674 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
675 ContentType::Text => return Ok(local_var_content),
676 ContentType::Unsupported(local_var_unknown_type) => {
677 return Err(Error::from(serde_json::Error::custom(format!(
678 "Received `{local_var_unknown_type}` content type response that cannot be converted to `String`"
679 ))));
680 }
681 }
682 } else {
683 let local_var_entity: Option<GetSsoUserIdentifierError> =
684 serde_json::from_str(&local_var_content).ok();
685 let local_var_error = ResponseContent {
686 status: local_var_status,
687 content: local_var_content,
688 entity: local_var_entity,
689 };
690 Err(Error::ResponseError(local_var_error))
691 }
692 }
693
694 async fn get_subscription(
695 &self,
696 ) -> Result<models::SubscriptionResponseModel, Error<GetSubscriptionError>> {
697 let local_var_configuration = &self.configuration;
698
699 let local_var_client = &local_var_configuration.client;
700
701 let local_var_uri_str = format!(
702 "{}/accounts/subscription",
703 local_var_configuration.base_path
704 );
705 let mut local_var_req_builder =
706 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
707
708 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
709 local_var_req_builder = local_var_req_builder
710 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
711 }
712 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
713 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
714 };
715
716 let local_var_req = local_var_req_builder.build()?;
717 let local_var_resp = local_var_client.execute(local_var_req).await?;
718
719 let local_var_status = local_var_resp.status();
720 let local_var_content_type = local_var_resp
721 .headers()
722 .get("content-type")
723 .and_then(|v| v.to_str().ok())
724 .unwrap_or("application/octet-stream");
725 let local_var_content_type = super::ContentType::from(local_var_content_type);
726 let local_var_content = local_var_resp.text().await?;
727
728 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
729 match local_var_content_type {
730 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
731 ContentType::Text => {
732 return Err(Error::from(serde_json::Error::custom(
733 "Received `text/plain` content type response that cannot be converted to `models::SubscriptionResponseModel`",
734 )));
735 }
736 ContentType::Unsupported(local_var_unknown_type) => {
737 return Err(Error::from(serde_json::Error::custom(format!(
738 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::SubscriptionResponseModel`"
739 ))));
740 }
741 }
742 } else {
743 let local_var_entity: Option<GetSubscriptionError> =
744 serde_json::from_str(&local_var_content).ok();
745 let local_var_error = ResponseContent {
746 status: local_var_status,
747 content: local_var_content,
748 entity: local_var_entity,
749 };
750 Err(Error::ResponseError(local_var_error))
751 }
752 }
753
754 async fn get_tax_info(&self) -> Result<models::TaxInfoResponseModel, Error<GetTaxInfoError>> {
755 let local_var_configuration = &self.configuration;
756
757 let local_var_client = &local_var_configuration.client;
758
759 let local_var_uri_str = format!("{}/accounts/tax", local_var_configuration.base_path);
760 let mut local_var_req_builder =
761 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
762
763 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
764 local_var_req_builder = local_var_req_builder
765 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
766 }
767 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
768 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
769 };
770
771 let local_var_req = local_var_req_builder.build()?;
772 let local_var_resp = local_var_client.execute(local_var_req).await?;
773
774 let local_var_status = local_var_resp.status();
775 let local_var_content_type = local_var_resp
776 .headers()
777 .get("content-type")
778 .and_then(|v| v.to_str().ok())
779 .unwrap_or("application/octet-stream");
780 let local_var_content_type = super::ContentType::from(local_var_content_type);
781 let local_var_content = local_var_resp.text().await?;
782
783 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
784 match local_var_content_type {
785 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
786 ContentType::Text => {
787 return Err(Error::from(serde_json::Error::custom(
788 "Received `text/plain` content type response that cannot be converted to `models::TaxInfoResponseModel`",
789 )));
790 }
791 ContentType::Unsupported(local_var_unknown_type) => {
792 return Err(Error::from(serde_json::Error::custom(format!(
793 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::TaxInfoResponseModel`"
794 ))));
795 }
796 }
797 } else {
798 let local_var_entity: Option<GetTaxInfoError> =
799 serde_json::from_str(&local_var_content).ok();
800 let local_var_error = ResponseContent {
801 status: local_var_status,
802 content: local_var_content,
803 entity: local_var_entity,
804 };
805 Err(Error::ResponseError(local_var_error))
806 }
807 }
808
809 async fn post_cancel<'a>(
810 &self,
811 subscription_cancellation_request_model: Option<
812 models::SubscriptionCancellationRequestModel,
813 >,
814 ) -> Result<(), Error<PostCancelError>> {
815 let local_var_configuration = &self.configuration;
816
817 let local_var_client = &local_var_configuration.client;
818
819 let local_var_uri_str = format!("{}/accounts/cancel", local_var_configuration.base_path);
820 let mut local_var_req_builder =
821 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
822
823 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
824 local_var_req_builder = local_var_req_builder
825 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
826 }
827 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
828 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
829 };
830 local_var_req_builder =
831 local_var_req_builder.json(&subscription_cancellation_request_model);
832
833 let local_var_req = local_var_req_builder.build()?;
834 let local_var_resp = local_var_client.execute(local_var_req).await?;
835
836 let local_var_status = local_var_resp.status();
837 let local_var_content = local_var_resp.text().await?;
838
839 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
840 Ok(())
841 } else {
842 let local_var_entity: Option<PostCancelError> =
843 serde_json::from_str(&local_var_content).ok();
844 let local_var_error = ResponseContent {
845 status: local_var_status,
846 content: local_var_content,
847 entity: local_var_entity,
848 };
849 Err(Error::ResponseError(local_var_error))
850 }
851 }
852
853 async fn post_delete_recover<'a>(
854 &self,
855 delete_recover_request_model: Option<models::DeleteRecoverRequestModel>,
856 ) -> Result<(), Error<PostDeleteRecoverError>> {
857 let local_var_configuration = &self.configuration;
858
859 let local_var_client = &local_var_configuration.client;
860
861 let local_var_uri_str = format!(
862 "{}/accounts/delete-recover",
863 local_var_configuration.base_path
864 );
865 let mut local_var_req_builder =
866 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
867
868 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
869 local_var_req_builder = local_var_req_builder
870 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
871 }
872 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
873 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
874 };
875 local_var_req_builder = local_var_req_builder.json(&delete_recover_request_model);
876
877 let local_var_req = local_var_req_builder.build()?;
878 let local_var_resp = local_var_client.execute(local_var_req).await?;
879
880 let local_var_status = local_var_resp.status();
881 let local_var_content = local_var_resp.text().await?;
882
883 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
884 Ok(())
885 } else {
886 let local_var_entity: Option<PostDeleteRecoverError> =
887 serde_json::from_str(&local_var_content).ok();
888 let local_var_error = ResponseContent {
889 status: local_var_status,
890 content: local_var_content,
891 entity: local_var_entity,
892 };
893 Err(Error::ResponseError(local_var_error))
894 }
895 }
896
897 async fn post_delete_recover_token<'a>(
898 &self,
899 verify_delete_recover_request_model: Option<models::VerifyDeleteRecoverRequestModel>,
900 ) -> Result<(), Error<PostDeleteRecoverTokenError>> {
901 let local_var_configuration = &self.configuration;
902
903 let local_var_client = &local_var_configuration.client;
904
905 let local_var_uri_str = format!(
906 "{}/accounts/delete-recover-token",
907 local_var_configuration.base_path
908 );
909 let mut local_var_req_builder =
910 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
911
912 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
913 local_var_req_builder = local_var_req_builder
914 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
915 }
916 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
917 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
918 };
919 local_var_req_builder = local_var_req_builder.json(&verify_delete_recover_request_model);
920
921 let local_var_req = local_var_req_builder.build()?;
922 let local_var_resp = local_var_client.execute(local_var_req).await?;
923
924 let local_var_status = local_var_resp.status();
925 let local_var_content = local_var_resp.text().await?;
926
927 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
928 Ok(())
929 } else {
930 let local_var_entity: Option<PostDeleteRecoverTokenError> =
931 serde_json::from_str(&local_var_content).ok();
932 let local_var_error = ResponseContent {
933 status: local_var_status,
934 content: local_var_content,
935 entity: local_var_entity,
936 };
937 Err(Error::ResponseError(local_var_error))
938 }
939 }
940
941 async fn post_email<'a>(
942 &self,
943 email_request_model: Option<models::EmailRequestModel>,
944 ) -> Result<(), Error<PostEmailError>> {
945 let local_var_configuration = &self.configuration;
946
947 let local_var_client = &local_var_configuration.client;
948
949 let local_var_uri_str = format!("{}/accounts/email", local_var_configuration.base_path);
950 let mut local_var_req_builder =
951 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
952
953 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
954 local_var_req_builder = local_var_req_builder
955 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
956 }
957 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
958 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
959 };
960 local_var_req_builder = local_var_req_builder.json(&email_request_model);
961
962 let local_var_req = local_var_req_builder.build()?;
963 let local_var_resp = local_var_client.execute(local_var_req).await?;
964
965 let local_var_status = local_var_resp.status();
966 let local_var_content = local_var_resp.text().await?;
967
968 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
969 Ok(())
970 } else {
971 let local_var_entity: Option<PostEmailError> =
972 serde_json::from_str(&local_var_content).ok();
973 let local_var_error = ResponseContent {
974 status: local_var_status,
975 content: local_var_content,
976 entity: local_var_entity,
977 };
978 Err(Error::ResponseError(local_var_error))
979 }
980 }
981
982 async fn post_email_token<'a>(
983 &self,
984 email_token_request_model: Option<models::EmailTokenRequestModel>,
985 ) -> Result<(), Error<PostEmailTokenError>> {
986 let local_var_configuration = &self.configuration;
987
988 let local_var_client = &local_var_configuration.client;
989
990 let local_var_uri_str =
991 format!("{}/accounts/email-token", local_var_configuration.base_path);
992 let mut local_var_req_builder =
993 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
994
995 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
996 local_var_req_builder = local_var_req_builder
997 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
998 }
999 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1000 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1001 };
1002 local_var_req_builder = local_var_req_builder.json(&email_token_request_model);
1003
1004 let local_var_req = local_var_req_builder.build()?;
1005 let local_var_resp = local_var_client.execute(local_var_req).await?;
1006
1007 let local_var_status = local_var_resp.status();
1008 let local_var_content = local_var_resp.text().await?;
1009
1010 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1011 Ok(())
1012 } else {
1013 let local_var_entity: Option<PostEmailTokenError> =
1014 serde_json::from_str(&local_var_content).ok();
1015 let local_var_error = ResponseContent {
1016 status: local_var_status,
1017 content: local_var_content,
1018 entity: local_var_entity,
1019 };
1020 Err(Error::ResponseError(local_var_error))
1021 }
1022 }
1023
1024 async fn post_kdf<'a>(
1025 &self,
1026 kdf_request_model: Option<models::KdfRequestModel>,
1027 ) -> Result<(), Error<PostKdfError>> {
1028 let local_var_configuration = &self.configuration;
1029
1030 let local_var_client = &local_var_configuration.client;
1031
1032 let local_var_uri_str = format!("{}/accounts/kdf", local_var_configuration.base_path);
1033 let mut local_var_req_builder =
1034 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1035
1036 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1037 local_var_req_builder = local_var_req_builder
1038 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1039 }
1040 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1041 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1042 };
1043 local_var_req_builder = local_var_req_builder.json(&kdf_request_model);
1044
1045 let local_var_req = local_var_req_builder.build()?;
1046 let local_var_resp = local_var_client.execute(local_var_req).await?;
1047
1048 let local_var_status = local_var_resp.status();
1049 let local_var_content = local_var_resp.text().await?;
1050
1051 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1052 Ok(())
1053 } else {
1054 let local_var_entity: Option<PostKdfError> =
1055 serde_json::from_str(&local_var_content).ok();
1056 let local_var_error = ResponseContent {
1057 status: local_var_status,
1058 content: local_var_content,
1059 entity: local_var_entity,
1060 };
1061 Err(Error::ResponseError(local_var_error))
1062 }
1063 }
1064
1065 async fn post_keys<'a>(
1066 &self,
1067 keys_request_model: Option<models::KeysRequestModel>,
1068 ) -> Result<models::KeysResponseModel, Error<PostKeysError>> {
1069 let local_var_configuration = &self.configuration;
1070
1071 let local_var_client = &local_var_configuration.client;
1072
1073 let local_var_uri_str = format!("{}/accounts/keys", local_var_configuration.base_path);
1074 let mut local_var_req_builder =
1075 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1076
1077 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1078 local_var_req_builder = local_var_req_builder
1079 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1080 }
1081 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1082 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1083 };
1084 local_var_req_builder = local_var_req_builder.json(&keys_request_model);
1085
1086 let local_var_req = local_var_req_builder.build()?;
1087 let local_var_resp = local_var_client.execute(local_var_req).await?;
1088
1089 let local_var_status = local_var_resp.status();
1090 let local_var_content_type = local_var_resp
1091 .headers()
1092 .get("content-type")
1093 .and_then(|v| v.to_str().ok())
1094 .unwrap_or("application/octet-stream");
1095 let local_var_content_type = super::ContentType::from(local_var_content_type);
1096 let local_var_content = local_var_resp.text().await?;
1097
1098 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1099 match local_var_content_type {
1100 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1101 ContentType::Text => {
1102 return Err(Error::from(serde_json::Error::custom(
1103 "Received `text/plain` content type response that cannot be converted to `models::KeysResponseModel`",
1104 )));
1105 }
1106 ContentType::Unsupported(local_var_unknown_type) => {
1107 return Err(Error::from(serde_json::Error::custom(format!(
1108 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::KeysResponseModel`"
1109 ))));
1110 }
1111 }
1112 } else {
1113 let local_var_entity: Option<PostKeysError> =
1114 serde_json::from_str(&local_var_content).ok();
1115 let local_var_error = ResponseContent {
1116 status: local_var_status,
1117 content: local_var_content,
1118 entity: local_var_entity,
1119 };
1120 Err(Error::ResponseError(local_var_error))
1121 }
1122 }
1123
1124 async fn post_license<'a>(
1125 &self,
1126 license: std::path::PathBuf,
1127 ) -> Result<(), Error<PostLicenseError>> {
1128 let local_var_configuration = &self.configuration;
1129
1130 let local_var_client = &local_var_configuration.client;
1131
1132 let local_var_uri_str = format!("{}/accounts/license", local_var_configuration.base_path);
1133 let mut local_var_req_builder =
1134 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1135
1136 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1137 local_var_req_builder = local_var_req_builder
1138 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1139 }
1140 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1141 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1142 };
1143 let mut local_var_form = reqwest::multipart::Form::new();
1144 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
1146
1147 let local_var_req = local_var_req_builder.build()?;
1148 let local_var_resp = local_var_client.execute(local_var_req).await?;
1149
1150 let local_var_status = local_var_resp.status();
1151 let local_var_content = local_var_resp.text().await?;
1152
1153 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1154 Ok(())
1155 } else {
1156 let local_var_entity: Option<PostLicenseError> =
1157 serde_json::from_str(&local_var_content).ok();
1158 let local_var_error = ResponseContent {
1159 status: local_var_status,
1160 content: local_var_content,
1161 entity: local_var_entity,
1162 };
1163 Err(Error::ResponseError(local_var_error))
1164 }
1165 }
1166
1167 async fn post_password<'a>(
1168 &self,
1169 password_request_model: Option<models::PasswordRequestModel>,
1170 ) -> Result<(), Error<PostPasswordError>> {
1171 let local_var_configuration = &self.configuration;
1172
1173 let local_var_client = &local_var_configuration.client;
1174
1175 let local_var_uri_str = format!("{}/accounts/password", local_var_configuration.base_path);
1176 let mut local_var_req_builder =
1177 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1178
1179 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1180 local_var_req_builder = local_var_req_builder
1181 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1182 }
1183 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1184 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1185 };
1186 local_var_req_builder = local_var_req_builder.json(&password_request_model);
1187
1188 let local_var_req = local_var_req_builder.build()?;
1189 let local_var_resp = local_var_client.execute(local_var_req).await?;
1190
1191 let local_var_status = local_var_resp.status();
1192 let local_var_content = local_var_resp.text().await?;
1193
1194 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1195 Ok(())
1196 } else {
1197 let local_var_entity: Option<PostPasswordError> =
1198 serde_json::from_str(&local_var_content).ok();
1199 let local_var_error = ResponseContent {
1200 status: local_var_status,
1201 content: local_var_content,
1202 entity: local_var_entity,
1203 };
1204 Err(Error::ResponseError(local_var_error))
1205 }
1206 }
1207
1208 async fn post_password_hint<'a>(
1209 &self,
1210 password_hint_request_model: Option<models::PasswordHintRequestModel>,
1211 ) -> Result<(), Error<PostPasswordHintError>> {
1212 let local_var_configuration = &self.configuration;
1213
1214 let local_var_client = &local_var_configuration.client;
1215
1216 let local_var_uri_str = format!(
1217 "{}/accounts/password-hint",
1218 local_var_configuration.base_path
1219 );
1220 let mut local_var_req_builder =
1221 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1222
1223 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1224 local_var_req_builder = local_var_req_builder
1225 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1226 }
1227 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1228 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1229 };
1230 local_var_req_builder = local_var_req_builder.json(&password_hint_request_model);
1231
1232 let local_var_req = local_var_req_builder.build()?;
1233 let local_var_resp = local_var_client.execute(local_var_req).await?;
1234
1235 let local_var_status = local_var_resp.status();
1236 let local_var_content = local_var_resp.text().await?;
1237
1238 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1239 Ok(())
1240 } else {
1241 let local_var_entity: Option<PostPasswordHintError> =
1242 serde_json::from_str(&local_var_content).ok();
1243 let local_var_error = ResponseContent {
1244 status: local_var_status,
1245 content: local_var_content,
1246 entity: local_var_entity,
1247 };
1248 Err(Error::ResponseError(local_var_error))
1249 }
1250 }
1251
1252 async fn post_payment<'a>(
1253 &self,
1254 payment_request_model: Option<models::PaymentRequestModel>,
1255 ) -> Result<(), Error<PostPaymentError>> {
1256 let local_var_configuration = &self.configuration;
1257
1258 let local_var_client = &local_var_configuration.client;
1259
1260 let local_var_uri_str = format!("{}/accounts/payment", local_var_configuration.base_path);
1261 let mut local_var_req_builder =
1262 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1263
1264 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1265 local_var_req_builder = local_var_req_builder
1266 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1267 }
1268 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1269 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1270 };
1271 local_var_req_builder = local_var_req_builder.json(&payment_request_model);
1272
1273 let local_var_req = local_var_req_builder.build()?;
1274 let local_var_resp = local_var_client.execute(local_var_req).await?;
1275
1276 let local_var_status = local_var_resp.status();
1277 let local_var_content = local_var_resp.text().await?;
1278
1279 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1280 Ok(())
1281 } else {
1282 let local_var_entity: Option<PostPaymentError> =
1283 serde_json::from_str(&local_var_content).ok();
1284 let local_var_error = ResponseContent {
1285 status: local_var_status,
1286 content: local_var_content,
1287 entity: local_var_entity,
1288 };
1289 Err(Error::ResponseError(local_var_error))
1290 }
1291 }
1292
1293 async fn post_premium<'a>(
1294 &self,
1295 payment_method_type: models::PaymentMethodType,
1296 payment_token: Option<&'a str>,
1297 additional_storage_gb: Option<i32>,
1298 country: Option<&'a str>,
1299 postal_code: Option<&'a str>,
1300 license: Option<std::path::PathBuf>,
1301 ) -> Result<models::PaymentResponseModel, Error<PostPremiumError>> {
1302 let local_var_configuration = &self.configuration;
1303
1304 let local_var_client = &local_var_configuration.client;
1305
1306 let local_var_uri_str = format!("{}/accounts/premium", local_var_configuration.base_path);
1307 let mut local_var_req_builder =
1308 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1309
1310 local_var_req_builder =
1311 local_var_req_builder.query(&[("paymentMethodType", &payment_method_type.to_string())]);
1312 if let Some(ref param_value) = payment_token {
1313 local_var_req_builder =
1314 local_var_req_builder.query(&[("paymentToken", ¶m_value.to_string())]);
1315 }
1316 if let Some(ref param_value) = additional_storage_gb {
1317 local_var_req_builder =
1318 local_var_req_builder.query(&[("additionalStorageGb", ¶m_value.to_string())]);
1319 }
1320 if let Some(ref param_value) = country {
1321 local_var_req_builder =
1322 local_var_req_builder.query(&[("country", ¶m_value.to_string())]);
1323 }
1324 if let Some(ref param_value) = postal_code {
1325 local_var_req_builder =
1326 local_var_req_builder.query(&[("postalCode", ¶m_value.to_string())]);
1327 }
1328 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1329 local_var_req_builder = local_var_req_builder
1330 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1331 }
1332 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1333 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1334 };
1335 let mut local_var_form = reqwest::multipart::Form::new();
1336 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
1338
1339 let local_var_req = local_var_req_builder.build()?;
1340 let local_var_resp = local_var_client.execute(local_var_req).await?;
1341
1342 let local_var_status = local_var_resp.status();
1343 let local_var_content_type = local_var_resp
1344 .headers()
1345 .get("content-type")
1346 .and_then(|v| v.to_str().ok())
1347 .unwrap_or("application/octet-stream");
1348 let local_var_content_type = super::ContentType::from(local_var_content_type);
1349 let local_var_content = local_var_resp.text().await?;
1350
1351 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1352 match local_var_content_type {
1353 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1354 ContentType::Text => {
1355 return Err(Error::from(serde_json::Error::custom(
1356 "Received `text/plain` content type response that cannot be converted to `models::PaymentResponseModel`",
1357 )));
1358 }
1359 ContentType::Unsupported(local_var_unknown_type) => {
1360 return Err(Error::from(serde_json::Error::custom(format!(
1361 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::PaymentResponseModel`"
1362 ))));
1363 }
1364 }
1365 } else {
1366 let local_var_entity: Option<PostPremiumError> =
1367 serde_json::from_str(&local_var_content).ok();
1368 let local_var_error = ResponseContent {
1369 status: local_var_status,
1370 content: local_var_content,
1371 entity: local_var_entity,
1372 };
1373 Err(Error::ResponseError(local_var_error))
1374 }
1375 }
1376
1377 async fn post_reinstate(&self) -> Result<(), Error<PostReinstateError>> {
1378 let local_var_configuration = &self.configuration;
1379
1380 let local_var_client = &local_var_configuration.client;
1381
1382 let local_var_uri_str = format!(
1383 "{}/accounts/reinstate-premium",
1384 local_var_configuration.base_path
1385 );
1386 let mut local_var_req_builder =
1387 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1388
1389 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1390 local_var_req_builder = local_var_req_builder
1391 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1392 }
1393 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1394 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1395 };
1396
1397 let local_var_req = local_var_req_builder.build()?;
1398 let local_var_resp = local_var_client.execute(local_var_req).await?;
1399
1400 let local_var_status = local_var_resp.status();
1401 let local_var_content = local_var_resp.text().await?;
1402
1403 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1404 Ok(())
1405 } else {
1406 let local_var_entity: Option<PostReinstateError> =
1407 serde_json::from_str(&local_var_content).ok();
1408 let local_var_error = ResponseContent {
1409 status: local_var_status,
1410 content: local_var_content,
1411 entity: local_var_entity,
1412 };
1413 Err(Error::ResponseError(local_var_error))
1414 }
1415 }
1416
1417 async fn post_request_otp(&self) -> Result<(), Error<PostRequestOTPError>> {
1418 let local_var_configuration = &self.configuration;
1419
1420 let local_var_client = &local_var_configuration.client;
1421
1422 let local_var_uri_str =
1423 format!("{}/accounts/request-otp", local_var_configuration.base_path);
1424 let mut local_var_req_builder =
1425 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1426
1427 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1428 local_var_req_builder = local_var_req_builder
1429 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1430 }
1431 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1432 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1433 };
1434
1435 let local_var_req = local_var_req_builder.build()?;
1436 let local_var_resp = local_var_client.execute(local_var_req).await?;
1437
1438 let local_var_status = local_var_resp.status();
1439 let local_var_content = local_var_resp.text().await?;
1440
1441 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1442 Ok(())
1443 } else {
1444 let local_var_entity: Option<PostRequestOTPError> =
1445 serde_json::from_str(&local_var_content).ok();
1446 let local_var_error = ResponseContent {
1447 status: local_var_status,
1448 content: local_var_content,
1449 entity: local_var_entity,
1450 };
1451 Err(Error::ResponseError(local_var_error))
1452 }
1453 }
1454
1455 async fn post_security_stamp<'a>(
1456 &self,
1457 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
1458 ) -> Result<(), Error<PostSecurityStampError>> {
1459 let local_var_configuration = &self.configuration;
1460
1461 let local_var_client = &local_var_configuration.client;
1462
1463 let local_var_uri_str = format!(
1464 "{}/accounts/security-stamp",
1465 local_var_configuration.base_path
1466 );
1467 let mut local_var_req_builder =
1468 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1469
1470 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1471 local_var_req_builder = local_var_req_builder
1472 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1473 }
1474 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1475 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1476 };
1477 local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
1478
1479 let local_var_req = local_var_req_builder.build()?;
1480 let local_var_resp = local_var_client.execute(local_var_req).await?;
1481
1482 let local_var_status = local_var_resp.status();
1483 let local_var_content = local_var_resp.text().await?;
1484
1485 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1486 Ok(())
1487 } else {
1488 let local_var_entity: Option<PostSecurityStampError> =
1489 serde_json::from_str(&local_var_content).ok();
1490 let local_var_error = ResponseContent {
1491 status: local_var_status,
1492 content: local_var_content,
1493 entity: local_var_entity,
1494 };
1495 Err(Error::ResponseError(local_var_error))
1496 }
1497 }
1498
1499 async fn post_set_password<'a>(
1500 &self,
1501 set_password_request_model: Option<models::SetPasswordRequestModel>,
1502 ) -> Result<(), Error<PostSetPasswordError>> {
1503 let local_var_configuration = &self.configuration;
1504
1505 let local_var_client = &local_var_configuration.client;
1506
1507 let local_var_uri_str = format!(
1508 "{}/accounts/set-password",
1509 local_var_configuration.base_path
1510 );
1511 let mut local_var_req_builder =
1512 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1513
1514 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1515 local_var_req_builder = local_var_req_builder
1516 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1517 }
1518 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1519 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1520 };
1521 local_var_req_builder = local_var_req_builder.json(&set_password_request_model);
1522
1523 let local_var_req = local_var_req_builder.build()?;
1524 let local_var_resp = local_var_client.execute(local_var_req).await?;
1525
1526 let local_var_status = local_var_resp.status();
1527 let local_var_content = local_var_resp.text().await?;
1528
1529 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1530 Ok(())
1531 } else {
1532 let local_var_entity: Option<PostSetPasswordError> =
1533 serde_json::from_str(&local_var_content).ok();
1534 let local_var_error = ResponseContent {
1535 status: local_var_status,
1536 content: local_var_content,
1537 entity: local_var_entity,
1538 };
1539 Err(Error::ResponseError(local_var_error))
1540 }
1541 }
1542
1543 async fn post_storage<'a>(
1544 &self,
1545 storage_request_model: Option<models::StorageRequestModel>,
1546 ) -> Result<models::PaymentResponseModel, Error<PostStorageError>> {
1547 let local_var_configuration = &self.configuration;
1548
1549 let local_var_client = &local_var_configuration.client;
1550
1551 let local_var_uri_str = format!("{}/accounts/storage", local_var_configuration.base_path);
1552 let mut local_var_req_builder =
1553 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1554
1555 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1556 local_var_req_builder = local_var_req_builder
1557 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1558 }
1559 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1560 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1561 };
1562 local_var_req_builder = local_var_req_builder.json(&storage_request_model);
1563
1564 let local_var_req = local_var_req_builder.build()?;
1565 let local_var_resp = local_var_client.execute(local_var_req).await?;
1566
1567 let local_var_status = local_var_resp.status();
1568 let local_var_content_type = local_var_resp
1569 .headers()
1570 .get("content-type")
1571 .and_then(|v| v.to_str().ok())
1572 .unwrap_or("application/octet-stream");
1573 let local_var_content_type = super::ContentType::from(local_var_content_type);
1574 let local_var_content = local_var_resp.text().await?;
1575
1576 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1577 match local_var_content_type {
1578 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1579 ContentType::Text => {
1580 return Err(Error::from(serde_json::Error::custom(
1581 "Received `text/plain` content type response that cannot be converted to `models::PaymentResponseModel`",
1582 )));
1583 }
1584 ContentType::Unsupported(local_var_unknown_type) => {
1585 return Err(Error::from(serde_json::Error::custom(format!(
1586 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::PaymentResponseModel`"
1587 ))));
1588 }
1589 }
1590 } else {
1591 let local_var_entity: Option<PostStorageError> =
1592 serde_json::from_str(&local_var_content).ok();
1593 let local_var_error = ResponseContent {
1594 status: local_var_status,
1595 content: local_var_content,
1596 entity: local_var_entity,
1597 };
1598 Err(Error::ResponseError(local_var_error))
1599 }
1600 }
1601
1602 async fn post_verify_email(&self) -> Result<(), Error<PostVerifyEmailError>> {
1603 let local_var_configuration = &self.configuration;
1604
1605 let local_var_client = &local_var_configuration.client;
1606
1607 let local_var_uri_str = format!(
1608 "{}/accounts/verify-email",
1609 local_var_configuration.base_path
1610 );
1611 let mut local_var_req_builder =
1612 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1613
1614 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1615 local_var_req_builder = local_var_req_builder
1616 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1617 }
1618 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1619 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1620 };
1621
1622 let local_var_req = local_var_req_builder.build()?;
1623 let local_var_resp = local_var_client.execute(local_var_req).await?;
1624
1625 let local_var_status = local_var_resp.status();
1626 let local_var_content = local_var_resp.text().await?;
1627
1628 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1629 Ok(())
1630 } else {
1631 let local_var_entity: Option<PostVerifyEmailError> =
1632 serde_json::from_str(&local_var_content).ok();
1633 let local_var_error = ResponseContent {
1634 status: local_var_status,
1635 content: local_var_content,
1636 entity: local_var_entity,
1637 };
1638 Err(Error::ResponseError(local_var_error))
1639 }
1640 }
1641
1642 async fn post_verify_email_token<'a>(
1643 &self,
1644 verify_email_request_model: Option<models::VerifyEmailRequestModel>,
1645 ) -> Result<(), Error<PostVerifyEmailTokenError>> {
1646 let local_var_configuration = &self.configuration;
1647
1648 let local_var_client = &local_var_configuration.client;
1649
1650 let local_var_uri_str = format!(
1651 "{}/accounts/verify-email-token",
1652 local_var_configuration.base_path
1653 );
1654 let mut local_var_req_builder =
1655 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1656
1657 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1658 local_var_req_builder = local_var_req_builder
1659 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1660 }
1661 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1662 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1663 };
1664 local_var_req_builder = local_var_req_builder.json(&verify_email_request_model);
1665
1666 let local_var_req = local_var_req_builder.build()?;
1667 let local_var_resp = local_var_client.execute(local_var_req).await?;
1668
1669 let local_var_status = local_var_resp.status();
1670 let local_var_content = local_var_resp.text().await?;
1671
1672 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1673 Ok(())
1674 } else {
1675 let local_var_entity: Option<PostVerifyEmailTokenError> =
1676 serde_json::from_str(&local_var_content).ok();
1677 let local_var_error = ResponseContent {
1678 status: local_var_status,
1679 content: local_var_content,
1680 entity: local_var_entity,
1681 };
1682 Err(Error::ResponseError(local_var_error))
1683 }
1684 }
1685
1686 async fn post_verify_password<'a>(
1687 &self,
1688 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
1689 ) -> Result<models::MasterPasswordPolicyResponseModel, Error<PostVerifyPasswordError>> {
1690 let local_var_configuration = &self.configuration;
1691
1692 let local_var_client = &local_var_configuration.client;
1693
1694 let local_var_uri_str = format!(
1695 "{}/accounts/verify-password",
1696 local_var_configuration.base_path
1697 );
1698 let mut local_var_req_builder =
1699 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1700
1701 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1702 local_var_req_builder = local_var_req_builder
1703 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1704 }
1705 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1706 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1707 };
1708 local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
1709
1710 let local_var_req = local_var_req_builder.build()?;
1711 let local_var_resp = local_var_client.execute(local_var_req).await?;
1712
1713 let local_var_status = local_var_resp.status();
1714 let local_var_content_type = local_var_resp
1715 .headers()
1716 .get("content-type")
1717 .and_then(|v| v.to_str().ok())
1718 .unwrap_or("application/octet-stream");
1719 let local_var_content_type = super::ContentType::from(local_var_content_type);
1720 let local_var_content = local_var_resp.text().await?;
1721
1722 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1723 match local_var_content_type {
1724 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1725 ContentType::Text => {
1726 return Err(Error::from(serde_json::Error::custom(
1727 "Received `text/plain` content type response that cannot be converted to `models::MasterPasswordPolicyResponseModel`",
1728 )));
1729 }
1730 ContentType::Unsupported(local_var_unknown_type) => {
1731 return Err(Error::from(serde_json::Error::custom(format!(
1732 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::MasterPasswordPolicyResponseModel`"
1733 ))));
1734 }
1735 }
1736 } else {
1737 let local_var_entity: Option<PostVerifyPasswordError> =
1738 serde_json::from_str(&local_var_content).ok();
1739 let local_var_error = ResponseContent {
1740 status: local_var_status,
1741 content: local_var_content,
1742 entity: local_var_entity,
1743 };
1744 Err(Error::ResponseError(local_var_error))
1745 }
1746 }
1747
1748 async fn put_avatar<'a>(
1749 &self,
1750 update_avatar_request_model: Option<models::UpdateAvatarRequestModel>,
1751 ) -> Result<models::ProfileResponseModel, Error<PutAvatarError>> {
1752 let local_var_configuration = &self.configuration;
1753
1754 let local_var_client = &local_var_configuration.client;
1755
1756 let local_var_uri_str = format!("{}/accounts/avatar", local_var_configuration.base_path);
1757 let mut local_var_req_builder =
1758 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1759
1760 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1761 local_var_req_builder = local_var_req_builder
1762 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1763 }
1764 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1765 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1766 };
1767 local_var_req_builder = local_var_req_builder.json(&update_avatar_request_model);
1768
1769 let local_var_req = local_var_req_builder.build()?;
1770 let local_var_resp = local_var_client.execute(local_var_req).await?;
1771
1772 let local_var_status = local_var_resp.status();
1773 let local_var_content_type = local_var_resp
1774 .headers()
1775 .get("content-type")
1776 .and_then(|v| v.to_str().ok())
1777 .unwrap_or("application/octet-stream");
1778 let local_var_content_type = super::ContentType::from(local_var_content_type);
1779 let local_var_content = local_var_resp.text().await?;
1780
1781 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1782 match local_var_content_type {
1783 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1784 ContentType::Text => {
1785 return Err(Error::from(serde_json::Error::custom(
1786 "Received `text/plain` content type response that cannot be converted to `models::ProfileResponseModel`",
1787 )));
1788 }
1789 ContentType::Unsupported(local_var_unknown_type) => {
1790 return Err(Error::from(serde_json::Error::custom(format!(
1791 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProfileResponseModel`"
1792 ))));
1793 }
1794 }
1795 } else {
1796 let local_var_entity: Option<PutAvatarError> =
1797 serde_json::from_str(&local_var_content).ok();
1798 let local_var_error = ResponseContent {
1799 status: local_var_status,
1800 content: local_var_content,
1801 entity: local_var_entity,
1802 };
1803 Err(Error::ResponseError(local_var_error))
1804 }
1805 }
1806
1807 async fn put_profile<'a>(
1808 &self,
1809 update_profile_request_model: Option<models::UpdateProfileRequestModel>,
1810 ) -> Result<models::ProfileResponseModel, Error<PutProfileError>> {
1811 let local_var_configuration = &self.configuration;
1812
1813 let local_var_client = &local_var_configuration.client;
1814
1815 let local_var_uri_str = format!("{}/accounts/profile", local_var_configuration.base_path);
1816 let mut local_var_req_builder =
1817 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1818
1819 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1820 local_var_req_builder = local_var_req_builder
1821 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1822 }
1823 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1824 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1825 };
1826 local_var_req_builder = local_var_req_builder.json(&update_profile_request_model);
1827
1828 let local_var_req = local_var_req_builder.build()?;
1829 let local_var_resp = local_var_client.execute(local_var_req).await?;
1830
1831 let local_var_status = local_var_resp.status();
1832 let local_var_content_type = local_var_resp
1833 .headers()
1834 .get("content-type")
1835 .and_then(|v| v.to_str().ok())
1836 .unwrap_or("application/octet-stream");
1837 let local_var_content_type = super::ContentType::from(local_var_content_type);
1838 let local_var_content = local_var_resp.text().await?;
1839
1840 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1841 match local_var_content_type {
1842 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1843 ContentType::Text => {
1844 return Err(Error::from(serde_json::Error::custom(
1845 "Received `text/plain` content type response that cannot be converted to `models::ProfileResponseModel`",
1846 )));
1847 }
1848 ContentType::Unsupported(local_var_unknown_type) => {
1849 return Err(Error::from(serde_json::Error::custom(format!(
1850 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProfileResponseModel`"
1851 ))));
1852 }
1853 }
1854 } else {
1855 let local_var_entity: Option<PutProfileError> =
1856 serde_json::from_str(&local_var_content).ok();
1857 let local_var_error = ResponseContent {
1858 status: local_var_status,
1859 content: local_var_content,
1860 entity: local_var_entity,
1861 };
1862 Err(Error::ResponseError(local_var_error))
1863 }
1864 }
1865
1866 async fn put_tax_info<'a>(
1867 &self,
1868 tax_info_update_request_model: Option<models::TaxInfoUpdateRequestModel>,
1869 ) -> Result<(), Error<PutTaxInfoError>> {
1870 let local_var_configuration = &self.configuration;
1871
1872 let local_var_client = &local_var_configuration.client;
1873
1874 let local_var_uri_str = format!("{}/accounts/tax", local_var_configuration.base_path);
1875 let mut local_var_req_builder =
1876 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1877
1878 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1879 local_var_req_builder = local_var_req_builder
1880 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1881 }
1882 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1883 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1884 };
1885 local_var_req_builder = local_var_req_builder.json(&tax_info_update_request_model);
1886
1887 let local_var_req = local_var_req_builder.build()?;
1888 let local_var_resp = local_var_client.execute(local_var_req).await?;
1889
1890 let local_var_status = local_var_resp.status();
1891 let local_var_content = local_var_resp.text().await?;
1892
1893 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1894 Ok(())
1895 } else {
1896 let local_var_entity: Option<PutTaxInfoError> =
1897 serde_json::from_str(&local_var_content).ok();
1898 let local_var_error = ResponseContent {
1899 status: local_var_status,
1900 content: local_var_content,
1901 entity: local_var_entity,
1902 };
1903 Err(Error::ResponseError(local_var_error))
1904 }
1905 }
1906
1907 async fn put_update_tde_password<'a>(
1908 &self,
1909 update_tde_offboarding_password_request_model: Option<
1910 models::UpdateTdeOffboardingPasswordRequestModel,
1911 >,
1912 ) -> Result<(), Error<PutUpdateTdePasswordError>> {
1913 let local_var_configuration = &self.configuration;
1914
1915 let local_var_client = &local_var_configuration.client;
1916
1917 let local_var_uri_str = format!(
1918 "{}/accounts/update-tde-offboarding-password",
1919 local_var_configuration.base_path
1920 );
1921 let mut local_var_req_builder =
1922 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1923
1924 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1925 local_var_req_builder = local_var_req_builder
1926 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1927 }
1928 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1929 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1930 };
1931 local_var_req_builder =
1932 local_var_req_builder.json(&update_tde_offboarding_password_request_model);
1933
1934 let local_var_req = local_var_req_builder.build()?;
1935 let local_var_resp = local_var_client.execute(local_var_req).await?;
1936
1937 let local_var_status = local_var_resp.status();
1938 let local_var_content = local_var_resp.text().await?;
1939
1940 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1941 Ok(())
1942 } else {
1943 let local_var_entity: Option<PutUpdateTdePasswordError> =
1944 serde_json::from_str(&local_var_content).ok();
1945 let local_var_error = ResponseContent {
1946 status: local_var_status,
1947 content: local_var_content,
1948 entity: local_var_entity,
1949 };
1950 Err(Error::ResponseError(local_var_error))
1951 }
1952 }
1953
1954 async fn put_update_temp_password<'a>(
1955 &self,
1956 update_temp_password_request_model: Option<models::UpdateTempPasswordRequestModel>,
1957 ) -> Result<(), Error<PutUpdateTempPasswordError>> {
1958 let local_var_configuration = &self.configuration;
1959
1960 let local_var_client = &local_var_configuration.client;
1961
1962 let local_var_uri_str = format!(
1963 "{}/accounts/update-temp-password",
1964 local_var_configuration.base_path
1965 );
1966 let mut local_var_req_builder =
1967 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1968
1969 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1970 local_var_req_builder = local_var_req_builder
1971 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1972 }
1973 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1974 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1975 };
1976 local_var_req_builder = local_var_req_builder.json(&update_temp_password_request_model);
1977
1978 let local_var_req = local_var_req_builder.build()?;
1979 let local_var_resp = local_var_client.execute(local_var_req).await?;
1980
1981 let local_var_status = local_var_resp.status();
1982 let local_var_content = local_var_resp.text().await?;
1983
1984 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1985 Ok(())
1986 } else {
1987 let local_var_entity: Option<PutUpdateTempPasswordError> =
1988 serde_json::from_str(&local_var_content).ok();
1989 let local_var_error = ResponseContent {
1990 status: local_var_status,
1991 content: local_var_content,
1992 entity: local_var_entity,
1993 };
1994 Err(Error::ResponseError(local_var_error))
1995 }
1996 }
1997
1998 async fn resend_new_device_otp<'a>(
1999 &self,
2000 unauthenticated_secret_verification_request_model: Option<
2001 models::UnauthenticatedSecretVerificationRequestModel,
2002 >,
2003 ) -> Result<(), Error<ResendNewDeviceOtpError>> {
2004 let local_var_configuration = &self.configuration;
2005
2006 let local_var_client = &local_var_configuration.client;
2007
2008 let local_var_uri_str = format!(
2009 "{}/accounts/resend-new-device-otp",
2010 local_var_configuration.base_path
2011 );
2012 let mut local_var_req_builder =
2013 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2014
2015 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2016 local_var_req_builder = local_var_req_builder
2017 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2018 }
2019 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
2020 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2021 };
2022 local_var_req_builder =
2023 local_var_req_builder.json(&unauthenticated_secret_verification_request_model);
2024
2025 let local_var_req = local_var_req_builder.build()?;
2026 let local_var_resp = local_var_client.execute(local_var_req).await?;
2027
2028 let local_var_status = local_var_resp.status();
2029 let local_var_content = local_var_resp.text().await?;
2030
2031 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2032 Ok(())
2033 } else {
2034 let local_var_entity: Option<ResendNewDeviceOtpError> =
2035 serde_json::from_str(&local_var_content).ok();
2036 let local_var_error = ResponseContent {
2037 status: local_var_status,
2038 content: local_var_content,
2039 entity: local_var_entity,
2040 };
2041 Err(Error::ResponseError(local_var_error))
2042 }
2043 }
2044
2045 async fn rotate_api_key<'a>(
2046 &self,
2047 secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
2048 ) -> Result<models::ApiKeyResponseModel, Error<RotateApiKeyError>> {
2049 let local_var_configuration = &self.configuration;
2050
2051 let local_var_client = &local_var_configuration.client;
2052
2053 let local_var_uri_str = format!(
2054 "{}/accounts/rotate-api-key",
2055 local_var_configuration.base_path
2056 );
2057 let mut local_var_req_builder =
2058 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2059
2060 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2061 local_var_req_builder = local_var_req_builder
2062 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2063 }
2064 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
2065 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2066 };
2067 local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
2068
2069 let local_var_req = local_var_req_builder.build()?;
2070 let local_var_resp = local_var_client.execute(local_var_req).await?;
2071
2072 let local_var_status = local_var_resp.status();
2073 let local_var_content_type = local_var_resp
2074 .headers()
2075 .get("content-type")
2076 .and_then(|v| v.to_str().ok())
2077 .unwrap_or("application/octet-stream");
2078 let local_var_content_type = super::ContentType::from(local_var_content_type);
2079 let local_var_content = local_var_resp.text().await?;
2080
2081 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2082 match local_var_content_type {
2083 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
2084 ContentType::Text => {
2085 return Err(Error::from(serde_json::Error::custom(
2086 "Received `text/plain` content type response that cannot be converted to `models::ApiKeyResponseModel`",
2087 )));
2088 }
2089 ContentType::Unsupported(local_var_unknown_type) => {
2090 return Err(Error::from(serde_json::Error::custom(format!(
2091 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ApiKeyResponseModel`"
2092 ))));
2093 }
2094 }
2095 } else {
2096 let local_var_entity: Option<RotateApiKeyError> =
2097 serde_json::from_str(&local_var_content).ok();
2098 let local_var_error = ResponseContent {
2099 status: local_var_status,
2100 content: local_var_content,
2101 entity: local_var_entity,
2102 };
2103 Err(Error::ResponseError(local_var_error))
2104 }
2105 }
2106
2107 async fn set_user_verify_devices<'a>(
2108 &self,
2109 set_verify_devices_request_model: Option<models::SetVerifyDevicesRequestModel>,
2110 ) -> Result<(), Error<SetUserVerifyDevicesError>> {
2111 let local_var_configuration = &self.configuration;
2112
2113 let local_var_client = &local_var_configuration.client;
2114
2115 let local_var_uri_str = format!(
2116 "{}/accounts/verify-devices",
2117 local_var_configuration.base_path
2118 );
2119 let mut local_var_req_builder =
2120 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2121
2122 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2123 local_var_req_builder = local_var_req_builder
2124 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2125 }
2126 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
2127 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2128 };
2129 local_var_req_builder = local_var_req_builder.json(&set_verify_devices_request_model);
2130
2131 let local_var_req = local_var_req_builder.build()?;
2132 let local_var_resp = local_var_client.execute(local_var_req).await?;
2133
2134 let local_var_status = local_var_resp.status();
2135 let local_var_content = local_var_resp.text().await?;
2136
2137 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2138 Ok(())
2139 } else {
2140 let local_var_entity: Option<SetUserVerifyDevicesError> =
2141 serde_json::from_str(&local_var_content).ok();
2142 let local_var_error = ResponseContent {
2143 status: local_var_status,
2144 content: local_var_content,
2145 entity: local_var_entity,
2146 };
2147 Err(Error::ResponseError(local_var_error))
2148 }
2149 }
2150
2151 async fn verify_otp<'a>(
2152 &self,
2153 verify_otp_request_model: Option<models::VerifyOtpRequestModel>,
2154 ) -> Result<(), Error<VerifyOTPError>> {
2155 let local_var_configuration = &self.configuration;
2156
2157 let local_var_client = &local_var_configuration.client;
2158
2159 let local_var_uri_str =
2160 format!("{}/accounts/verify-otp", local_var_configuration.base_path);
2161 let mut local_var_req_builder =
2162 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2163
2164 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2165 local_var_req_builder = local_var_req_builder
2166 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2167 }
2168 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
2169 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2170 };
2171 local_var_req_builder = local_var_req_builder.json(&verify_otp_request_model);
2172
2173 let local_var_req = local_var_req_builder.build()?;
2174 let local_var_resp = local_var_client.execute(local_var_req).await?;
2175
2176 let local_var_status = local_var_resp.status();
2177 let local_var_content = local_var_resp.text().await?;
2178
2179 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2180 Ok(())
2181 } else {
2182 let local_var_entity: Option<VerifyOTPError> =
2183 serde_json::from_str(&local_var_content).ok();
2184 let local_var_error = ResponseContent {
2185 status: local_var_status,
2186 content: local_var_content,
2187 entity: local_var_entity,
2188 };
2189 Err(Error::ResponseError(local_var_error))
2190 }
2191 }
2192}
2193
2194#[derive(Debug, Clone, Serialize, Deserialize)]
2196#[serde(untagged)]
2197pub enum ApiKeyError {
2198 UnknownValue(serde_json::Value),
2199}
2200#[derive(Debug, Clone, Serialize, Deserialize)]
2202#[serde(untagged)]
2203pub enum DeleteError {
2204 UnknownValue(serde_json::Value),
2205}
2206#[derive(Debug, Clone, Serialize, Deserialize)]
2208#[serde(untagged)]
2209pub enum DeleteSsoUserError {
2210 UnknownValue(serde_json::Value),
2211}
2212#[derive(Debug, Clone, Serialize, Deserialize)]
2214#[serde(untagged)]
2215pub enum GetAccountRevisionDateError {
2216 UnknownValue(serde_json::Value),
2217}
2218#[derive(Debug, Clone, Serialize, Deserialize)]
2220#[serde(untagged)]
2221pub enum GetKeysError {
2222 UnknownValue(serde_json::Value),
2223}
2224#[derive(Debug, Clone, Serialize, Deserialize)]
2226#[serde(untagged)]
2227pub enum GetOrganizationsError {
2228 UnknownValue(serde_json::Value),
2229}
2230#[derive(Debug, Clone, Serialize, Deserialize)]
2232#[serde(untagged)]
2233pub enum GetProfileError {
2234 UnknownValue(serde_json::Value),
2235}
2236#[derive(Debug, Clone, Serialize, Deserialize)]
2238#[serde(untagged)]
2239pub enum GetSsoUserIdentifierError {
2240 UnknownValue(serde_json::Value),
2241}
2242#[derive(Debug, Clone, Serialize, Deserialize)]
2244#[serde(untagged)]
2245pub enum GetSubscriptionError {
2246 UnknownValue(serde_json::Value),
2247}
2248#[derive(Debug, Clone, Serialize, Deserialize)]
2250#[serde(untagged)]
2251pub enum GetTaxInfoError {
2252 UnknownValue(serde_json::Value),
2253}
2254#[derive(Debug, Clone, Serialize, Deserialize)]
2256#[serde(untagged)]
2257pub enum PostCancelError {
2258 UnknownValue(serde_json::Value),
2259}
2260#[derive(Debug, Clone, Serialize, Deserialize)]
2262#[serde(untagged)]
2263pub enum PostDeleteRecoverError {
2264 UnknownValue(serde_json::Value),
2265}
2266#[derive(Debug, Clone, Serialize, Deserialize)]
2268#[serde(untagged)]
2269pub enum PostDeleteRecoverTokenError {
2270 UnknownValue(serde_json::Value),
2271}
2272#[derive(Debug, Clone, Serialize, Deserialize)]
2274#[serde(untagged)]
2275pub enum PostEmailError {
2276 UnknownValue(serde_json::Value),
2277}
2278#[derive(Debug, Clone, Serialize, Deserialize)]
2280#[serde(untagged)]
2281pub enum PostEmailTokenError {
2282 UnknownValue(serde_json::Value),
2283}
2284#[derive(Debug, Clone, Serialize, Deserialize)]
2286#[serde(untagged)]
2287pub enum PostKdfError {
2288 UnknownValue(serde_json::Value),
2289}
2290#[derive(Debug, Clone, Serialize, Deserialize)]
2292#[serde(untagged)]
2293pub enum PostKeysError {
2294 UnknownValue(serde_json::Value),
2295}
2296#[derive(Debug, Clone, Serialize, Deserialize)]
2298#[serde(untagged)]
2299pub enum PostLicenseError {
2300 UnknownValue(serde_json::Value),
2301}
2302#[derive(Debug, Clone, Serialize, Deserialize)]
2304#[serde(untagged)]
2305pub enum PostPasswordError {
2306 UnknownValue(serde_json::Value),
2307}
2308#[derive(Debug, Clone, Serialize, Deserialize)]
2310#[serde(untagged)]
2311pub enum PostPasswordHintError {
2312 UnknownValue(serde_json::Value),
2313}
2314#[derive(Debug, Clone, Serialize, Deserialize)]
2316#[serde(untagged)]
2317pub enum PostPaymentError {
2318 UnknownValue(serde_json::Value),
2319}
2320#[derive(Debug, Clone, Serialize, Deserialize)]
2322#[serde(untagged)]
2323pub enum PostPremiumError {
2324 UnknownValue(serde_json::Value),
2325}
2326#[derive(Debug, Clone, Serialize, Deserialize)]
2328#[serde(untagged)]
2329pub enum PostReinstateError {
2330 UnknownValue(serde_json::Value),
2331}
2332#[derive(Debug, Clone, Serialize, Deserialize)]
2334#[serde(untagged)]
2335pub enum PostRequestOTPError {
2336 UnknownValue(serde_json::Value),
2337}
2338#[derive(Debug, Clone, Serialize, Deserialize)]
2340#[serde(untagged)]
2341pub enum PostSecurityStampError {
2342 UnknownValue(serde_json::Value),
2343}
2344#[derive(Debug, Clone, Serialize, Deserialize)]
2346#[serde(untagged)]
2347pub enum PostSetPasswordError {
2348 UnknownValue(serde_json::Value),
2349}
2350#[derive(Debug, Clone, Serialize, Deserialize)]
2352#[serde(untagged)]
2353pub enum PostStorageError {
2354 UnknownValue(serde_json::Value),
2355}
2356#[derive(Debug, Clone, Serialize, Deserialize)]
2358#[serde(untagged)]
2359pub enum PostVerifyEmailError {
2360 UnknownValue(serde_json::Value),
2361}
2362#[derive(Debug, Clone, Serialize, Deserialize)]
2364#[serde(untagged)]
2365pub enum PostVerifyEmailTokenError {
2366 UnknownValue(serde_json::Value),
2367}
2368#[derive(Debug, Clone, Serialize, Deserialize)]
2370#[serde(untagged)]
2371pub enum PostVerifyPasswordError {
2372 UnknownValue(serde_json::Value),
2373}
2374#[derive(Debug, Clone, Serialize, Deserialize)]
2376#[serde(untagged)]
2377pub enum PutAvatarError {
2378 UnknownValue(serde_json::Value),
2379}
2380#[derive(Debug, Clone, Serialize, Deserialize)]
2382#[serde(untagged)]
2383pub enum PutProfileError {
2384 UnknownValue(serde_json::Value),
2385}
2386#[derive(Debug, Clone, Serialize, Deserialize)]
2388#[serde(untagged)]
2389pub enum PutTaxInfoError {
2390 UnknownValue(serde_json::Value),
2391}
2392#[derive(Debug, Clone, Serialize, Deserialize)]
2394#[serde(untagged)]
2395pub enum PutUpdateTdePasswordError {
2396 UnknownValue(serde_json::Value),
2397}
2398#[derive(Debug, Clone, Serialize, Deserialize)]
2400#[serde(untagged)]
2401pub enum PutUpdateTempPasswordError {
2402 UnknownValue(serde_json::Value),
2403}
2404#[derive(Debug, Clone, Serialize, Deserialize)]
2406#[serde(untagged)]
2407pub enum ResendNewDeviceOtpError {
2408 UnknownValue(serde_json::Value),
2409}
2410#[derive(Debug, Clone, Serialize, Deserialize)]
2412#[serde(untagged)]
2413pub enum RotateApiKeyError {
2414 UnknownValue(serde_json::Value),
2415}
2416#[derive(Debug, Clone, Serialize, Deserialize)]
2418#[serde(untagged)]
2419pub enum SetUserVerifyDevicesError {
2420 UnknownValue(serde_json::Value),
2421}
2422#[derive(Debug, Clone, Serialize, Deserialize)]
2424#[serde(untagged)]
2425pub enum VerifyOTPError {
2426 UnknownValue(serde_json::Value),
2427}