clientapi-pbs 2026.5.24

/*
 * Proxmox Backup Server API
 *
 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pbs.proxmox.com/docs/api-viewer/ for the upstream documentation.
 *
 * The version of the OpenAPI document: 9.x
 * 
 * Generated by: https://openapi-generator.tech
 */


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


/// struct for typed errors of method [`admin_datastore_create_change_owner`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreateChangeOwnerError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_gc`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreateGcError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_mount`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreateMountError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_move_group`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreateMoveGroupError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_move_namespace`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreateMoveNamespaceError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_namespace`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreateNamespaceError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_prune`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreatePruneError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_prune_datastore`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreatePruneDatastoreError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_unmount`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreateUnmountError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_upload_backup_log`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreateUploadBackupLogError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_create_verify`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreCreateVerifyError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_delete_groups`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreDeleteGroupsError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_delete_namespace`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreDeleteNamespaceError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_delete_snapshots`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreDeleteSnapshotsError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_active_operations`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetActiveOperationsError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_admin_datastore_by_store`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetAdminDatastoreByStoreError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_catalog`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetCatalogError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_datastore`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetDatastoreError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_download`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetDownloadError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_download_decoded`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetDownloadDecodedError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_files`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetFilesError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_gc`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetGcError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_group_notes`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetGroupNotesError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_groups`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetGroupsError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_namespace`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetNamespaceError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_notes`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetNotesError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_protected`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetProtectedError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_pxar_file_download`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetPxarFileDownloadError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_rrd`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetRrdError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_snapshots`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetSnapshotsError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_get_status`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreGetStatusError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_update_group_notes`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreUpdateGroupNotesError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_update_notes`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreUpdateNotesError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_update_protected`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreUpdateProtectedError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`admin_datastore_update_s3_refresh`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdminDatastoreUpdateS3RefreshError {
    Status400(models::PbsError),
    Status401(models::PbsError),
    Status403(models::PbsError),
    Status404(models::PbsError),
    Status500(models::PbsError),
    Status501(models::PbsError),
    Status503(models::PbsError),
    UnknownValue(serde_json::Value),
}


