bitwarden_api_api/apis/

accounts_api.rs

/*
 * Bitwarden Internal API
 *
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: latest
 *
 * Generated by: https://openapi-generator.tech
 */

use std::sync::Arc;

use async_trait::async_trait;
#[cfg(feature = "mockall")]
use mockall::automock;
use reqwest;
use serde::{Deserialize, Serialize, de::Error as _};

use super::{Error, configuration};
use crate::{
    apis::{AuthRequired, ContentType, ResponseContent},
    models,
};

#[cfg_attr(feature = "mockall", automock)]
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
pub trait AccountsApi: Send + Sync {
    /// POST /accounts/api-key
    async fn api_key<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<models::ApiKeyResponseModel, Error<ApiKeyError>>;

    /// DELETE /accounts
    async fn delete<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<(), Error<DeleteError>>;

    /// DELETE /accounts/sso/{organizationId}
    async fn delete_sso_user<'a>(
        &self,
        organization_id: &'a str,
    ) -> Result<(), Error<DeleteSsoUserError>>;

    /// GET /accounts/revision-date
    async fn get_account_revision_date(&self) -> Result<i64, Error<GetAccountRevisionDateError>>;

    /// GET /accounts/keys
    async fn get_keys(&self) -> Result<models::KeysResponseModel, Error<GetKeysError>>;

    /// GET /accounts/organizations
    async fn get_organizations(
        &self,
    ) -> Result<
        models::ProfileOrganizationResponseModelListResponseModel,
        Error<GetOrganizationsError>,
    >;

    /// GET /accounts/profile
    async fn get_profile(&self) -> Result<models::ProfileResponseModel, Error<GetProfileError>>;

    /// GET /accounts/sso/user-identifier
    async fn get_sso_user_identifier(&self) -> Result<String, Error<GetSsoUserIdentifierError>>;

    /// GET /accounts/subscription
    async fn get_subscription(
        &self,
    ) -> Result<models::SubscriptionResponseModel, Error<GetSubscriptionError>>;

    /// POST /accounts/cancel
    async fn post_cancel<'a>(
        &self,
        subscription_cancellation_request_model: Option<
            models::SubscriptionCancellationRequestModel,
        >,
    ) -> Result<(), Error<PostCancelError>>;

    /// POST /accounts/delete-recover
    async fn post_delete_recover<'a>(
        &self,
        delete_recover_request_model: Option<models::DeleteRecoverRequestModel>,
    ) -> Result<(), Error<PostDeleteRecoverError>>;

    /// POST /accounts/delete-recover-token
    async fn post_delete_recover_token<'a>(
        &self,
        verify_delete_recover_request_model: Option<models::VerifyDeleteRecoverRequestModel>,
    ) -> Result<(), Error<PostDeleteRecoverTokenError>>;

    /// POST /accounts/email
    async fn post_email<'a>(
        &self,
        email_request_model: Option<models::EmailRequestModel>,
    ) -> Result<(), Error<PostEmailError>>;

    /// POST /accounts/email-token
    async fn post_email_token<'a>(
        &self,
        email_token_request_model: Option<models::EmailTokenRequestModel>,
    ) -> Result<(), Error<PostEmailTokenError>>;

    /// POST /accounts/kdf
    async fn post_kdf<'a>(
        &self,
        password_request_model: Option<models::PasswordRequestModel>,
    ) -> Result<(), Error<PostKdfError>>;

    /// POST /accounts/keys
    async fn post_keys<'a>(
        &self,
        keys_request_model: Option<models::KeysRequestModel>,
    ) -> Result<models::KeysResponseModel, Error<PostKeysError>>;

    /// POST /accounts/license
    async fn post_license<'a>(
        &self,
        license: std::path::PathBuf,
    ) -> Result<(), Error<PostLicenseError>>;

    /// POST /accounts/password
    async fn post_password<'a>(
        &self,
        password_request_model: Option<models::PasswordRequestModel>,
    ) -> Result<(), Error<PostPasswordError>>;

    /// POST /accounts/password-hint
    async fn post_password_hint<'a>(
        &self,
        password_hint_request_model: Option<models::PasswordHintRequestModel>,
    ) -> Result<(), Error<PostPasswordHintError>>;

    /// POST /accounts/reinstate-premium
    async fn post_reinstate(&self) -> Result<(), Error<PostReinstateError>>;

    /// POST /accounts/request-otp
    async fn post_request_otp(&self) -> Result<(), Error<PostRequestOTPError>>;

    /// POST /accounts/security-stamp
    async fn post_security_stamp<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<(), Error<PostSecurityStampError>>;

    /// POST /accounts/set-password
    async fn post_set_password<'a>(
        &self,
        set_initial_password_request_model: Option<models::SetInitialPasswordRequestModel>,
    ) -> Result<(), Error<PostSetPasswordError>>;

    /// POST /accounts/storage
    async fn post_storage<'a>(
        &self,
        storage_request_model: Option<models::StorageRequestModel>,
    ) -> Result<models::PaymentResponseModel, Error<PostStorageError>>;

    /// POST /accounts/verify-email
    async fn post_verify_email(&self) -> Result<(), Error<PostVerifyEmailError>>;

    /// POST /accounts/verify-email-token
    async fn post_verify_email_token<'a>(
        &self,
        verify_email_request_model: Option<models::VerifyEmailRequestModel>,
    ) -> Result<(), Error<PostVerifyEmailTokenError>>;

    /// POST /accounts/verify-password
    async fn post_verify_password<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<models::MasterPasswordPolicyResponseModel, Error<PostVerifyPasswordError>>;

    /// PUT /accounts/avatar
    async fn put_avatar<'a>(
        &self,
        update_avatar_request_model: Option<models::UpdateAvatarRequestModel>,
    ) -> Result<models::ProfileResponseModel, Error<PutAvatarError>>;

    /// PUT /accounts/profile
    async fn put_profile<'a>(
        &self,
        update_profile_request_model: Option<models::UpdateProfileRequestModel>,
    ) -> Result<models::ProfileResponseModel, Error<PutProfileError>>;

    /// PUT /accounts/update-tde-offboarding-password
    async fn put_update_tde_password<'a>(
        &self,
        update_tde_offboarding_password_request_model: Option<
            models::UpdateTdeOffboardingPasswordRequestModel,
        >,
    ) -> Result<(), Error<PutUpdateTdePasswordError>>;

    /// PUT /accounts/update-temp-password
    async fn put_update_temp_password<'a>(
        &self,
        update_temp_password_request_model: Option<models::UpdateTempPasswordRequestModel>,
    ) -> Result<(), Error<PutUpdateTempPasswordError>>;

    /// POST /accounts/resend-new-device-otp
    async fn resend_new_device_otp<'a>(
        &self,
        unauthenticated_secret_verification_request_model: Option<
            models::UnauthenticatedSecretVerificationRequestModel,
        >,
    ) -> Result<(), Error<ResendNewDeviceOtpError>>;

    /// POST /accounts/rotate-api-key
    async fn rotate_api_key<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<models::ApiKeyResponseModel, Error<RotateApiKeyError>>;

    /// PUT /accounts/verify-devices
    async fn set_user_verify_devices<'a>(
        &self,
        set_verify_devices_request_model: Option<models::SetVerifyDevicesRequestModel>,
    ) -> Result<(), Error<SetUserVerifyDevicesError>>;

    /// POST /accounts/verify-otp
    async fn verify_otp<'a>(
        &self,
        verify_otp_request_model: Option<models::VerifyOtpRequestModel>,
    ) -> Result<(), Error<VerifyOTPError>>;
}

