bitwarden_api_api/apis/

organization_users_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::{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 OrganizationUsersApi: Send + Sync {
    /// POST /organizations/{orgId}/users/{organizationUserId}/accept
    async fn accept<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_id: uuid::Uuid,
        organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
    ) -> Result<(), Error<AcceptError>>;

    /// POST /organizations/{orgId}/users/{organizationUserId}/accept-init
    async fn accept_init<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_id: uuid::Uuid,
        organization_user_accept_init_request_model: Option<
            models::OrganizationUserAcceptInitRequestModel,
        >,
    ) -> Result<(), Error<AcceptInitError>>;

    /// POST /organizations/{orgId}/users/confirm
    async fn bulk_confirm<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_confirm_request_model: Option<
            models::OrganizationUserBulkConfirmRequestModel,
        >,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkConfirmError>>;

    /// DELETE /organizations/{orgId}/users/delete-account
    async fn bulk_delete_account<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<
        models::OrganizationUserBulkResponseModelListResponseModel,
        Error<BulkDeleteAccountError>,
    >;

    /// PUT /organizations/{orgId}/users/enable-secrets-manager
    async fn bulk_enable_secrets_manager<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<(), Error<BulkEnableSecretsManagerError>>;

    /// POST /organizations/{orgId}/users/reinvite
    async fn bulk_reinvite<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkReinviteError>>;

    /// DELETE /organizations/{orgId}/users
    async fn bulk_remove<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRemoveError>>;

    /// PUT /organizations/{orgId}/users/restore
    async fn bulk_restore<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRestoreError>>;

    /// PUT /organizations/{orgId}/users/revoke
    async fn bulk_revoke<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRevokeError>>;

    /// POST /organizations/{orgId}/users/{id}/confirm
    async fn confirm<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
        organization_user_confirm_request_model: Option<
            models::OrganizationUserConfirmRequestModel,
        >,
    ) -> Result<(), Error<ConfirmError>>;

    /// DELETE /organizations/{orgId}/users/{id}/delete-account
    async fn delete_account<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<DeleteAccountError>>;

    /// GET /organizations/{orgId}/users/{id}
    async fn get<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
        include_groups: Option<bool>,
    ) -> Result<models::OrganizationUserDetailsResponseModel, Error<GetError>>;

    /// POST /organizations/{orgId}/users/account-recovery-details
    async fn get_account_recovery_details<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<
        models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel,
        Error<GetAccountRecoveryDetailsError>,
    >;

    /// GET /organizations/{orgId}/users
    async fn get_all<'a>(
        &self,
        org_id: uuid::Uuid,
        include_groups: Option<bool>,
        include_collections: Option<bool>,
    ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error<GetAllError>>;

    /// GET /organizations/{orgId}/users/mini-details
    async fn get_mini_details<'a>(
        &self,
        org_id: uuid::Uuid,
    ) -> Result<
        models::OrganizationUserUserMiniDetailsResponseModelListResponseModel,
        Error<GetMiniDetailsError>,
    >;

    /// GET /organizations/{orgId}/users/{id}/reset-password-details
    async fn get_reset_password_details<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<
        models::OrganizationUserResetPasswordDetailsResponseModel,
        Error<GetResetPasswordDetailsError>,
    >;

    /// POST /organizations/{orgId}/users/invite
    async fn invite<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
    ) -> Result<(), Error<InviteError>>;

    /// PUT /organizations/{orgId}/users/{id}
    async fn put<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
        organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
    ) -> Result<(), Error<PutError>>;

    /// PUT /organizations/{orgId}/users/{id}/reset-password
    async fn put_reset_password<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
        organization_user_reset_password_request_model: Option<
            models::OrganizationUserResetPasswordRequestModel,
        >,
    ) -> Result<(), Error<PutResetPasswordError>>;

    /// PUT /organizations/{orgId}/users/{userId}/reset-password-enrollment
    async fn put_reset_password_enrollment<'a>(
        &self,
        org_id: uuid::Uuid,
        user_id: uuid::Uuid,
        organization_user_reset_password_enrollment_request_model: Option<
            models::OrganizationUserResetPasswordEnrollmentRequestModel,
        >,
    ) -> Result<(), Error<PutResetPasswordEnrollmentError>>;

    /// POST /organizations/{orgId}/users/{id}/reinvite
    async fn reinvite<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<ReinviteError>>;

    /// DELETE /organizations/{orgId}/users/{id}
    async fn remove<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<RemoveError>>;

    /// PUT /organizations/{orgId}/users/{id}/restore
    async fn restore<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<RestoreError>>;

    /// PUT /organizations/{orgId}/users/{id}/revoke
    async fn revoke<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<RevokeError>>;

    /// POST /organizations/{orgId}/users/public-keys
    async fn user_public_keys<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<
        models::OrganizationUserPublicKeyResponseModelListResponseModel,
        Error<UserPublicKeysError>,
    >;
}

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

