incus-client 0.1.1

/*
 * Incus external REST API
 *
 * This is the REST API used by all Incus clients. Internal endpoints aren't included in this documentation.  The Incus API is available over both a local unix+http and remote https API. Authentication for local users relies on group membership and access to the unix socket. For remote users, the default authentication method is TLS client certificates.
 *
 * The version of the OpenAPI document: 1.0
 * Contact: lxc-devel@lists.linuxcontainers.org
 * 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 [`instance_access`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceAccessError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_backup_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceBackupDeleteError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_backup_export`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceBackupExportError {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_backup_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceBackupGetError {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_backup_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceBackupPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_backups_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceBackupsGetError {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_backups_get_recursion1`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceBackupsGetRecursion1Error {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_backups_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceBackupsPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_bitmaps_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceBitmapsPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_console_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceConsoleDeleteError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_console_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceConsoleGetError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_console_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceConsolePostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_debug_memory_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceDebugMemoryGetError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_debug_repair_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceDebugRepairPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceDeleteError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_exec_output_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceExecOutputDeleteError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_exec_output_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceExecOutputGetError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_exec_outputs_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceExecOutputsGetError {
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_exec_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceExecPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_files_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceFilesDeleteError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_files_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceFilesGetError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_files_head`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceFilesHeadError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_files_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceFilesPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceGetError {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_get_recursion1`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceGetRecursion1Error {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_log_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceLogDeleteError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_log_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceLogGetError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_logs_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceLogsGetError {
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_metadata_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceMetadataGetError {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_metadata_patch`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceMetadataPatchError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status412(models::InstanceMetadataPut412Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_metadata_put`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceMetadataPutError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status412(models::InstanceMetadataPut412Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_metadata_templates_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceMetadataTemplatesDeleteError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_metadata_templates_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceMetadataTemplatesGetError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_metadata_templates_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceMetadataTemplatesPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_patch`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstancePatchError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstancePostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_put`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstancePutError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_rebuild_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceRebuildPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_sftp`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceSftpError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status404(models::InstanceConsoleGet404Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_snapshot_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceSnapshotDeleteError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_snapshot_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceSnapshotGetError {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_snapshot_patch`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceSnapshotPatchError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_snapshot_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceSnapshotPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_snapshot_put`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceSnapshotPutError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_snapshots_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceSnapshotsGetError {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_snapshots_get_recursion1`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceSnapshotsGetRecursion1Error {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_snapshots_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceSnapshotsPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_state_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceStateGetError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_state_put`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceStatePutError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instances_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstancesGetError {
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instances_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstancesPostError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instances_put`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstancesPutError {
    Status400(models::InstancesPut400Response),
    Status403(models::InstancesGet403Response),
    Status500(models::InstancesGet500Response),
    UnknownValue(serde_json::Value),
}


/// Gets the access information for the instance.
pub async fn instance_access(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceAccess200Response, Error<InstanceAccessError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/access", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Deletes the instance backup.
pub async fn instance_backup_delete(configuration: &configuration::Configuration, name: &str, backup: &str, project: Option<&str>) -> Result<models::InstancesPut202Response, Error<InstanceBackupDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_backup = backup;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/backups/{backup}", configuration.base_path, name=crate::apis::urlencode(p_path_name), backup=crate::apis::urlencode(p_path_backup));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Download the raw backup file(s) from the server.
pub async fn instance_backup_export(configuration: &configuration::Configuration, name: &str, backup: &str, project: Option<&str>) -> Result<(), Error<InstanceBackupExportError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_backup = backup;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/backups/{backup}/export", configuration.base_path, name=crate::apis::urlencode(p_path_name), backup=crate::apis::urlencode(p_path_backup));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceBackupExportError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Gets a specific instance backup.
pub async fn instance_backup_get(configuration: &configuration::Configuration, name: &str, backup: &str, project: Option<&str>) -> Result<models::InstanceBackupGet200Response, Error<InstanceBackupGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_backup = backup;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/backups/{backup}", configuration.base_path, name=crate::apis::urlencode(p_path_name), backup=crate::apis::urlencode(p_path_backup));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Renames an instance backup.
pub async fn instance_backup_post(configuration: &configuration::Configuration, name: &str, backup: &str, project: Option<&str>, backup2: Option<models::InstanceBackupPost>) -> Result<models::InstancesPut202Response, Error<InstanceBackupPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_backup = backup;
    let p_query_project = project;
    let p_body_backup = backup2;

    let uri_str = format!("{}/1.0/instances/{name}/backups/{backup}", configuration.base_path, name=crate::apis::urlencode(p_path_name), backup=crate::apis::urlencode(p_path_backup));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_backup);

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

/// Returns a list of instance backups (URLs).
pub async fn instance_backups_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceBackupsGet200Response, Error<InstanceBackupsGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/backups", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Returns a list of instance backups (structs).
pub async fn instance_backups_get_recursion1(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceBackupsGetRecursion1200Response, Error<InstanceBackupsGetRecursion1Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/backups?recursion=1", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Creates a new backup.  If the `Accept` header is set to `application/octet-stream`, this directly streams the backup tarball to the client without any intermediate operation.
pub async fn instance_backups_post(configuration: &configuration::Configuration, name: &str, project: Option<&str>, backup: Option<models::InstanceBackupsPost>) -> Result<models::InstancesPut202Response, Error<InstanceBackupsPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_backup = backup;

    let uri_str = format!("{}/1.0/instances/{name}/backups", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_backup);

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

/// Creates a new bitmap.
pub async fn instance_bitmaps_post(configuration: &configuration::Configuration, name: &str, project: Option<&str>, bitmap: Option<models::StorageVolumeBitmapsPost>) -> Result<models::InstancesPut202Response, Error<InstanceBitmapsPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_bitmap = bitmap;

    let uri_str = format!("{}/1.0/instances/{name}/bitmaps", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_bitmap);

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

/// Clears the console log buffer.
pub async fn instance_console_delete(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceConsoleDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/console", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Gets the console output for the instance either as text log or as vga screendump.
pub async fn instance_console_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>, r#type: Option<&str>) -> Result<(), Error<InstanceConsoleGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_query_type = r#type;

    let uri_str = format!("{}/1.0/instances/{name}/console", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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 user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceConsoleGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Connects to the console of an instance.  The returned operation metadata will contain two websockets, one for data and one for control.
pub async fn instance_console_post(configuration: &configuration::Configuration, name: &str, project: Option<&str>, console: Option<models::InstanceConsolePost>) -> Result<models::InstancesPut202Response, Error<InstanceConsolePostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_console = console;

    let uri_str = format!("{}/1.0/instances/{name}/console", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_console);

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

/// Returns memory debug information of a running instance. Only supported for VMs.
pub async fn instance_debug_memory_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>, format: Option<&str>) -> Result<(), Error<InstanceDebugMemoryGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_query_format = format;

    let uri_str = format!("{}/1.0/instances/{name}/debug/memory", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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 user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceDebugMemoryGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Runs an internal repair action on the instance.
pub async fn instance_debug_repair_post(configuration: &configuration::Configuration, name: &str, project: Option<&str>, state: Option<models::InstanceDebugRepairPost>) -> Result<models::InstancePatch200Response, Error<InstanceDebugRepairPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_state = state;

    let uri_str = format!("{}/1.0/instances/{name}/debug/repair", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_state);

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

/// Deletes a specific instance.  This also deletes anything owned by the instance such as snapshots and backups.
pub async fn instance_delete(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstancesPut202Response, Error<InstanceDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Removes the exec record-output file.
pub async fn instance_exec_output_delete(configuration: &configuration::Configuration, name: &str, filename: &str, project: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceExecOutputDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_filename = filename;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/logs/exec-output/{filename}", configuration.base_path, name=crate::apis::urlencode(p_path_name), filename=crate::apis::urlencode(p_path_filename));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Gets the exec-output file.
pub async fn instance_exec_output_get(configuration: &configuration::Configuration, name: &str, filename: &str, project: Option<&str>) -> Result<(), Error<InstanceExecOutputGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_filename = filename;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/logs/exec-output/{filename}", configuration.base_path, name=crate::apis::urlencode(p_path_name), filename=crate::apis::urlencode(p_path_filename));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceExecOutputGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Returns a list of exec record-output files (URLs).
pub async fn instance_exec_outputs_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceExecOutputsGet200Response, Error<InstanceExecOutputsGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/logs/exec-output", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Executes a command inside an instance.  The returned operation metadata will contain either 2 or 4 websockets. In non-interactive mode, you'll get one websocket for each of stdin, stdout and stderr. In interactive mode, a single bi-directional websocket is used for stdin and stdout/stderr.  An additional \"control\" socket is always added on top which can be used for out of band communications. This allows sending signals and window sizing information through.
pub async fn instance_exec_post(configuration: &configuration::Configuration, name: &str, project: Option<&str>, exec: Option<models::InstanceExecPost>) -> Result<models::InstancesPut202Response, Error<InstanceExecPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_exec = exec;

    let uri_str = format!("{}/1.0/instances/{name}/exec", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_exec);

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

/// Removes the file.
pub async fn instance_files_delete(configuration: &configuration::Configuration, name: &str, path: Option<&str>, project: Option<&str>, x_incus_force: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceFilesDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_path = path;
    let p_query_project = project;
    let p_header_x_incus_force = x_incus_force;

    let uri_str = format!("{}/1.0/instances/{name}/files", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_path {
        req_builder = req_builder.query(&[("path", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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(param_value) = p_header_x_incus_force {
        req_builder = req_builder.header("X-Incus-force", param_value.to_string());
    }

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

/// Gets the file content. If it's a directory, a json list of files will be returned instead.
pub async fn instance_files_get(configuration: &configuration::Configuration, name: &str, path: Option<&str>, project: Option<&str>) -> Result<(), Error<InstanceFilesGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_path = path;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/files", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_path {
        req_builder = req_builder.query(&[("path", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceFilesGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Gets the file or directory metadata.
pub async fn instance_files_head(configuration: &configuration::Configuration, name: &str, path: Option<&str>, project: Option<&str>) -> Result<(), Error<InstanceFilesHeadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_path = path;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/files", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::HEAD, &uri_str);

    if let Some(ref param_value) = p_query_path {
        req_builder = req_builder.query(&[("path", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceFilesHeadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Creates a new file in the instance.
pub async fn instance_files_post(configuration: &configuration::Configuration, name: &str, path: Option<&str>, project: Option<&str>, x_incus_uid: Option<&str>, x_incus_gid: Option<&str>, x_incus_mode: Option<&str>, x_incus_type: Option<&str>, x_incus_write: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceFilesPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_path = path;
    let p_query_project = project;
    let p_header_x_incus_uid = x_incus_uid;
    let p_header_x_incus_gid = x_incus_gid;
    let p_header_x_incus_mode = x_incus_mode;
    let p_header_x_incus_type = x_incus_type;
    let p_header_x_incus_write = x_incus_write;

    let uri_str = format!("{}/1.0/instances/{name}/files", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_path {
        req_builder = req_builder.query(&[("path", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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(param_value) = p_header_x_incus_uid {
        req_builder = req_builder.header("X-Incus-uid", param_value.to_string());
    }
    if let Some(param_value) = p_header_x_incus_gid {
        req_builder = req_builder.header("X-Incus-gid", param_value.to_string());
    }
    if let Some(param_value) = p_header_x_incus_mode {
        req_builder = req_builder.header("X-Incus-mode", param_value.to_string());
    }
    if let Some(param_value) = p_header_x_incus_type {
        req_builder = req_builder.header("X-Incus-type", param_value.to_string());
    }
    if let Some(param_value) = p_header_x_incus_write {
        req_builder = req_builder.header("X-Incus-write", param_value.to_string());
    }

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

/// Gets a specific instance (basic struct).
pub async fn instance_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceGet200Response, Error<InstanceGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Gets a specific instance (full struct).  recursion=1 also includes information about state, snapshots and backups.
pub async fn instance_get_recursion1(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceGetRecursion1200Response, Error<InstanceGetRecursion1Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}?recursion=1", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Removes the log file.
pub async fn instance_log_delete(configuration: &configuration::Configuration, name: &str, filename: &str, project: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceLogDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_filename = filename;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/logs/{filename}", configuration.base_path, name=crate::apis::urlencode(p_path_name), filename=crate::apis::urlencode(p_path_filename));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Gets the log file.
pub async fn instance_log_get(configuration: &configuration::Configuration, name: &str, filename: &str, project: Option<&str>) -> Result<(), Error<InstanceLogGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_filename = filename;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/logs/{filename}", configuration.base_path, name=crate::apis::urlencode(p_path_name), filename=crate::apis::urlencode(p_path_filename));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceLogGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Returns a list of log files (URLs).
pub async fn instance_logs_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceLogsGet200Response, Error<InstanceLogsGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/logs", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Gets the image metadata for the instance.
pub async fn instance_metadata_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceMetadataGet200Response, Error<InstanceMetadataGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/metadata", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Updates a subset of the instance image metadata.
pub async fn instance_metadata_patch(configuration: &configuration::Configuration, name: &str, metadata: models::ImageMetadata, project: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceMetadataPatchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_body_metadata = metadata;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/metadata", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_metadata);

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

/// Updates the instance image metadata.
pub async fn instance_metadata_put(configuration: &configuration::Configuration, name: &str, metadata: models::ImageMetadata, project: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceMetadataPutError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_body_metadata = metadata;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/metadata", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_metadata);

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

/// Removes the template file.
pub async fn instance_metadata_templates_delete(configuration: &configuration::Configuration, name: &str, path: Option<&str>, project: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceMetadataTemplatesDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_path = path;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/metadata/templates", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_path {
        req_builder = req_builder.query(&[("path", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// If no path specified, returns a list of template file names. If a path is specified, returns the file content.
pub async fn instance_metadata_templates_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>, path: Option<&str>) -> Result<(), Error<InstanceMetadataTemplatesGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_query_path = path;

    let uri_str = format!("{}/1.0/instances/{name}/metadata/templates", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_path {
        req_builder = req_builder.query(&[("path", &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());
    }

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceMetadataTemplatesGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Creates a new image template file for the instance.
pub async fn instance_metadata_templates_post(configuration: &configuration::Configuration, name: &str, path: Option<&str>, project: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceMetadataTemplatesPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_path = path;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/metadata/templates", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_path {
        req_builder = req_builder.query(&[("path", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Updates a subset of the instance configuration
pub async fn instance_patch(configuration: &configuration::Configuration, name: &str, project: Option<&str>, instance: Option<models::InstancePut>) -> Result<models::InstancePatch200Response, Error<InstancePatchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_instance = instance;

    let uri_str = format!("{}/1.0/instances/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_instance);

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

/// Renames, moves an instance between pools or migrates an instance to another server.  The returned operation metadata will vary based on what's requested. For rename or move within the same server, this is a simple background operation with progress data. For migration, in the push case, this will similarly be a background operation with progress data, for the pull case, it will be a websocket operation with a number of secrets to be passed to the target server.
pub async fn instance_post(configuration: &configuration::Configuration, name: &str, project: Option<&str>, migration: Option<models::InstancePost>) -> Result<models::InstancesPut202Response, Error<InstancePostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_migration = migration;

    let uri_str = format!("{}/1.0/instances/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_migration);

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

/// Updates the instance configuration or trigger a snapshot restore.
pub async fn instance_put(configuration: &configuration::Configuration, name: &str, project: Option<&str>, instance: Option<models::InstancePut>) -> Result<models::InstancesPut202Response, Error<InstancePutError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_instance = instance;

    let uri_str = format!("{}/1.0/instances/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_instance);

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

/// Rebuild an instance using an alternate image or as empty.
pub async fn instance_rebuild_post(configuration: &configuration::Configuration, name: &str, instance: models::InstanceRebuildPost, project: Option<&str>) -> Result<models::InstancePatch200Response, Error<InstanceRebuildPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_body_instance = instance;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/rebuild", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_instance);

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

/// Upgrades the request to an SFTP connection of the instance's filesystem.
pub async fn instance_sftp(configuration: &configuration::Configuration, name: &str) -> Result<(), Error<InstanceSftpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;

    let uri_str = format!("{}/1.0/instances/{name}/sftp", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    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());
    }

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceSftpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Deletes the instance snapshot.
pub async fn instance_snapshot_delete(configuration: &configuration::Configuration, name: &str, snapshot: &str, project: Option<&str>) -> Result<models::InstancesPut202Response, Error<InstanceSnapshotDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_snapshot = snapshot;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/snapshots/{snapshot}", configuration.base_path, name=crate::apis::urlencode(p_path_name), snapshot=crate::apis::urlencode(p_path_snapshot));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Gets a specific instance snapshot.
pub async fn instance_snapshot_get(configuration: &configuration::Configuration, name: &str, snapshot: &str, project: Option<&str>) -> Result<models::InstanceSnapshotGet200Response, Error<InstanceSnapshotGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_snapshot = snapshot;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/snapshots/{snapshot}", configuration.base_path, name=crate::apis::urlencode(p_path_name), snapshot=crate::apis::urlencode(p_path_snapshot));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Updates a subset of the snapshot config.
pub async fn instance_snapshot_patch(configuration: &configuration::Configuration, name: &str, snapshot: &str, project: Option<&str>, snapshot2: Option<models::InstanceSnapshotPut>) -> Result<models::InstancesPut202Response, Error<InstanceSnapshotPatchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_snapshot = snapshot;
    let p_query_project = project;
    let p_body_snapshot = snapshot2;

    let uri_str = format!("{}/1.0/instances/{name}/snapshots/{snapshot}", configuration.base_path, name=crate::apis::urlencode(p_path_name), snapshot=crate::apis::urlencode(p_path_snapshot));
    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_snapshot);

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

/// Renames or migrates an instance snapshot to another server.  The returned operation metadata will vary based on what's requested. For rename or move within the same server, this is a simple background operation with progress data. For migration, in the push case, this will similarly be a background operation with progress data, for the pull case, it will be a websocket operation with a number of secrets to be passed to the target server.
pub async fn instance_snapshot_post(configuration: &configuration::Configuration, name: &str, snapshot: &str, project: Option<&str>, snapshot2: Option<models::InstanceSnapshotPost>) -> Result<models::InstancesPut202Response, Error<InstanceSnapshotPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_snapshot = snapshot;
    let p_query_project = project;
    let p_body_snapshot = snapshot2;

    let uri_str = format!("{}/1.0/instances/{name}/snapshots/{snapshot}", configuration.base_path, name=crate::apis::urlencode(p_path_name), snapshot=crate::apis::urlencode(p_path_snapshot));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_snapshot);

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

/// Updates the snapshot config.
pub async fn instance_snapshot_put(configuration: &configuration::Configuration, name: &str, snapshot: &str, project: Option<&str>, snapshot2: Option<models::InstanceSnapshotPut>) -> Result<models::InstancesPut202Response, Error<InstanceSnapshotPutError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_path_snapshot = snapshot;
    let p_query_project = project;
    let p_body_snapshot = snapshot2;

    let uri_str = format!("{}/1.0/instances/{name}/snapshots/{snapshot}", configuration.base_path, name=crate::apis::urlencode(p_path_name), snapshot=crate::apis::urlencode(p_path_snapshot));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_snapshot);

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

/// Returns a list of instance snapshots (URLs).
pub async fn instance_snapshots_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceSnapshotsGet200Response, Error<InstanceSnapshotsGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/snapshots", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Returns a list of instance snapshots (structs).
pub async fn instance_snapshots_get_recursion1(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceSnapshotsGetRecursion1200Response, Error<InstanceSnapshotsGetRecursion1Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/snapshots?recursion=1", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Creates a new snapshot.
pub async fn instance_snapshots_post(configuration: &configuration::Configuration, name: &str, project: Option<&str>, snapshot: Option<models::InstanceSnapshotsPost>) -> Result<models::InstancesPut202Response, Error<InstanceSnapshotsPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_snapshot = snapshot;

    let uri_str = format!("{}/1.0/instances/{name}/snapshots", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_snapshot);

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

/// Gets the runtime state of the instance.  This is a reasonably expensive call as it causes code to be run inside of the instance to retrieve the resource usage and network information.
pub async fn instance_state_get(configuration: &configuration::Configuration, name: &str, project: Option<&str>) -> Result<models::InstanceStateGet200Response, Error<InstanceStateGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;

    let uri_str = format!("{}/1.0/instances/{name}/state", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Changes the running state of the instance.
pub async fn instance_state_put(configuration: &configuration::Configuration, name: &str, project: Option<&str>, state: Option<models::InstanceStatePut>) -> Result<models::InstancesPut202Response, Error<InstanceStatePutError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_name = name;
    let p_query_project = project;
    let p_body_state = state;

    let uri_str = format!("{}/1.0/instances/{name}/state", configuration.base_path, name=crate::apis::urlencode(p_path_name));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_state);

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

/// Returns a list of instances (URLs).
pub async fn instances_get(configuration: &configuration::Configuration, project: Option<&str>, filter: Option<&str>, all_projects: Option<bool>) -> Result<models::InstancesGet200Response, Error<InstancesGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_project = project;
    let p_query_filter = filter;
    let p_query_all_projects = all_projects;

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

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_all_projects {
        req_builder = req_builder.query(&[("all-projects", &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());
    }

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

/// Creates a new instance. Depending on the source, this can create an instance from an existing local image, remote image, existing local instance or snapshot, remote migration stream or backup file.
pub async fn instances_post(configuration: &configuration::Configuration, project: Option<&str>, target: Option<&str>) -> Result<models::InstancesPut202Response, Error<InstancesPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_project = project;
    let p_query_target = target;

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

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }

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

/// Changes the running state of all instances.
pub async fn instances_put(configuration: &configuration::Configuration, project: Option<&str>, state: Option<models::InstancesPut>) -> Result<models::InstancesPut202Response, Error<InstancesPutError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_project = project;
    let p_body_state = state;

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

    if let Some(ref param_value) = p_query_project {
        req_builder = req_builder.query(&[("project", &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());
    }
    req_builder = req_builder.json(&p_body_state);

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