clientapi-pve 2026.5.24

/*
 * Proxmox Virtual Environment API
 *
 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pve.proxmox.com/pve-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 [`nodes_storage_copy`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum NodesStorageCopyError {
    Status400(models::PveError),
    Status401(models::PveError),
    Status403(models::PveError),
    Status404(models::PveError),
    Status500(models::PveError),
    Status501(models::PveError),
    Status503(models::PveError),
    UnknownValue(serde_json::Value),
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/// Copy a volume. This is experimental code - do not use.
pub async fn nodes_storage_copy(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str, nodes_storage_copy_request: models::NodesStorageCopyRequest) -> Result<models::NodesStorageCopyResponse, Error<NodesStorageCopyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_path_volume = volume;
    let p_body_nodes_storage_copy_request = nodes_storage_copy_request;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content/{volume}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage), volume=crate::apis::urlencode(p_path_volume));
    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_nodes_storage_copy_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::NodesStorageCopyResponse`"))),
            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::NodesStorageCopyResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageCopyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Allocate disk images.
pub async fn nodes_storage_create_content(configuration: &configuration::Configuration, node: &str, storage: &str, nodes_storage_create_content_request: models::NodesStorageCreateContentRequest) -> Result<models::NodesStorageCreateContentResponse, Error<NodesStorageCreateContentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_body_nodes_storage_create_content_request = nodes_storage_create_content_request;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    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_nodes_storage_create_content_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::NodesStorageCreateContentResponse`"))),
            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::NodesStorageCreateContentResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageCreateContentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Delete volume  Permissions: You need 'Datastore.Allocate' privilege on the storage (or 'Datastore.AllocateSpace' for backup volumes if you have VM.Backup privilege on the VM).
pub async fn nodes_storage_delete_content(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str, delay: Option<i32>) -> Result<models::NodesStorageDeleteContentResponse, Error<NodesStorageDeleteContentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_path_volume = volume;
    let p_query_delay = delay;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content/{volume}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage), volume=crate::apis::urlencode(p_path_volume));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_delay {
        req_builder = req_builder.query(&[("delay", &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::NodesStorageDeleteContentResponse`"))),
            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::NodesStorageDeleteContentResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageDeleteContentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Prune backups. Only those using the standard naming scheme are considered.  Permissions: You need the 'Datastore.Allocate' privilege on the storage (or if a VM ID is specified, 'Datastore.AllocateSpace' and 'VM.Backup' for the VM).
pub async fn nodes_storage_delete_prunebackups(configuration: &configuration::Configuration, node: &str, storage: &str, prune_backups: Option<&str>, r#type: Option<models::PveClusterBackupInfoTypeEnum>, vmid: Option<i32>) -> Result<models::NodesStorageDeletePrunebackupsResponse, Error<NodesStorageDeletePrunebackupsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_query_prune_backups = prune_backups;
    let p_query_type = r#type;
    let p_query_vmid = vmid;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/prunebackups", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_prune_backups {
        req_builder = req_builder.query(&[("prune-backups", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_type {
        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_vmid {
        req_builder = req_builder.query(&[("vmid", &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::NodesStorageDeletePrunebackupsResponse`"))),
            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::NodesStorageDeletePrunebackupsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageDeletePrunebackupsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// 
pub async fn nodes_storage_diridx(configuration: &configuration::Configuration, node: &str, storage: &str) -> Result<models::NodesStorageDiridxResponse, Error<NodesStorageDiridxError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    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::NodesStorageDiridxResponse`"))),
            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::NodesStorageDiridxResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageDiridxError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Extract a file or directory (as zip archive) from a PBS backup.  Permissions: You need read access for the volume.
pub async fn nodes_storage_download(configuration: &configuration::Configuration, filepath: &str, node: &str, storage: &str, volume: &str, tar: Option<&str>) -> Result<models::NodesStorageDownloadResponse, Error<NodesStorageDownloadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filepath = filepath;
    let p_path_node = node;
    let p_path_storage = storage;
    let p_query_volume = volume;
    let p_query_tar = tar;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/file-restore/download", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("filepath", &p_query_filepath.to_string())]);
    if let Some(ref param_value) = p_query_tar {
        req_builder = req_builder.query(&[("tar", &param_value.to_string())]);
    }
    req_builder = req_builder.query(&[("volume", &p_query_volume.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::NodesStorageDownloadResponse`"))),
            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::NodesStorageDownloadResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageDownloadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Download templates, ISO images, OVAs and VM images by using an URL.  Permissions: Requires allocation access on the storage and as this allows one to probe the (local!) host network indirectly it also requires one of Sys.Modify on / (for backwards compatibility) or the newer Sys.AccessNetwork privilege on the node.
pub async fn nodes_storage_download_url(configuration: &configuration::Configuration, node: &str, storage: &str, nodes_storage_download_url_request: models::NodesStorageDownloadUrlRequest) -> Result<models::NodesStorageDownloadUrlResponse, Error<NodesStorageDownloadUrlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_body_nodes_storage_download_url_request = nodes_storage_download_url_request;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/download-url", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    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_nodes_storage_download_url_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::NodesStorageDownloadUrlResponse`"))),
            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::NodesStorageDownloadUrlResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageDownloadUrlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get prune information for backups. NOTE: this is only a preview and might not be what a subsequent prune call does if backups are removed/added in the meantime.
pub async fn nodes_storage_dryrun(configuration: &configuration::Configuration, node: &str, storage: &str, prune_backups: Option<&str>, r#type: Option<models::PveClusterBackupInfoTypeEnum>, vmid: Option<i32>) -> Result<models::NodesStorageDryrunResponse, Error<NodesStorageDryrunError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_query_prune_backups = prune_backups;
    let p_query_type = r#type;
    let p_query_vmid = vmid;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/prunebackups", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_prune_backups {
        req_builder = req_builder.query(&[("prune-backups", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_type {
        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_vmid {
        req_builder = req_builder.query(&[("vmid", &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::NodesStorageDryrunResponse`"))),
            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::NodesStorageDryrunResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageDryrunError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// List storage content.
pub async fn nodes_storage_get_content(configuration: &configuration::Configuration, node: &str, storage: &str, content: Option<&str>, vmid: Option<i32>) -> Result<models::NodesStorageGetContentResponse, Error<NodesStorageGetContentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_query_content = content;
    let p_query_vmid = vmid;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_content {
        req_builder = req_builder.query(&[("content", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_vmid {
        req_builder = req_builder.query(&[("vmid", &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::NodesStorageGetContentResponse`"))),
            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::NodesStorageGetContentResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageGetContentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get the base parameters for creating a guest which imports data from a foreign importable guest, like an ESXi VM  Permissions: You need read access for the volume.
pub async fn nodes_storage_get_import_metadata(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str) -> Result<models::NodesStorageGetImportMetadataResponse, Error<NodesStorageGetImportMetadataError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_query_volume = volume;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/import-metadata", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("volume", &p_query_volume.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::NodesStorageGetImportMetadataResponse`"))),
            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::NodesStorageGetImportMetadataResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageGetImportMetadataError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// List files and directories for single file restore under the given path.  Permissions: You need read access for the volume.
pub async fn nodes_storage_get_list(configuration: &configuration::Configuration, filepath: &str, node: &str, storage: &str, volume: &str) -> Result<models::NodesStorageGetListResponse, Error<NodesStorageGetListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filepath = filepath;
    let p_path_node = node;
    let p_path_storage = storage;
    let p_query_volume = volume;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/file-restore/list", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("filepath", &p_query_filepath.to_string())]);
    req_builder = req_builder.query(&[("volume", &p_query_volume.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::NodesStorageGetListResponse`"))),
            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::NodesStorageGetListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageGetListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get status for all datastores.  Permissions: Only list entries where you have 'Datastore.Audit' or 'Datastore.AllocateSpace' permissions on '/storage/<storage>'
pub async fn nodes_storage_get_storage(configuration: &configuration::Configuration, node: &str, content: Option<&str>, enabled: Option<&str>, format: Option<&str>, storage: Option<&str>, target: Option<&str>) -> Result<models::NodesStorageGetStorageResponse, Error<NodesStorageGetStorageError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_query_content = content;
    let p_query_enabled = enabled;
    let p_query_format = format;
    let p_query_storage = storage;
    let p_query_target = target;

    let uri_str = format!("{}/nodes/{node}/storage", configuration.base_path, node=crate::apis::urlencode(p_path_node));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_content {
        req_builder = req_builder.query(&[("content", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_enabled {
        req_builder = req_builder.query(&[("enabled", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_format {
        req_builder = req_builder.query(&[("format", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_storage {
        req_builder = req_builder.query(&[("storage", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_target {
        req_builder = req_builder.query(&[("target", &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::NodesStorageGetStorageResponse`"))),
            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::NodesStorageGetStorageResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageGetStorageError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Return identity information for this storage instance.
pub async fn nodes_storage_identity(configuration: &configuration::Configuration, node: &str, storage: &str) -> Result<models::NodesStorageIdentityResponse, Error<NodesStorageIdentityError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/identity", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    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::NodesStorageIdentityResponse`"))),
            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::NodesStorageIdentityResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageIdentityError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get volume attributes  Permissions: You need read access for the volume.
pub async fn nodes_storage_info(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str) -> Result<models::NodesStorageInfoResponse, Error<NodesStorageInfoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_path_volume = volume;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content/{volume}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage), volume=crate::apis::urlencode(p_path_volume));
    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::NodesStorageInfoResponse`"))),
            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::NodesStorageInfoResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageInfoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Pull an OCI image from a registry.
pub async fn nodes_storage_oci_registry_pull(configuration: &configuration::Configuration, node: &str, storage: &str, nodes_storage_oci_registry_pull_request: models::NodesStorageOciRegistryPullRequest) -> Result<models::NodesStorageOciRegistryPullResponse, Error<NodesStorageOciRegistryPullError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_body_nodes_storage_oci_registry_pull_request = nodes_storage_oci_registry_pull_request;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/oci-registry-pull", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    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_nodes_storage_oci_registry_pull_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::NodesStorageOciRegistryPullResponse`"))),
            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::NodesStorageOciRegistryPullResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageOciRegistryPullError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Read storage status.
pub async fn nodes_storage_read_status(configuration: &configuration::Configuration, node: &str, storage: &str) -> Result<models::NodesStorageReadStatusResponse, Error<NodesStorageReadStatusError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/status", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    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::NodesStorageReadStatusResponse`"))),
            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::NodesStorageReadStatusResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageReadStatusError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Read storage RRD statistics (returns PNG).
pub async fn nodes_storage_rrd(configuration: &configuration::Configuration, ds: &str, node: &str, storage: &str, timeframe: models::PveTimeframeEnum, cf: Option<models::PveCfEnum>) -> Result<models::NodesStorageRrdResponse, Error<NodesStorageRrdError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ds = ds;
    let p_path_node = node;
    let p_path_storage = storage;
    let p_query_timeframe = timeframe;
    let p_query_cf = cf;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/rrd", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_cf {
        req_builder = req_builder.query(&[("cf", &param_value.to_string())]);
    }
    req_builder = req_builder.query(&[("ds", &p_query_ds.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::NodesStorageRrdResponse`"))),
            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::NodesStorageRrdResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageRrdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Read storage RRD statistics.
pub async fn nodes_storage_rrddata(configuration: &configuration::Configuration, node: &str, storage: &str, timeframe: models::PveTimeframeEnum, cf: Option<models::PveCfEnum>) -> Result<models::NodesStorageRrddataResponse, Error<NodesStorageRrddataError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_query_timeframe = timeframe;
    let p_query_cf = cf;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/rrddata", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_cf {
        req_builder = req_builder.query(&[("cf", &param_value.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::NodesStorageRrddataResponse`"))),
            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::NodesStorageRrddataResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageRrddataError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Update volume attributes  Permissions: You need read access for the volume.
pub async fn nodes_storage_updateattributes(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str, nodes_storage_updateattributes_request: Option<models::NodesStorageUpdateattributesRequest>) -> Result<models::NodesStorageUpdateattributesResponse, Error<NodesStorageUpdateattributesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_path_volume = volume;
    let p_body_nodes_storage_updateattributes_request = nodes_storage_updateattributes_request;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content/{volume}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage), volume=crate::apis::urlencode(p_path_volume));
    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_nodes_storage_updateattributes_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::NodesStorageUpdateattributesResponse`"))),
            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::NodesStorageUpdateattributesResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageUpdateattributesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Upload templates, ISO images, OVAs and VM images.
pub async fn nodes_storage_upload(configuration: &configuration::Configuration, node: &str, storage: &str, nodes_storage_upload_request: models::NodesStorageUploadRequest) -> Result<models::NodesStorageUploadResponse, Error<NodesStorageUploadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_node = node;
    let p_path_storage = storage;
    let p_body_nodes_storage_upload_request = nodes_storage_upload_request;

    let uri_str = format!("{}/nodes/{node}/storage/{storage}/upload", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
    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_nodes_storage_upload_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::NodesStorageUploadResponse`"))),
            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::NodesStorageUploadResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<NodesStorageUploadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}