antimatter_api 2.0.13

/*
 * Antimatter Public API
 *
 * Interact with the Antimatter Cloud API
 *
 * The version of the OpenAPI document: 2.0.13
 * Contact: support@antimatter.io
 * Generated by: https://openapi-generator.tech
 */


use reqwest;
use serde::{Deserialize, Serialize};
use crate::{apis::ResponseContent, models};
use super::{Error, configuration};


/// struct for typed errors of method [`domain_add_external_root_encryption_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainAddExternalRootEncryptionKeyError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_delete_external_root_encryption_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainDeleteExternalRootEncryptionKeyError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_external_root_encryption_key_test`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainExternalRootEncryptionKeyTestError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_flush_encryption_keys`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainFlushEncryptionKeysError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_get_active_external_root_encryption_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainGetActiveExternalRootEncryptionKeyError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_get_encryption_settings`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainGetEncryptionSettingsError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_get_external_root_encryption_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainGetExternalRootEncryptionKeyError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_get_external_root_encryption_key_providers`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainGetExternalRootEncryptionKeyProvidersError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_list_external_root_encryption_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainListExternalRootEncryptionKeyError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_put_encryption_settings`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainPutEncryptionSettingsError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_rotate_root_encryption_keys`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainRotateRootEncryptionKeysError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`domain_set_active_external_root_encryption_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DomainSetActiveExternalRootEncryptionKeyError {
    Status400(models::InvalidRequestError),
    Status401(models::UnauthorizedError),
    Status404(models::ResourceNotFoundError),
    Status409(models::ConflictError),
    Status412(models::PreconditionFailedError),
    Status429(models::ResourceExhaustedError),
    DefaultResponse(models::Error),
    UnknownValue(serde_json::Value),
}


/// Add a new external root encryption key with its supporting access configuration. 
pub async fn domain_add_external_root_encryption_key(configuration: &configuration::Configuration, domain_id: &str, key_infos: models::KeyInfos) -> Result<models::RootEncryptionKeyIdResponse, Error<DomainAddExternalRootEncryptionKeyError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/keys", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_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.bearer_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(&key_infos);

    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() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DomainAddExternalRootEncryptionKeyError> = 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))
    }
}

/// Delete an external root encryption key using its ID. This operation is only successful if the external root encryption key is not in use by any key encryption keys. Call the rotate endpoint to ensure that all KEKs have been migrated to the active REK. 
pub async fn domain_delete_external_root_encryption_key(configuration: &configuration::Configuration, domain_id: &str, root_encryption_key_id: &str) -> Result<(), Error<DomainDeleteExternalRootEncryptionKeyError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/keys/{rootEncryptionKeyID}", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_id), rootEncryptionKeyID=crate::apis::urlencode(root_encryption_key_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.bearer_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<DomainDeleteExternalRootEncryptionKeyError> = 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))
    }
}

/// Attempts to use a root encryption key to encrypt and decrypt, validating its availability 
pub async fn domain_external_root_encryption_key_test(configuration: &configuration::Configuration, domain_id: &str, root_encryption_key_id: &str, body: serde_json::Value) -> Result<models::RootEncryptionKeyTestResponse, Error<DomainExternalRootEncryptionKeyTestError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/keys/{rootEncryptionKeyID}/test", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_id), rootEncryptionKeyID=crate::apis::urlencode(root_encryption_key_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.bearer_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(&body);

    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() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DomainExternalRootEncryptionKeyTestError> = 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))
    }
}

/// Flush all keys in memory. The keys will be immediately reloaded from persistent storage, forcing a check that the domain's root key is still available 
pub async fn domain_flush_encryption_keys(configuration: &configuration::Configuration, domain_id: &str, body: Option<serde_json::Value>) -> Result<(), Error<DomainFlushEncryptionKeysError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/flush", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_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.bearer_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(&body);

    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<DomainFlushEncryptionKeysError> = 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))
    }
}

