bitwarden_api_api/apis/
accounts_api.rs

1/*
2 * Bitwarden Internal API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: latest
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use 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    /// POST /accounts/api-key
30    async fn api_key<'a>(
31        &self,
32        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
33    ) -> Result<models::ApiKeyResponseModel, Error<ApiKeyError>>;
34
35    /// DELETE /accounts
36    async fn delete<'a>(
37        &self,
38        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
39    ) -> Result<(), Error<DeleteError>>;
40
41    /// DELETE /accounts/sso/{organizationId}
42    async fn delete_sso_user<'a>(
43        &self,
44        organization_id: &'a str,
45    ) -> Result<(), Error<DeleteSsoUserError>>;
46
47    /// GET /accounts/revision-date
48    async fn get_account_revision_date(&self) -> Result<i64, Error<GetAccountRevisionDateError>>;
49
50    /// GET /accounts/keys
51    async fn get_keys(&self) -> Result<models::KeysResponseModel, Error<GetKeysError>>;
52
53    /// GET /accounts/organizations
54    async fn get_organizations(
55        &self,
56    ) -> Result<
57        models::ProfileOrganizationResponseModelListResponseModel,
58        Error<GetOrganizationsError>,
59    >;
60
61    /// GET /accounts/profile
62    async fn get_profile(&self) -> Result<models::ProfileResponseModel, Error<GetProfileError>>;
63
64    /// GET /accounts/sso/user-identifier
65    async fn get_sso_user_identifier(&self) -> Result<String, Error<GetSsoUserIdentifierError>>;
66
67    /// GET /accounts/subscription
68    async fn get_subscription(
69        &self,
70    ) -> Result<models::SubscriptionResponseModel, Error<GetSubscriptionError>>;
71
72    /// GET /accounts/tax
73    async fn get_tax_info(&self) -> Result<models::TaxInfoResponseModel, Error<GetTaxInfoError>>;
74
75    /// POST /accounts/cancel
76    async fn post_cancel<'a>(
77        &self,
78        subscription_cancellation_request_model: Option<
79            models::SubscriptionCancellationRequestModel,
80        >,
81    ) -> Result<(), Error<PostCancelError>>;
82
83    /// POST /accounts/delete-recover
84    async fn post_delete_recover<'a>(
85        &self,
86        delete_recover_request_model: Option<models::DeleteRecoverRequestModel>,
87    ) -> Result<(), Error<PostDeleteRecoverError>>;
88
89    /// POST /accounts/delete-recover-token
90    async fn post_delete_recover_token<'a>(
91        &self,
92        verify_delete_recover_request_model: Option<models::VerifyDeleteRecoverRequestModel>,
93    ) -> Result<(), Error<PostDeleteRecoverTokenError>>;
94
95    /// POST /accounts/email
96    async fn post_email<'a>(
97        &self,
98        email_request_model: Option<models::EmailRequestModel>,
99    ) -> Result<(), Error<PostEmailError>>;
100
101    /// POST /accounts/email-token
102    async fn post_email_token<'a>(
103        &self,
104        email_token_request_model: Option<models::EmailTokenRequestModel>,
105    ) -> Result<(), Error<PostEmailTokenError>>;
106
107    /// POST /accounts/kdf
108    async fn post_kdf<'a>(
109        &self,
110        kdf_request_model: Option<models::KdfRequestModel>,
111    ) -> Result<(), Error<PostKdfError>>;
112
113    /// POST /accounts/keys
114    async fn post_keys<'a>(
115        &self,
116        keys_request_model: Option<models::KeysRequestModel>,
117    ) -> Result<models::KeysResponseModel, Error<PostKeysError>>;
118
119    /// POST /accounts/license
120    async fn post_license<'a>(
121        &self,
122        license: std::path::PathBuf,
123    ) -> Result<(), Error<PostLicenseError>>;
124
125    /// POST /accounts/password
126    async fn post_password<'a>(
127        &self,
128        password_request_model: Option<models::PasswordRequestModel>,
129    ) -> Result<(), Error<PostPasswordError>>;
130
131    /// POST /accounts/password-hint
132    async fn post_password_hint<'a>(
133        &self,
134        password_hint_request_model: Option<models::PasswordHintRequestModel>,
135    ) -> Result<(), Error<PostPasswordHintError>>;
136
137    /// POST /accounts/payment
138    async fn post_payment<'a>(
139        &self,
140        payment_request_model: Option<models::PaymentRequestModel>,
141    ) -> Result<(), Error<PostPaymentError>>;
142
143    /// POST /accounts/premium
144    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    /// POST /accounts/reinstate-premium
155    async fn post_reinstate(&self) -> Result<(), Error<PostReinstateError>>;
156
157    /// POST /accounts/request-otp
158    async fn post_request_otp(&self) -> Result<(), Error<PostRequestOTPError>>;
159
160    /// POST /accounts/security-stamp
161    async fn post_security_stamp<'a>(
162        &self,
163        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
164    ) -> Result<(), Error<PostSecurityStampError>>;
165
166    /// POST /accounts/set-password
167    async fn post_set_password<'a>(
168        &self,
169        set_password_request_model: Option<models::SetPasswordRequestModel>,
170    ) -> Result<(), Error<PostSetPasswordError>>;
171
172    /// POST /accounts/storage
173    async fn post_storage<'a>(
174        &self,
175        storage_request_model: Option<models::StorageRequestModel>,
176    ) -> Result<models::PaymentResponseModel, Error<PostStorageError>>;
177
178    /// POST /accounts/verify-email
179    async fn post_verify_email(&self) -> Result<(), Error<PostVerifyEmailError>>;
180
181    /// POST /accounts/verify-email-token
182    async fn post_verify_email_token<'a>(
183        &self,
184        verify_email_request_model: Option<models::VerifyEmailRequestModel>,
185    ) -> Result<(), Error<PostVerifyEmailTokenError>>;
186
187    /// POST /accounts/verify-password
188    async fn post_verify_password<'a>(
189        &self,
190        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
191    ) -> Result<models::MasterPasswordPolicyResponseModel, Error<PostVerifyPasswordError>>;
192
193    /// PUT /accounts/avatar
194    async fn put_avatar<'a>(
195        &self,
196        update_avatar_request_model: Option<models::UpdateAvatarRequestModel>,
197    ) -> Result<models::ProfileResponseModel, Error<PutAvatarError>>;
198
199    /// PUT /accounts/profile
200    async fn put_profile<'a>(
201        &self,
202        update_profile_request_model: Option<models::UpdateProfileRequestModel>,
203    ) -> Result<models::ProfileResponseModel, Error<PutProfileError>>;
204
205    /// PUT /accounts/tax
206    async fn put_tax_info<'a>(
207        &self,
208        tax_info_update_request_model: Option<models::TaxInfoUpdateRequestModel>,
209    ) -> Result<(), Error<PutTaxInfoError>>;
210
211    /// PUT /accounts/update-tde-offboarding-password
212    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    /// PUT /accounts/update-temp-password
220    async fn put_update_temp_password<'a>(
221        &self,
222        update_temp_password_request_model: Option<models::UpdateTempPasswordRequestModel>,
223    ) -> Result<(), Error<PutUpdateTempPasswordError>>;
224
225    /// POST /accounts/resend-new-device-otp
226    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    /// POST /accounts/rotate-api-key
234    async fn rotate_api_key<'a>(
235        &self,
236        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
237    ) -> Result<models::ApiKeyResponseModel, Error<RotateApiKeyError>>;
238
239    /// PUT /accounts/verify-devices
240    async fn set_user_verify_devices<'a>(
241        &self,
242        set_verify_devices_request_model: Option<models::SetVerifyDevicesRequestModel>,
243    ) -> Result<(), Error<SetUserVerifyDevicesError>>;
244
245    /// POST /accounts/verify-otp
246    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        // TODO: support file upload for 'license' parameter
1145        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", &param_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", &param_value.to_string())]);
1319        }
1320        if let Some(ref param_value) = country {
1321            local_var_req_builder =
1322                local_var_req_builder.query(&[("country", &param_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", &param_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        // TODO: support file upload for 'license' parameter
1337        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/// struct for typed errors of method [`AccountsApi::api_key`]
2195#[derive(Debug, Clone, Serialize, Deserialize)]
2196#[serde(untagged)]
2197pub enum ApiKeyError {
2198    UnknownValue(serde_json::Value),
2199}
2200/// struct for typed errors of method [`AccountsApi::delete`]
2201#[derive(Debug, Clone, Serialize, Deserialize)]
2202#[serde(untagged)]
2203pub enum DeleteError {
2204    UnknownValue(serde_json::Value),
2205}
2206/// struct for typed errors of method [`AccountsApi::delete_sso_user`]
2207#[derive(Debug, Clone, Serialize, Deserialize)]
2208#[serde(untagged)]
2209pub enum DeleteSsoUserError {
2210    UnknownValue(serde_json::Value),
2211}
2212/// struct for typed errors of method [`AccountsApi::get_account_revision_date`]
2213#[derive(Debug, Clone, Serialize, Deserialize)]
2214#[serde(untagged)]
2215pub enum GetAccountRevisionDateError {
2216    UnknownValue(serde_json::Value),
2217}
2218/// struct for typed errors of method [`AccountsApi::get_keys`]
2219#[derive(Debug, Clone, Serialize, Deserialize)]
2220#[serde(untagged)]
2221pub enum GetKeysError {
2222    UnknownValue(serde_json::Value),
2223}
2224/// struct for typed errors of method [`AccountsApi::get_organizations`]
2225#[derive(Debug, Clone, Serialize, Deserialize)]
2226#[serde(untagged)]
2227pub enum GetOrganizationsError {
2228    UnknownValue(serde_json::Value),
2229}
2230/// struct for typed errors of method [`AccountsApi::get_profile`]
2231#[derive(Debug, Clone, Serialize, Deserialize)]
2232#[serde(untagged)]
2233pub enum GetProfileError {
2234    UnknownValue(serde_json::Value),
2235}
2236/// struct for typed errors of method [`AccountsApi::get_sso_user_identifier`]
2237#[derive(Debug, Clone, Serialize, Deserialize)]
2238#[serde(untagged)]
2239pub enum GetSsoUserIdentifierError {
2240    UnknownValue(serde_json::Value),
2241}
2242/// struct for typed errors of method [`AccountsApi::get_subscription`]
2243#[derive(Debug, Clone, Serialize, Deserialize)]
2244#[serde(untagged)]
2245pub enum GetSubscriptionError {
2246    UnknownValue(serde_json::Value),
2247}
2248/// struct for typed errors of method [`AccountsApi::get_tax_info`]
2249#[derive(Debug, Clone, Serialize, Deserialize)]
2250#[serde(untagged)]
2251pub enum GetTaxInfoError {
2252    UnknownValue(serde_json::Value),
2253}
2254/// struct for typed errors of method [`AccountsApi::post_cancel`]
2255#[derive(Debug, Clone, Serialize, Deserialize)]
2256#[serde(untagged)]
2257pub enum PostCancelError {
2258    UnknownValue(serde_json::Value),
2259}
2260/// struct for typed errors of method [`AccountsApi::post_delete_recover`]
2261#[derive(Debug, Clone, Serialize, Deserialize)]
2262#[serde(untagged)]
2263pub enum PostDeleteRecoverError {
2264    UnknownValue(serde_json::Value),
2265}
2266/// struct for typed errors of method [`AccountsApi::post_delete_recover_token`]
2267#[derive(Debug, Clone, Serialize, Deserialize)]
2268#[serde(untagged)]
2269pub enum PostDeleteRecoverTokenError {
2270    UnknownValue(serde_json::Value),
2271}
2272/// struct for typed errors of method [`AccountsApi::post_email`]
2273#[derive(Debug, Clone, Serialize, Deserialize)]
2274#[serde(untagged)]
2275pub enum PostEmailError {
2276    UnknownValue(serde_json::Value),
2277}
2278/// struct for typed errors of method [`AccountsApi::post_email_token`]
2279#[derive(Debug, Clone, Serialize, Deserialize)]
2280#[serde(untagged)]
2281pub enum PostEmailTokenError {
2282    UnknownValue(serde_json::Value),
2283}
2284/// struct for typed errors of method [`AccountsApi::post_kdf`]
2285#[derive(Debug, Clone, Serialize, Deserialize)]
2286#[serde(untagged)]
2287pub enum PostKdfError {
2288    UnknownValue(serde_json::Value),
2289}
2290/// struct for typed errors of method [`AccountsApi::post_keys`]
2291#[derive(Debug, Clone, Serialize, Deserialize)]
2292#[serde(untagged)]
2293pub enum PostKeysError {
2294    UnknownValue(serde_json::Value),
2295}
2296/// struct for typed errors of method [`AccountsApi::post_license`]
2297#[derive(Debug, Clone, Serialize, Deserialize)]
2298#[serde(untagged)]
2299pub enum PostLicenseError {
2300    UnknownValue(serde_json::Value),
2301}
2302/// struct for typed errors of method [`AccountsApi::post_password`]
2303#[derive(Debug, Clone, Serialize, Deserialize)]
2304#[serde(untagged)]
2305pub enum PostPasswordError {
2306    UnknownValue(serde_json::Value),
2307}
2308/// struct for typed errors of method [`AccountsApi::post_password_hint`]
2309#[derive(Debug, Clone, Serialize, Deserialize)]
2310#[serde(untagged)]
2311pub enum PostPasswordHintError {
2312    UnknownValue(serde_json::Value),
2313}
2314/// struct for typed errors of method [`AccountsApi::post_payment`]
2315#[derive(Debug, Clone, Serialize, Deserialize)]
2316#[serde(untagged)]
2317pub enum PostPaymentError {
2318    UnknownValue(serde_json::Value),
2319}
2320/// struct for typed errors of method [`AccountsApi::post_premium`]
2321#[derive(Debug, Clone, Serialize, Deserialize)]
2322#[serde(untagged)]
2323pub enum PostPremiumError {
2324    UnknownValue(serde_json::Value),
2325}
2326/// struct for typed errors of method [`AccountsApi::post_reinstate`]
2327#[derive(Debug, Clone, Serialize, Deserialize)]
2328#[serde(untagged)]
2329pub enum PostReinstateError {
2330    UnknownValue(serde_json::Value),
2331}
2332/// struct for typed errors of method [`AccountsApi::post_request_otp`]
2333#[derive(Debug, Clone, Serialize, Deserialize)]
2334#[serde(untagged)]
2335pub enum PostRequestOTPError {
2336    UnknownValue(serde_json::Value),
2337}
2338/// struct for typed errors of method [`AccountsApi::post_security_stamp`]
2339#[derive(Debug, Clone, Serialize, Deserialize)]
2340#[serde(untagged)]
2341pub enum PostSecurityStampError {
2342    UnknownValue(serde_json::Value),
2343}
2344/// struct for typed errors of method [`AccountsApi::post_set_password`]
2345#[derive(Debug, Clone, Serialize, Deserialize)]
2346#[serde(untagged)]
2347pub enum PostSetPasswordError {
2348    UnknownValue(serde_json::Value),
2349}
2350/// struct for typed errors of method [`AccountsApi::post_storage`]
2351#[derive(Debug, Clone, Serialize, Deserialize)]
2352#[serde(untagged)]
2353pub enum PostStorageError {
2354    UnknownValue(serde_json::Value),
2355}
2356/// struct for typed errors of method [`AccountsApi::post_verify_email`]
2357#[derive(Debug, Clone, Serialize, Deserialize)]
2358#[serde(untagged)]
2359pub enum PostVerifyEmailError {
2360    UnknownValue(serde_json::Value),
2361}
2362/// struct for typed errors of method [`AccountsApi::post_verify_email_token`]
2363#[derive(Debug, Clone, Serialize, Deserialize)]
2364#[serde(untagged)]
2365pub enum PostVerifyEmailTokenError {
2366    UnknownValue(serde_json::Value),
2367}
2368/// struct for typed errors of method [`AccountsApi::post_verify_password`]
2369#[derive(Debug, Clone, Serialize, Deserialize)]
2370#[serde(untagged)]
2371pub enum PostVerifyPasswordError {
2372    UnknownValue(serde_json::Value),
2373}
2374/// struct for typed errors of method [`AccountsApi::put_avatar`]
2375#[derive(Debug, Clone, Serialize, Deserialize)]
2376#[serde(untagged)]
2377pub enum PutAvatarError {
2378    UnknownValue(serde_json::Value),
2379}
2380/// struct for typed errors of method [`AccountsApi::put_profile`]
2381#[derive(Debug, Clone, Serialize, Deserialize)]
2382#[serde(untagged)]
2383pub enum PutProfileError {
2384    UnknownValue(serde_json::Value),
2385}
2386/// struct for typed errors of method [`AccountsApi::put_tax_info`]
2387#[derive(Debug, Clone, Serialize, Deserialize)]
2388#[serde(untagged)]
2389pub enum PutTaxInfoError {
2390    UnknownValue(serde_json::Value),
2391}
2392/// struct for typed errors of method [`AccountsApi::put_update_tde_password`]
2393#[derive(Debug, Clone, Serialize, Deserialize)]
2394#[serde(untagged)]
2395pub enum PutUpdateTdePasswordError {
2396    UnknownValue(serde_json::Value),
2397}
2398/// struct for typed errors of method [`AccountsApi::put_update_temp_password`]
2399#[derive(Debug, Clone, Serialize, Deserialize)]
2400#[serde(untagged)]
2401pub enum PutUpdateTempPasswordError {
2402    UnknownValue(serde_json::Value),
2403}
2404/// struct for typed errors of method [`AccountsApi::resend_new_device_otp`]
2405#[derive(Debug, Clone, Serialize, Deserialize)]
2406#[serde(untagged)]
2407pub enum ResendNewDeviceOtpError {
2408    UnknownValue(serde_json::Value),
2409}
2410/// struct for typed errors of method [`AccountsApi::rotate_api_key`]
2411#[derive(Debug, Clone, Serialize, Deserialize)]
2412#[serde(untagged)]
2413pub enum RotateApiKeyError {
2414    UnknownValue(serde_json::Value),
2415}
2416/// struct for typed errors of method [`AccountsApi::set_user_verify_devices`]
2417#[derive(Debug, Clone, Serialize, Deserialize)]
2418#[serde(untagged)]
2419pub enum SetUserVerifyDevicesError {
2420    UnknownValue(serde_json::Value),
2421}
2422/// struct for typed errors of method [`AccountsApi::verify_otp`]
2423#[derive(Debug, Clone, Serialize, Deserialize)]
2424#[serde(untagged)]
2425pub enum VerifyOTPError {
2426    UnknownValue(serde_json::Value),
2427}