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 [`tape_drive_create_barcode_label_media`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateBarcodeLabelMediaError {
    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 [`tape_drive_create_catalog`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateCatalogError {
    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 [`tape_drive_create_eject_media`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateEjectMediaError {
    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 [`tape_drive_create_format_media`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateFormatMediaError {
    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 [`tape_drive_create_label_media`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateLabelMediaError {
    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 [`tape_drive_create_load_media`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateLoadMediaError {
    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 [`tape_drive_create_load_slot`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateLoadSlotError {
    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 [`tape_drive_create_restore_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateRestoreKeyError {
    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 [`tape_drive_create_rewind`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateRewindError {
    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 [`tape_drive_create_unload`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveCreateUnloadError {
    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 [`tape_drive_get_cartridge_memory`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveGetCartridgeMemoryError {
    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 [`tape_drive_get_drive`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveGetDriveError {
    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 [`tape_drive_get_inventory`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveGetInventoryError {
    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 [`tape_drive_get_read_label`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveGetReadLabelError {
    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 [`tape_drive_get_status`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveGetStatusError {
    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 [`tape_drive_get_tape_drive_by_drive`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveGetTapeDriveByDriveError {
    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 [`tape_drive_get_volume_statistics`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveGetVolumeStatisticsError {
    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 [`tape_drive_update_clean`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveUpdateCleanError {
    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 [`tape_drive_update_export_media`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveUpdateExportMediaError {
    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 [`tape_drive_update_inventory`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TapeDriveUpdateInventoryError {
    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),
}


/// Label media with barcodes from changer device
pub async fn tape_drive_create_barcode_label_media(configuration: &configuration::Configuration, drive: &str, tape_drive_create_barcode_label_media_request: Option<models::TapeDriveCreateBarcodeLabelMediaRequest>) -> Result<models::TapeDriveCreateBarcodeLabelMediaResponse, Error<TapeDriveCreateBarcodeLabelMediaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_create_barcode_label_media_request = tape_drive_create_barcode_label_media_request;

    let uri_str = format!("{}/tape/drive/{drive}/barcode-label-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_create_barcode_label_media_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::TapeDriveCreateBarcodeLabelMediaResponse`"))),
            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::TapeDriveCreateBarcodeLabelMediaResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateBarcodeLabelMediaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Scan media and record content
pub async fn tape_drive_create_catalog(configuration: &configuration::Configuration, drive: &str, tape_drive_create_catalog_request: Option<models::TapeDriveCreateCatalogRequest>) -> Result<models::TapeDriveCreateCatalogResponse, Error<TapeDriveCreateCatalogError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_create_catalog_request = tape_drive_create_catalog_request;

    let uri_str = format!("{}/tape/drive/{drive}/catalog", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_create_catalog_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::TapeDriveCreateCatalogResponse`"))),
            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::TapeDriveCreateCatalogResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateCatalogError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Eject/Unload drive media
pub async fn tape_drive_create_eject_media(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveCreateEjectMediaResponse, Error<TapeDriveCreateEjectMediaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;

    let uri_str = format!("{}/tape/drive/{drive}/eject-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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::TapeDriveCreateEjectMediaResponse`"))),
            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::TapeDriveCreateEjectMediaResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateEjectMediaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Format media. Check for label-text if given (cancels if wrong media).
pub async fn tape_drive_create_format_media(configuration: &configuration::Configuration, drive: &str, tape_drive_create_format_media_request: Option<models::TapeDriveCreateFormatMediaRequest>) -> Result<models::TapeDriveCreateFormatMediaResponse, Error<TapeDriveCreateFormatMediaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_create_format_media_request = tape_drive_create_format_media_request;

    let uri_str = format!("{}/tape/drive/{drive}/format-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_create_format_media_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::TapeDriveCreateFormatMediaResponse`"))),
            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::TapeDriveCreateFormatMediaResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateFormatMediaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Label media  Write a new media label to the media in 'drive'. The media is assigned to the specified 'pool', or else to the free media pool.  Note: The media need to be empty (you may want to format it first).
pub async fn tape_drive_create_label_media(configuration: &configuration::Configuration, drive: &str, tape_drive_create_label_media_request: models::TapeDriveCreateLabelMediaRequest) -> Result<models::TapeDriveCreateLabelMediaResponse, Error<TapeDriveCreateLabelMediaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_create_label_media_request = tape_drive_create_label_media_request;

    let uri_str = format!("{}/tape/drive/{drive}/label-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_create_label_media_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::TapeDriveCreateLabelMediaResponse`"))),
            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::TapeDriveCreateLabelMediaResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateLabelMediaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Load media with specified label  Issue a media load request to the associated changer device.
pub async fn tape_drive_create_load_media(configuration: &configuration::Configuration, drive: &str, tape_drive_update_export_media_request: models::TapeDriveUpdateExportMediaRequest) -> Result<models::TapeDriveCreateLoadMediaResponse, Error<TapeDriveCreateLoadMediaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_update_export_media_request = tape_drive_update_export_media_request;

    let uri_str = format!("{}/tape/drive/{drive}/load-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_update_export_media_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::TapeDriveCreateLoadMediaResponse`"))),
            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::TapeDriveCreateLoadMediaResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateLoadMediaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Load media from the specified slot  Issue a media load request to the associated changer device.
pub async fn tape_drive_create_load_slot(configuration: &configuration::Configuration, drive: &str, tape_drive_create_load_slot_request: models::TapeDriveCreateLoadSlotRequest) -> Result<models::TapeDriveCreateLoadSlotResponse, Error<TapeDriveCreateLoadSlotError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_create_load_slot_request = tape_drive_create_load_slot_request;

    let uri_str = format!("{}/tape/drive/{drive}/load-slot", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_create_load_slot_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::TapeDriveCreateLoadSlotResponse`"))),
            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::TapeDriveCreateLoadSlotResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateLoadSlotError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Try to restore a tape encryption key
pub async fn tape_drive_create_restore_key(configuration: &configuration::Configuration, drive: &str, tape_drive_create_restore_key_request: models::TapeDriveCreateRestoreKeyRequest) -> Result<models::TapeDriveCreateRestoreKeyResponse, Error<TapeDriveCreateRestoreKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_create_restore_key_request = tape_drive_create_restore_key_request;

    let uri_str = format!("{}/tape/drive/{drive}/restore-key", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_create_restore_key_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::TapeDriveCreateRestoreKeyResponse`"))),
            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::TapeDriveCreateRestoreKeyResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateRestoreKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Rewind tape
pub async fn tape_drive_create_rewind(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveCreateRewindResponse, Error<TapeDriveCreateRewindError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;

    let uri_str = format!("{}/tape/drive/{drive}/rewind", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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::TapeDriveCreateRewindResponse`"))),
            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::TapeDriveCreateRewindResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateRewindError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Unload media via changer
pub async fn tape_drive_create_unload(configuration: &configuration::Configuration, drive: &str, tape_drive_create_unload_request: Option<models::TapeDriveCreateUnloadRequest>) -> Result<models::TapeDriveCreateUnloadResponse, Error<TapeDriveCreateUnloadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_create_unload_request = tape_drive_create_unload_request;

    let uri_str = format!("{}/tape/drive/{drive}/unload", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_create_unload_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::TapeDriveCreateUnloadResponse`"))),
            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::TapeDriveCreateUnloadResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveCreateUnloadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Read Cartridge Memory (Medium auxiliary memory attributes)
pub async fn tape_drive_get_cartridge_memory(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetCartridgeMemoryResponse, Error<TapeDriveGetCartridgeMemoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;

    let uri_str = format!("{}/tape/drive/{drive}/cartridge-memory", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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::TapeDriveGetCartridgeMemoryResponse`"))),
            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::TapeDriveGetCartridgeMemoryResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveGetCartridgeMemoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// List drives  Permissions: List configured tape drives filtered by Tape.Audit privileges
pub async fn tape_drive_get_drive(configuration: &configuration::Configuration, changer: Option<&str>, query_activity: Option<bool>) -> Result<models::TapeDriveGetDriveResponse, Error<TapeDriveGetDriveError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_changer = changer;
    let p_query_query_activity = query_activity;

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

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

/// List known media labels (Changer Inventory)  Note: Only useful for drives with associated changer device.  This method queries the changer to get a list of media labels.  Note: This updates the media online status.
pub async fn tape_drive_get_inventory(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetInventoryResponse, Error<TapeDriveGetInventoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;

    let uri_str = format!("{}/tape/drive/{drive}/inventory", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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::TapeDriveGetInventoryResponse`"))),
            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::TapeDriveGetInventoryResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveGetInventoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Read media label (optionally inventorize media)
pub async fn tape_drive_get_read_label(configuration: &configuration::Configuration, drive: &str, inventorize: Option<bool>) -> Result<models::TapeDriveGetReadLabelResponse, Error<TapeDriveGetReadLabelError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_query_inventorize = inventorize;

    let uri_str = format!("{}/tape/drive/{drive}/read-label", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

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

/// Get drive/media status
pub async fn tape_drive_get_status(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetStatusResponse, Error<TapeDriveGetStatusError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;

    let uri_str = format!("{}/tape/drive/{drive}/status", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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::TapeDriveGetStatusResponse`"))),
            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::TapeDriveGetStatusResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveGetStatusError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Directory index.
pub async fn tape_drive_get_tape_drive_by_drive(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetTapeDriveByDriveResponse, Error<TapeDriveGetTapeDriveByDriveError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;

    let uri_str = format!("{}/tape/drive/{drive}", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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::TapeDriveGetTapeDriveByDriveResponse`"))),
            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::TapeDriveGetTapeDriveByDriveResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveGetTapeDriveByDriveError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Read Volume Statistics (SCSI log page 17h)
pub async fn tape_drive_get_volume_statistics(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetVolumeStatisticsResponse, Error<TapeDriveGetVolumeStatisticsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;

    let uri_str = format!("{}/tape/drive/{drive}/volume-statistics", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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::TapeDriveGetVolumeStatisticsResponse`"))),
            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::TapeDriveGetVolumeStatisticsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveGetVolumeStatisticsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Clean drive
pub async fn tape_drive_update_clean(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveUpdateCleanResponse, Error<TapeDriveUpdateCleanError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;

    let uri_str = format!("{}/tape/drive/{drive}/clean", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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::TapeDriveUpdateCleanResponse`"))),
            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::TapeDriveUpdateCleanResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveUpdateCleanError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Export media with specified label
pub async fn tape_drive_update_export_media(configuration: &configuration::Configuration, drive: &str, tape_drive_update_export_media_request: models::TapeDriveUpdateExportMediaRequest) -> Result<models::TapeDriveUpdateExportMediaResponse, Error<TapeDriveUpdateExportMediaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_update_export_media_request = tape_drive_update_export_media_request;

    let uri_str = format!("{}/tape/drive/{drive}/export-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_update_export_media_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::TapeDriveUpdateExportMediaResponse`"))),
            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::TapeDriveUpdateExportMediaResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveUpdateExportMediaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Update inventory  Note: Only useful for drives with associated changer device.  This method queries the changer to get a list of media labels. It then loads any unknown media into the drive, reads the label, and store the result to the media database.  If `catalog` is true, also tries to restore the catalog from tape.  Note: This updates the media online status.
pub async fn tape_drive_update_inventory(configuration: &configuration::Configuration, drive: &str, tape_drive_update_inventory_request: Option<models::TapeDriveUpdateInventoryRequest>) -> Result<models::TapeDriveUpdateInventoryResponse, Error<TapeDriveUpdateInventoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_drive = drive;
    let p_body_tape_drive_update_inventory_request = tape_drive_update_inventory_request;

    let uri_str = format!("{}/tape/drive/{drive}/inventory", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
    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_tape_drive_update_inventory_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::TapeDriveUpdateInventoryResponse`"))),
            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::TapeDriveUpdateInventoryResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TapeDriveUpdateInventoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}