/// Return the details about the current active root encryption key used by the domain. 
pub async fn domain_get_active_external_root_encryption_key(configuration: &configuration::Configuration, domain_id: &str) -> Result<models::RootEncryptionKeyItem, Error<DomainGetActiveExternalRootEncryptionKeyError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/active-key", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_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.bearer_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() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DomainGetActiveExternalRootEncryptionKeyError> = 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))
    }
}

/// Returns the current value of each encryption-related setting for the domain. 
pub async fn domain_get_encryption_settings(configuration: &configuration::Configuration, domain_id: &str) -> Result<models::EncryptionSettings, Error<DomainGetEncryptionSettingsError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/settings", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_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.bearer_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() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DomainGetEncryptionSettingsError> = 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))
    }
}

/// Get an external root encryption key using its ID. This operation is only successful if the external root encryption key exists, and the requesting domain has permissions to view the key. 
pub async fn domain_get_external_root_encryption_key(configuration: &configuration::Configuration, domain_id: &str, root_encryption_key_id: &str) -> Result<models::RootEncryptionKeyItem, Error<DomainGetExternalRootEncryptionKeyError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/keys/{rootEncryptionKeyID}", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_id), rootEncryptionKeyID=crate::apis::urlencode(root_encryption_key_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.bearer_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() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DomainGetExternalRootEncryptionKeyError> = 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))
    }
}

/// Returns a list of available root encryption key providers, along with their description and, if relevant, any additional information required to use them (e.g. for the delegated key provider `aws_am` the AWS account number to delegate to is returned). 
pub async fn domain_get_external_root_encryption_key_providers(configuration: &configuration::Configuration, domain_id: &str) -> Result<models::AvailableRootEncryptionKeyProviders, Error<DomainGetExternalRootEncryptionKeyProvidersError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/providers", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_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.bearer_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() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DomainGetExternalRootEncryptionKeyProvidersError> = 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))
    }
}

/// List all external root encryption keys for the domain. 
pub async fn domain_list_external_root_encryption_key(configuration: &configuration::Configuration, domain_id: &str) -> Result<models::RootEncryptionKeyListResponse, Error<DomainListExternalRootEncryptionKeyError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/keys", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_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.bearer_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() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DomainListExternalRootEncryptionKeyError> = 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))
    }
}

/// Updates encryption settings for the domain. 
pub async fn domain_put_encryption_settings(configuration: &configuration::Configuration, domain_id: &str, encryption_settings: models::EncryptionSettings) -> Result<(), Error<DomainPutEncryptionSettingsError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/settings", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_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.bearer_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(&encryption_settings);

    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<DomainPutEncryptionSettingsError> = 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))
    }
}

/// Collects key encryption keys not encrypted with the current active root encryption key, decrypts them with their original root encryption key, and then encrypts them with the active root encryption key. This is a batched operation and only 100 keys will be processed in a single call. In the response, \"has_more\" will be true if there are more KEKs that can be rotated. Usually the caller will call this endpoint in a loop until has_more is false. 
pub async fn domain_rotate_root_encryption_keys(configuration: &configuration::Configuration, domain_id: &str, body: serde_json::Value) -> Result<models::RotateKeyEncryptionKeyResponse, Error<DomainRotateRootEncryptionKeysError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/rotate", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_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.bearer_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(&body);

    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() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DomainRotateRootEncryptionKeysError> = 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))
    }
}

/// This will set which root encryption is active: i.e. is used for new capsules, or is used to encrypt KEKs when `rotate` is called. 
pub async fn domain_set_active_external_root_encryption_key(configuration: &configuration::Configuration, domain_id: &str, active_root_encryption_key_id: models::ActiveRootEncryptionKeyId) -> Result<models::ActiveRootEncryptionKeyResponse, Error<DomainSetActiveExternalRootEncryptionKeyError>> {
    let local_var_configuration = configuration;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/domains/{domainID}/control/encryption/active-key", local_var_configuration.base_path, domainID=crate::apis::urlencode(domain_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.bearer_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(&active_root_encryption_key_id);

    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() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DomainSetActiveExternalRootEncryptionKeyError> = 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))
    }
}