/// Change owner of a backup group  Permissions: Datastore.Modify on whole datastore, or changing ownership between user and a user's token for owned backups with Datastore.Backup
pub async fn admin_datastore_create_change_owner(configuration: &configuration::Configuration, store: &str, admin_datastore_create_change_owner_request: models::AdminDatastoreCreateChangeOwnerRequest) -> Result<models::AdminDatastoreCreateChangeOwnerResponse, Error<AdminDatastoreCreateChangeOwnerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_create_change_owner_request = admin_datastore_create_change_owner_request;

    let uri_str = format!("{}/admin/datastore/{store}/change-owner", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_create_change_owner_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreateChangeOwnerResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateChangeOwnerResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreateChangeOwnerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Start garbage collection.
pub async fn admin_datastore_create_gc(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreCreateGcResponse, Error<AdminDatastoreCreateGcError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;

    let uri_str = format!("{}/admin/datastore/{store}/gc", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreateGcResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateGcResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreateGcError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Mount removable datastore.
pub async fn admin_datastore_create_mount(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreCreateMountResponse, Error<AdminDatastoreCreateMountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;

    let uri_str = format!("{}/admin/datastore/{store}/mount", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreateMountResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateMountResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreateMountError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Move a backup group to a different namespace within the same datastore.  Permissions: Requires DATASTORE_MODIFY or DATASTORE_PRUNE (+ group ownership) on the source namespace and DATASTORE_MODIFY or DATASTORE_BACKUP (+ group ownership) on the target namespace.
pub async fn admin_datastore_create_move_group(configuration: &configuration::Configuration, store: &str, admin_datastore_create_move_group_request: models::AdminDatastoreCreateMoveGroupRequest) -> Result<models::AdminDatastoreCreateMoveGroupResponse, Error<AdminDatastoreCreateMoveGroupError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_create_move_group_request = admin_datastore_create_move_group_request;

    let uri_str = format!("{}/admin/datastore/{store}/move-group", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_create_move_group_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreateMoveGroupResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateMoveGroupResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreateMoveGroupError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Move a backup namespace (including all child namespaces and groups) to a new location.  Permissions: Requires DATASTORE_MODIFY on the parent of 'ns' and on the parent of 'target-ns'.
pub async fn admin_datastore_create_move_namespace(configuration: &configuration::Configuration, store: &str, admin_datastore_create_move_namespace_request: models::AdminDatastoreCreateMoveNamespaceRequest) -> Result<models::AdminDatastoreCreateMoveNamespaceResponse, Error<AdminDatastoreCreateMoveNamespaceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_create_move_namespace_request = admin_datastore_create_move_namespace_request;

    let uri_str = format!("{}/admin/datastore/{store}/move-namespace", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_create_move_namespace_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreateMoveNamespaceResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateMoveNamespaceResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreateMoveNamespaceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Create a new datastore namespace.  Permissions: Requires on /datastore/{store}[/{parent}] DATASTORE_MODIFY
pub async fn admin_datastore_create_namespace(configuration: &configuration::Configuration, store: &str, admin_datastore_create_namespace_request: models::AdminDatastoreCreateNamespaceRequest) -> Result<models::AdminDatastoreCreateNamespaceResponse, Error<AdminDatastoreCreateNamespaceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_create_namespace_request = admin_datastore_create_namespace_request;

    let uri_str = format!("{}/admin/datastore/{store}/namespace", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_create_namespace_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreateNamespaceResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateNamespaceResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreateNamespaceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Prune a group on the datastore  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_PRUNE and being the owner of the group
pub async fn admin_datastore_create_prune(configuration: &configuration::Configuration, store: &str, admin_datastore_create_prune_request: models::AdminDatastoreCreatePruneRequest) -> Result<models::AdminDatastoreCreatePruneResponse, Error<AdminDatastoreCreatePruneError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_create_prune_request = admin_datastore_create_prune_request;

    let uri_str = format!("{}/admin/datastore/{store}/prune", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_create_prune_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreatePruneResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreatePruneResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreatePruneError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Prune the datastore  Permissions: Requires Datastore.Modify or Datastore.Prune on the datastore/namespace.
pub async fn admin_datastore_create_prune_datastore(configuration: &configuration::Configuration, store: &str, admin_datastore_create_prune_datastore_request: Option<models::AdminDatastoreCreatePruneDatastoreRequest>) -> Result<models::AdminDatastoreCreatePruneDatastoreResponse, Error<AdminDatastoreCreatePruneDatastoreError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_create_prune_datastore_request = admin_datastore_create_prune_datastore_request;

    let uri_str = format!("{}/admin/datastore/{store}/prune-datastore", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_create_prune_datastore_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreatePruneDatastoreResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreatePruneDatastoreResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreatePruneDatastoreError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Unmount a removable device that is associated with the datastore
pub async fn admin_datastore_create_unmount(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreCreateUnmountResponse, Error<AdminDatastoreCreateUnmountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;

    let uri_str = format!("{}/admin/datastore/{store}/unmount", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreateUnmountResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateUnmountResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreateUnmountError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Upload the client backup log file into a backup snapshot ('client.log.blob').  Permissions: Only the backup creator/owner is allowed to do this.
pub async fn admin_datastore_create_upload_backup_log(configuration: &configuration::Configuration, store: &str, admin_datastore_create_upload_backup_log_request: models::AdminDatastoreCreateUploadBackupLogRequest) -> Result<models::AdminDatastoreCreateUploadBackupLogResponse, Error<AdminDatastoreCreateUploadBackupLogError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_create_upload_backup_log_request = admin_datastore_create_upload_backup_log_request;

    let uri_str = format!("{}/admin/datastore/{store}/upload-backup-log", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_create_upload_backup_log_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreateUploadBackupLogResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateUploadBackupLogResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreateUploadBackupLogError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Verify backups.  This function can verify a single backup snapshot, all backups from a backup group, or all backups in the datastore.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_VERIFY for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_create_verify(configuration: &configuration::Configuration, store: &str, admin_datastore_create_verify_request: Option<models::AdminDatastoreCreateVerifyRequest>) -> Result<models::AdminDatastoreCreateVerifyResponse, Error<AdminDatastoreCreateVerifyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_create_verify_request = admin_datastore_create_verify_request;

    let uri_str = format!("{}/admin/datastore/{store}/verify", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_create_verify_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreCreateVerifyResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreCreateVerifyResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreCreateVerifyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Delete backup group including all snapshots.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_PRUNE and being the owner of the group
pub async fn admin_datastore_delete_groups(configuration: &configuration::Configuration, backup_id: &str, backup_type: models::PbsBackupTypeEnum, store: &str, error_on_protected: Option<bool>, ns: Option<&str>) -> Result<models::AdminDatastoreDeleteGroupsResponse, Error<AdminDatastoreDeleteGroupsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_type = backup_type;
    let p_path_store = store;
    let p_query_error_on_protected = error_on_protected;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/groups", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    if let Some(ref param_value) = p_query_error_on_protected {
        req_builder = req_builder.query(&[("error-on-protected", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreDeleteGroupsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreDeleteGroupsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreDeleteGroupsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Delete a backup namespace including all snapshots.
pub async fn admin_datastore_delete_namespace(configuration: &configuration::Configuration, ns: &str, store: &str, delete_groups: Option<bool>, error_on_protected: Option<bool>) -> Result<models::AdminDatastoreDeleteNamespaceResponse, Error<AdminDatastoreDeleteNamespaceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ns = ns;
    let p_path_store = store;
    let p_query_delete_groups = delete_groups;
    let p_query_error_on_protected = error_on_protected;

    let uri_str = format!("{}/admin/datastore/{store}/namespace", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_delete_groups {
        req_builder = req_builder.query(&[("delete-groups", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_error_on_protected {
        req_builder = req_builder.query(&[("error-on-protected", &param_value.to_string())]);
    }
    req_builder = req_builder.query(&[("ns", &p_query_ns.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreDeleteNamespaceResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreDeleteNamespaceResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreDeleteNamespaceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Delete backup snapshot.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_PRUNE and being the owner of the group
pub async fn admin_datastore_delete_snapshots(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreDeleteSnapshotsResponse, Error<AdminDatastoreDeleteSnapshotsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_time = backup_time;
    let p_query_backup_type = backup_type;
    let p_path_store = store;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/snapshots", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreDeleteSnapshotsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreDeleteSnapshotsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreDeleteSnapshotsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Read datastore stats
pub async fn admin_datastore_get_active_operations(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreGetActiveOperationsResponse, Error<AdminDatastoreGetActiveOperationsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;

    let uri_str = format!("{}/admin/datastore/{store}/active-operations", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetActiveOperationsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetActiveOperationsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetActiveOperationsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Directory index.
pub async fn admin_datastore_get_admin_datastore_by_store(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreGetAdminDatastoreByStoreResponse, Error<AdminDatastoreGetAdminDatastoreByStoreError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;

    let uri_str = format!("{}/admin/datastore/{store}", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetAdminDatastoreByStoreResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetAdminDatastoreByStoreResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetAdminDatastoreByStoreError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get the entries of the given path of the catalog  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_get_catalog(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, filepath: &str, store: &str, archive_name: Option<&str>, ns: Option<&str>) -> Result<models::AdminDatastoreGetCatalogResponse, Error<AdminDatastoreGetCatalogError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_time = backup_time;
    let p_query_backup_type = backup_type;
    let p_query_filepath = filepath;
    let p_path_store = store;
    let p_query_archive_name = archive_name;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/catalog", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_archive_name {
        req_builder = req_builder.query(&[("archive-name", &param_value.to_string())]);
    }
    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    req_builder = req_builder.query(&[("filepath", &p_query_filepath.to_string())]);
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetCatalogResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetCatalogResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetCatalogError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Datastore list
pub async fn admin_datastore_get_datastore(configuration: &configuration::Configuration, ) -> Result<models::AdminDatastoreGetDatastoreResponse, Error<AdminDatastoreGetDatastoreError>> {

    let uri_str = format!("{}/admin/datastore", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetDatastoreResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetDatastoreResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetDatastoreError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Download single raw file from backup snapshot.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_get_download(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, file_name: &str, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetDownloadResponse, Error<AdminDatastoreGetDownloadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_time = backup_time;
    let p_query_backup_type = backup_type;
    let p_query_file_name = file_name;
    let p_path_store = store;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/download", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    req_builder = req_builder.query(&[("file-name", &p_query_file_name.to_string())]);
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetDownloadResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetDownloadResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetDownloadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Download single decoded file from backup snapshot. Only works if it's not encrypted.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_get_download_decoded(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, file_name: &str, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetDownloadDecodedResponse, Error<AdminDatastoreGetDownloadDecodedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_time = backup_time;
    let p_query_backup_type = backup_type;
    let p_query_file_name = file_name;
    let p_path_store = store;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/download-decoded", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    req_builder = req_builder.query(&[("file-name", &p_query_file_name.to_string())]);
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetDownloadDecodedResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetDownloadDecodedResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetDownloadDecodedError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// List snapshot files.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT or DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_get_files(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetFilesResponse, Error<AdminDatastoreGetFilesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_time = backup_time;
    let p_query_backup_type = backup_type;
    let p_path_store = store;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/files", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetFilesResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetFilesResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetFilesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Garbage collection status.
pub async fn admin_datastore_get_gc(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreGetGcResponse, Error<AdminDatastoreGetGcError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;

    let uri_str = format!("{}/admin/datastore/{store}/gc", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetGcResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetGcResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetGcError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get \"notes\" for a backup group  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_get_group_notes(configuration: &configuration::Configuration, backup_id: &str, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetGroupNotesResponse, Error<AdminDatastoreGetGroupNotesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_type = backup_type;
    let p_path_store = store;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/group-notes", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetGroupNotesResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetGroupNotesResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetGroupNotesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// List backup groups.  Permissions: Requires DATASTORE_AUDIT for all or DATASTORE_BACKUP for owned groups on /datastore/{store}[/{namespace}]
pub async fn admin_datastore_get_groups(configuration: &configuration::Configuration, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetGroupsResponse, Error<AdminDatastoreGetGroupsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/groups", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetGroupsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetGroupsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetGroupsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// List the namespaces of a datastore.  Permissions: Requires DATASTORE_AUDIT, DATASTORE_MODIFY or DATASTORE_BACKUP /datastore/{store}[/{parent}]
pub async fn admin_datastore_get_namespace(configuration: &configuration::Configuration, store: &str, max_depth: Option<i32>, parent: Option<&str>) -> Result<models::AdminDatastoreGetNamespaceResponse, Error<AdminDatastoreGetNamespaceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_query_max_depth = max_depth;
    let p_query_parent = parent;

    let uri_str = format!("{}/admin/datastore/{store}/namespace", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_max_depth {
        req_builder = req_builder.query(&[("max-depth", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_parent {
        req_builder = req_builder.query(&[("parent", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetNamespaceResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetNamespaceResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetNamespaceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get \"notes\" for a specific backup  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_get_notes(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetNotesResponse, Error<AdminDatastoreGetNotesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_time = backup_time;
    let p_query_backup_type = backup_type;
    let p_path_store = store;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/notes", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetNotesResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetNotesResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetNotesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Query protection for a specific backup  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_get_protected(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, store: &str, ns: Option<&str>) -> Result<models::AdminDatastoreGetProtectedResponse, Error<AdminDatastoreGetProtectedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_time = backup_time;
    let p_query_backup_type = backup_type;
    let p_path_store = store;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/protected", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetProtectedResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetProtectedResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetProtectedError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Download single file from pxar file of a backup snapshot. Only works if it's not encrypted.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_READ for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_get_pxar_file_download(configuration: &configuration::Configuration, backup_id: &str, backup_time: i64, backup_type: models::PbsBackupTypeEnum, filepath: &str, store: &str, archive_name: Option<&str>, ns: Option<&str>, tar: Option<bool>) -> Result<models::AdminDatastoreGetPxarFileDownloadResponse, Error<AdminDatastoreGetPxarFileDownloadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_backup_id = backup_id;
    let p_query_backup_time = backup_time;
    let p_query_backup_type = backup_type;
    let p_query_filepath = filepath;
    let p_path_store = store;
    let p_query_archive_name = archive_name;
    let p_query_ns = ns;
    let p_query_tar = tar;

    let uri_str = format!("{}/admin/datastore/{store}/pxar-file-download", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_archive_name {
        req_builder = req_builder.query(&[("archive-name", &param_value.to_string())]);
    }
    req_builder = req_builder.query(&[("backup-id", &p_query_backup_id.to_string())]);
    req_builder = req_builder.query(&[("backup-time", &p_query_backup_time.to_string())]);
    req_builder = req_builder.query(&[("backup-type", &p_query_backup_type.to_string())]);
    req_builder = req_builder.query(&[("filepath", &p_query_filepath.to_string())]);
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_tar {
        req_builder = req_builder.query(&[("tar", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetPxarFileDownloadResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetPxarFileDownloadResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetPxarFileDownloadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Read datastore stats
pub async fn admin_datastore_get_rrd(configuration: &configuration::Configuration, cf: models::PbsCfEnum, store: &str, timeframe: models::PbsTimeframeEnum) -> Result<models::AdminDatastoreGetRrdResponse, Error<AdminDatastoreGetRrdError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_cf = cf;
    let p_path_store = store;
    let p_query_timeframe = timeframe;

    let uri_str = format!("{}/admin/datastore/{store}/rrd", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("cf", &p_query_cf.to_string())]);
    req_builder = req_builder.query(&[("timeframe", &p_query_timeframe.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetRrdResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetRrdResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetRrdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// List backup snapshots.  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_AUDIT for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_get_snapshots(configuration: &configuration::Configuration, store: &str, backup_id: Option<&str>, backup_type: Option<models::PbsBackupTypeEnum>, ns: Option<&str>) -> Result<models::AdminDatastoreGetSnapshotsResponse, Error<AdminDatastoreGetSnapshotsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_query_backup_id = backup_id;
    let p_query_backup_type = backup_type;
    let p_query_ns = ns;

    let uri_str = format!("{}/admin/datastore/{store}/snapshots", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_backup_id {
        req_builder = req_builder.query(&[("backup-id", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_backup_type {
        req_builder = req_builder.query(&[("backup-type", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_ns {
        req_builder = req_builder.query(&[("ns", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetSnapshotsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetSnapshotsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetSnapshotsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get datastore status.  Permissions: Requires on /datastore/{store} either DATASTORE_AUDIT or DATASTORE_BACKUP for the full statistics. Counts of accessible groups are always returned, if any
pub async fn admin_datastore_get_status(configuration: &configuration::Configuration, store: &str, verbose: Option<bool>) -> Result<models::AdminDatastoreGetStatusResponse, Error<AdminDatastoreGetStatusError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_query_verbose = verbose;

    let uri_str = format!("{}/admin/datastore/{store}/status", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_verbose {
        req_builder = req_builder.query(&[("verbose", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreGetStatusResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreGetStatusResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreGetStatusError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Set \"notes\" for a backup group  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_update_group_notes(configuration: &configuration::Configuration, store: &str, admin_datastore_update_group_notes_request: models::AdminDatastoreUpdateGroupNotesRequest) -> Result<models::AdminDatastoreUpdateGroupNotesResponse, Error<AdminDatastoreUpdateGroupNotesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_update_group_notes_request = admin_datastore_update_group_notes_request;

    let uri_str = format!("{}/admin/datastore/{store}/group-notes", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_update_group_notes_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreUpdateGroupNotesResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreUpdateGroupNotesResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreUpdateGroupNotesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Set \"notes\" for a specific backup  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_update_notes(configuration: &configuration::Configuration, store: &str, admin_datastore_update_notes_request: models::AdminDatastoreUpdateNotesRequest) -> Result<models::AdminDatastoreUpdateNotesResponse, Error<AdminDatastoreUpdateNotesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_update_notes_request = admin_datastore_update_notes_request;

    let uri_str = format!("{}/admin/datastore/{store}/notes", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_update_notes_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreUpdateNotesResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreUpdateNotesResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreUpdateNotesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// En- or disable protection for a specific backup  Permissions: Requires on /datastore/{store}[/{namespace}] either DATASTORE_MODIFY for any or DATASTORE_BACKUP and being the owner of the group
pub async fn admin_datastore_update_protected(configuration: &configuration::Configuration, store: &str, admin_datastore_update_protected_request: models::AdminDatastoreUpdateProtectedRequest) -> Result<models::AdminDatastoreUpdateProtectedResponse, Error<AdminDatastoreUpdateProtectedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;
    let p_body_admin_datastore_update_protected_request = admin_datastore_update_protected_request;

    let uri_str = format!("{}/admin/datastore/{store}/protected", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };
    req_builder = req_builder.json(&p_body_admin_datastore_update_protected_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreUpdateProtectedResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreUpdateProtectedResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreUpdateProtectedError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Refresh datastore contents from S3 to local cache store.
pub async fn admin_datastore_update_s3_refresh(configuration: &configuration::Configuration, store: &str) -> Result<models::AdminDatastoreUpdateS3RefreshResponse, Error<AdminDatastoreUpdateS3RefreshError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_store = store;

    let uri_str = format!("{}/admin/datastore/{store}/s3-refresh", configuration.base_path, store=crate::apis::urlencode(p_path_store));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("Authorization", value);
    };
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("CSRFPreventionToken", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::AdminDatastoreUpdateS3RefreshResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AdminDatastoreUpdateS3RefreshResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AdminDatastoreUpdateS3RefreshError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}