pub struct AccountsApiClient {
    configuration: Arc<configuration::Configuration>,
}

impl AccountsApiClient {
    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
        Self { configuration }
    }
}

#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
impl AccountsApi for AccountsApiClient {
    async fn api_key<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<models::ApiKeyResponseModel, Error<ApiKeyError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/api-key", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::ApiKeyResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ApiKeyResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<ApiKeyError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn delete<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<(), Error<DeleteError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<DeleteError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn delete_sso_user<'a>(
        &self,
        organization_id: &'a str,
    ) -> Result<(), Error<DeleteSsoUserError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/sso/{organizationId}",
            local_var_configuration.base_path,
            organizationId = crate::apis::urlencode(organization_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<DeleteSsoUserError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn get_account_revision_date(&self) -> Result<i64, Error<GetAccountRevisionDateError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/revision-date",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `i64`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `i64`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetAccountRevisionDateError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn get_keys(&self) -> Result<models::KeysResponseModel, Error<GetKeysError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/keys", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::KeysResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::KeysResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetKeysError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn get_organizations(
        &self,
    ) -> Result<
        models::ProfileOrganizationResponseModelListResponseModel,
        Error<GetOrganizationsError>,
    > {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/organizations",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::ProfileOrganizationResponseModelListResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProfileOrganizationResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetOrganizationsError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn get_profile(&self) -> Result<models::ProfileResponseModel, Error<GetProfileError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/profile", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::ProfileResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProfileResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetProfileError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn get_sso_user_identifier(&self) -> Result<String, Error<GetSsoUserIdentifierError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/sso/user-identifier",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => return Ok(local_var_content),
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `String`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetSsoUserIdentifierError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn get_subscription(
        &self,
    ) -> Result<models::SubscriptionResponseModel, Error<GetSubscriptionError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/subscription",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::SubscriptionResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::SubscriptionResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetSubscriptionError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_cancel<'a>(
        &self,
        subscription_cancellation_request_model: Option<
            models::SubscriptionCancellationRequestModel,
        >,
    ) -> Result<(), Error<PostCancelError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/cancel", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder =
            local_var_req_builder.json(&subscription_cancellation_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostCancelError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_delete_recover<'a>(
        &self,
        delete_recover_request_model: Option<models::DeleteRecoverRequestModel>,
    ) -> Result<(), Error<PostDeleteRecoverError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/delete-recover",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&delete_recover_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostDeleteRecoverError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_delete_recover_token<'a>(
        &self,
        verify_delete_recover_request_model: Option<models::VerifyDeleteRecoverRequestModel>,
    ) -> Result<(), Error<PostDeleteRecoverTokenError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/delete-recover-token",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&verify_delete_recover_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostDeleteRecoverTokenError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_email<'a>(
        &self,
        email_request_model: Option<models::EmailRequestModel>,
    ) -> Result<(), Error<PostEmailError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/email", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&email_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostEmailError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_email_token<'a>(
        &self,
        email_token_request_model: Option<models::EmailTokenRequestModel>,
    ) -> Result<(), Error<PostEmailTokenError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str =
            format!("{}/accounts/email-token", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&email_token_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostEmailTokenError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_kdf<'a>(
        &self,
        password_request_model: Option<models::PasswordRequestModel>,
    ) -> Result<(), Error<PostKdfError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/kdf", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&password_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostKdfError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_keys<'a>(
        &self,
        keys_request_model: Option<models::KeysRequestModel>,
    ) -> Result<models::KeysResponseModel, Error<PostKeysError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/keys", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&keys_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::KeysResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::KeysResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<PostKeysError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_license<'a>(
        &self,
        license: std::path::PathBuf,
    ) -> Result<(), Error<PostLicenseError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/license", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        let mut local_var_form = reqwest::multipart::Form::new();
        // TODO: support file upload for 'license' parameter
        local_var_req_builder = local_var_req_builder.multipart(local_var_form);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostLicenseError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_password<'a>(
        &self,
        password_request_model: Option<models::PasswordRequestModel>,
    ) -> Result<(), Error<PostPasswordError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/password", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&password_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostPasswordError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_password_hint<'a>(
        &self,
        password_hint_request_model: Option<models::PasswordHintRequestModel>,
    ) -> Result<(), Error<PostPasswordHintError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/password-hint",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&password_hint_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostPasswordHintError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_reinstate(&self) -> Result<(), Error<PostReinstateError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/reinstate-premium",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostReinstateError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_request_otp(&self) -> Result<(), Error<PostRequestOTPError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str =
            format!("{}/accounts/request-otp", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostRequestOTPError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_security_stamp<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<(), Error<PostSecurityStampError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/security-stamp",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostSecurityStampError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_set_password<'a>(
        &self,
        set_initial_password_request_model: Option<models::SetInitialPasswordRequestModel>,
    ) -> Result<(), Error<PostSetPasswordError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/set-password",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&set_initial_password_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostSetPasswordError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_storage<'a>(
        &self,
        storage_request_model: Option<models::StorageRequestModel>,
    ) -> Result<models::PaymentResponseModel, Error<PostStorageError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/storage", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&storage_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::PaymentResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::PaymentResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<PostStorageError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_verify_email(&self) -> Result<(), Error<PostVerifyEmailError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/verify-email",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostVerifyEmailError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_verify_email_token<'a>(
        &self,
        verify_email_request_model: Option<models::VerifyEmailRequestModel>,
    ) -> Result<(), Error<PostVerifyEmailTokenError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/verify-email-token",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&verify_email_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PostVerifyEmailTokenError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn post_verify_password<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<models::MasterPasswordPolicyResponseModel, Error<PostVerifyPasswordError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/verify-password",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::MasterPasswordPolicyResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::MasterPasswordPolicyResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<PostVerifyPasswordError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn put_avatar<'a>(
        &self,
        update_avatar_request_model: Option<models::UpdateAvatarRequestModel>,
    ) -> Result<models::ProfileResponseModel, Error<PutAvatarError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/avatar", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&update_avatar_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::ProfileResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProfileResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<PutAvatarError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn put_profile<'a>(
        &self,
        update_profile_request_model: Option<models::UpdateProfileRequestModel>,
    ) -> Result<models::ProfileResponseModel, Error<PutProfileError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/accounts/profile", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&update_profile_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::ProfileResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProfileResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<PutProfileError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn put_update_tde_password<'a>(
        &self,
        update_tde_offboarding_password_request_model: Option<
            models::UpdateTdeOffboardingPasswordRequestModel,
        >,
    ) -> Result<(), Error<PutUpdateTdePasswordError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/update-tde-offboarding-password",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder =
            local_var_req_builder.json(&update_tde_offboarding_password_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PutUpdateTdePasswordError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn put_update_temp_password<'a>(
        &self,
        update_temp_password_request_model: Option<models::UpdateTempPasswordRequestModel>,
    ) -> Result<(), Error<PutUpdateTempPasswordError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/update-temp-password",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&update_temp_password_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<PutUpdateTempPasswordError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn resend_new_device_otp<'a>(
        &self,
        unauthenticated_secret_verification_request_model: Option<
            models::UnauthenticatedSecretVerificationRequestModel,
        >,
    ) -> Result<(), Error<ResendNewDeviceOtpError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/resend-new-device-otp",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder =
            local_var_req_builder.json(&unauthenticated_secret_verification_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<ResendNewDeviceOtpError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn rotate_api_key<'a>(
        &self,
        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
    ) -> Result<models::ApiKeyResponseModel, Error<RotateApiKeyError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/rotate-api-key",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to `models::ApiKeyResponseModel`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ApiKeyResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<RotateApiKeyError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn set_user_verify_devices<'a>(
        &self,
        set_verify_devices_request_model: Option<models::SetVerifyDevicesRequestModel>,
    ) -> Result<(), Error<SetUserVerifyDevicesError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/accounts/verify-devices",
            local_var_configuration.base_path
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&set_verify_devices_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<SetUserVerifyDevicesError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    async fn verify_otp<'a>(
        &self,
        verify_otp_request_model: Option<models::VerifyOtpRequestModel>,
    ) -> Result<(), Error<VerifyOTPError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str =
            format!("{}/accounts/verify-otp", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
        local_var_req_builder = local_var_req_builder.json(&verify_otp_request_model);

        let local_var_resp = local_var_req_builder.send().await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<VerifyOTPError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }
}