impl OrganizationUsersApiClient {
    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 OrganizationUsersApi for OrganizationUsersApiClient {
    async fn accept<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_id: uuid::Uuid,
        organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
    ) -> Result<(), Error<AcceptError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{organizationUserId}/accept",
            local_var_configuration.base_path,
            orgId = org_id,
            organizationUserId = organization_user_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_accept_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<AcceptError> =
                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 accept_init<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_id: uuid::Uuid,
        organization_user_accept_init_request_model: Option<
            models::OrganizationUserAcceptInitRequestModel,
        >,
    ) -> Result<(), Error<AcceptInitError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{organizationUserId}/accept-init",
            local_var_configuration.base_path,
            orgId = org_id,
            organizationUserId = organization_user_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder =
            local_var_req_builder.json(&organization_user_accept_init_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<AcceptInitError> =
                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 bulk_confirm<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_confirm_request_model: Option<
            models::OrganizationUserBulkConfirmRequestModel,
        >,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkConfirmError>>
    {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/confirm",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder =
            local_var_req_builder.json(&organization_user_bulk_confirm_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserBulkResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserBulkResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<BulkConfirmError> =
                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 bulk_delete_account<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<
        models::OrganizationUserBulkResponseModelListResponseModel,
        Error<BulkDeleteAccountError>,
    > {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/delete-account",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserBulkResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserBulkResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<BulkDeleteAccountError> =
                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 bulk_enable_secrets_manager<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<(), Error<BulkEnableSecretsManagerError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/enable-secrets-manager",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<BulkEnableSecretsManagerError> =
                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 bulk_reinvite<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkReinviteError>>
    {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/reinvite",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserBulkResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserBulkResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<BulkReinviteError> =
                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 bulk_remove<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRemoveError>>
    {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

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

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserBulkResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserBulkResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<BulkRemoveError> =
                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 bulk_restore<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRestoreError>>
    {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/restore",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserBulkResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserBulkResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<BulkRestoreError> =
                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 bulk_revoke<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRevokeError>>
    {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/revoke",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserBulkResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserBulkResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<BulkRevokeError> =
                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 confirm<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
        organization_user_confirm_request_model: Option<
            models::OrganizationUserConfirmRequestModel,
        >,
    ) -> Result<(), Error<ConfirmError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{id}/confirm",
            local_var_configuration.base_path,
            orgId = org_id,
            id = id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder =
            local_var_req_builder.json(&organization_user_confirm_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<ConfirmError> =
                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_account<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<DeleteAccountError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{id}/delete-account",
            local_var_configuration.base_path,
            orgId = org_id,
            id = id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<DeleteAccountError> =
                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<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
        include_groups: Option<bool>,
    ) -> Result<models::OrganizationUserDetailsResponseModel, Error<GetError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

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

        if let Some(ref param_value) = include_groups {
            local_var_req_builder =
                local_var_req_builder.query(&[("includeGroups", &param_value.to_string())]);
        }
        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserDetailsResponseModel`",
                    )));
                }
                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::OrganizationUserDetailsResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetError> = 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_recovery_details<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<
        models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel,
        Error<GetAccountRecoveryDetailsError>,
    > {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/account-recovery-details",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserResetPasswordDetailsResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserResetPasswordDetailsResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetAccountRecoveryDetailsError> =
                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_all<'a>(
        &self,
        org_id: uuid::Uuid,
        include_groups: Option<bool>,
        include_collections: Option<bool>,
    ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error<GetAllError>>
    {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

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

        if let Some(ref param_value) = include_groups {
            local_var_req_builder =
                local_var_req_builder.query(&[("includeGroups", &param_value.to_string())]);
        }
        if let Some(ref param_value) = include_collections {
            local_var_req_builder =
                local_var_req_builder.query(&[("includeCollections", &param_value.to_string())]);
        }
        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserUserDetailsResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserUserDetailsResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetAllError> =
                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_mini_details<'a>(
        &self,
        org_id: uuid::Uuid,
    ) -> Result<
        models::OrganizationUserUserMiniDetailsResponseModelListResponseModel,
        Error<GetMiniDetailsError>,
    > {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/mini-details",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserUserMiniDetailsResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserUserMiniDetailsResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetMiniDetailsError> =
                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_reset_password_details<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<
        models::OrganizationUserResetPasswordDetailsResponseModel,
        Error<GetResetPasswordDetailsError>,
    > {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{id}/reset-password-details",
            local_var_configuration.base_path,
            orgId = org_id,
            id = id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserResetPasswordDetailsResponseModel`",
                    )));
                }
                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::OrganizationUserResetPasswordDetailsResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetResetPasswordDetailsError> =
                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 invite<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
    ) -> Result<(), Error<InviteError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/invite",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_invite_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<InviteError> =
                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<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
        organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
    ) -> Result<(), Error<PutError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{id}",
            local_var_configuration.base_path,
            orgId = org_id,
            id = id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_update_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<PutError> = 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_reset_password<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
        organization_user_reset_password_request_model: Option<
            models::OrganizationUserResetPasswordRequestModel,
        >,
    ) -> Result<(), Error<PutResetPasswordError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{id}/reset-password",
            local_var_configuration.base_path,
            orgId = org_id,
            id = id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder =
            local_var_req_builder.json(&organization_user_reset_password_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<PutResetPasswordError> =
                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_reset_password_enrollment<'a>(
        &self,
        org_id: uuid::Uuid,
        user_id: uuid::Uuid,
        organization_user_reset_password_enrollment_request_model: Option<
            models::OrganizationUserResetPasswordEnrollmentRequestModel,
        >,
    ) -> Result<(), Error<PutResetPasswordEnrollmentError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{userId}/reset-password-enrollment",
            local_var_configuration.base_path,
            orgId = org_id,
            userId = user_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder =
            local_var_req_builder.json(&organization_user_reset_password_enrollment_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<PutResetPasswordEnrollmentError> =
                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 reinvite<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<ReinviteError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{id}/reinvite",
            local_var_configuration.base_path,
            orgId = org_id,
            id = id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<ReinviteError> =
                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 remove<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<RemoveError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

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

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<RemoveError> =
                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 restore<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<RestoreError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{id}/restore",
            local_var_configuration.base_path,
            orgId = org_id,
            id = id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<RestoreError> =
                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 revoke<'a>(
        &self,
        org_id: uuid::Uuid,
        id: uuid::Uuid,
    ) -> Result<(), Error<RevokeError>> {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/{id}/revoke",
            local_var_configuration.base_path,
            orgId = org_id,
            id = id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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<RevokeError> =
                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 user_public_keys<'a>(
        &self,
        org_id: uuid::Uuid,
        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
    ) -> Result<
        models::OrganizationUserPublicKeyResponseModelListResponseModel,
        Error<UserPublicKeysError>,
    > {
        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/organizations/{orgId}/users/public-keys",
            local_var_configuration.base_path,
            orgId = org_id
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
        };
        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).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::OrganizationUserPublicKeyResponseModelListResponseModel`",
                    )));
                }
                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::OrganizationUserPublicKeyResponseModelListResponseModel`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<UserPublicKeysError> =
                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 [`OrganizationUsersApi::accept`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AcceptError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::accept_init`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AcceptInitError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::bulk_confirm`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BulkConfirmError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::bulk_delete_account`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BulkDeleteAccountError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::bulk_enable_secrets_manager`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BulkEnableSecretsManagerError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::bulk_reinvite`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BulkReinviteError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::bulk_remove`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BulkRemoveError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::bulk_restore`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BulkRestoreError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::bulk_revoke`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BulkRevokeError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::confirm`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConfirmError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::delete_account`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteAccountError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::get_account_recovery_details`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAccountRecoveryDetailsError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::get_all`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAllError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::get_mini_details`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetMiniDetailsError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::get_reset_password_details`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetResetPasswordDetailsError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::invite`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InviteError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::put`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PutError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::put_reset_password`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PutResetPasswordError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::put_reset_password_enrollment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PutResetPasswordEnrollmentError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::reinvite`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReinviteError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::remove`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::restore`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RestoreError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::revoke`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RevokeError {
    UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`OrganizationUsersApi::user_public_keys`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UserPublicKeysError {
    UnknownValue(serde_json::Value),
}