/// struct for typed errors of method [`AccountsApi::api_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ApiKeyError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::delete_sso_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteSsoUserError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::get_account_revision_date`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAccountRevisionDateError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::get_keys`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetKeysError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::get_organizations`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetOrganizationsError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::get_profile`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetProfileError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::get_sso_user_identifier`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSsoUserIdentifierError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::get_subscription`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSubscriptionError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_cancel`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostCancelError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_delete_recover`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostDeleteRecoverError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_delete_recover_token`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostDeleteRecoverTokenError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_email`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostEmailError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_email_token`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostEmailTokenError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_kdf`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostKdfError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_keys`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostKeysError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_license`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostLicenseError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_password`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostPasswordError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_password_hint`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostPasswordHintError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_reinstate`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostReinstateError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_request_otp`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostRequestOTPError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_security_stamp`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostSecurityStampError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_set_password`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostSetPasswordError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_storage`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostStorageError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_verify_email`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostVerifyEmailError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_verify_email_token`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostVerifyEmailTokenError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::post_verify_password`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostVerifyPasswordError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::put_avatar`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PutAvatarError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::put_profile`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PutProfileError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::put_update_tde_password`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PutUpdateTdePasswordError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::put_update_temp_password`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PutUpdateTempPasswordError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::resend_new_device_otp`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ResendNewDeviceOtpError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::rotate_api_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RotateApiKeyError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::set_user_verify_devices`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SetUserVerifyDevicesError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`AccountsApi::verify_otp`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum VerifyOTPError {
    UnknownValue(serde_json::Value),
}