/*
 * Exoscale Public API
 *
 *  Infrastructure automation API, allowing programmatic access to all Exoscale products and services.  The [OpenAPI Specification](http://spec.openapis.org/oas/v3.0.3.html) source of this documentation can be obtained here:  * [JSON format](https://openapi-v2.exoscale.com/source.json) * [YAML format](https://openapi-v2.exoscale.com/source.yaml)
 *
 * The version of the OpenAPI document: 2.0.0
 * Contact: api@exoscale.com
 * Generated by: https://openapi-generator.tech
 */

use reqwest;

use super::{configuration, Error};
use crate::apis::ResponseContent;
use crate::sign_request;

/// struct for passing parameters to the method [`create_sks_cluster`]
#[derive(Clone, Debug)]
pub struct CreateSksClusterParams {
    pub create_sks_cluster_request: crate::models::CreateSksClusterRequest,
}

/// struct for passing parameters to the method [`create_sks_nodepool`]
#[derive(Clone, Debug)]
pub struct CreateSksNodepoolParams {
    pub id: String,
    pub create_sks_nodepool_request: crate::models::CreateSksNodepoolRequest,
}

/// struct for passing parameters to the method [`delete_sks_cluster`]
#[derive(Clone, Debug)]
pub struct DeleteSksClusterParams {
    pub id: String,
}

/// struct for passing parameters to the method [`delete_sks_nodepool`]
#[derive(Clone, Debug)]
pub struct DeleteSksNodepoolParams {
    pub id: String,
    pub sks_nodepool_id: String,
}

/// struct for passing parameters to the method [`evict_sks_nodepool_members`]
#[derive(Clone, Debug)]
pub struct EvictSksNodepoolMembersParams {
    pub id: String,
    pub sks_nodepool_id: String,
    pub evict_sks_nodepool_members_request: crate::models::EvictSksNodepoolMembersRequest,
}

/// struct for passing parameters to the method [`generate_sks_cluster_kubeconfig`]
#[derive(Clone, Debug)]
pub struct GenerateSksClusterKubeconfigParams {
    pub id: String,
    pub sks_kubeconfig_request: crate::models::SksKubeconfigRequest,
}

/// struct for passing parameters to the method [`get_sks_cluster`]
#[derive(Clone, Debug)]
pub struct GetSksClusterParams {
    pub id: String,
}

/// struct for passing parameters to the method [`get_sks_cluster_authority_cert`]
#[derive(Clone, Debug)]
pub struct GetSksClusterAuthorityCertParams {
    pub id: String,
    pub authority: String,
}

/// struct for passing parameters to the method [`get_sks_nodepool`]
#[derive(Clone, Debug)]
pub struct GetSksNodepoolParams {
    pub id: String,
    pub sks_nodepool_id: String,
}

/// struct for passing parameters to the method [`list_sks_cluster_deprecated_resources`]
#[derive(Clone, Debug)]
pub struct ListSksClusterDeprecatedResourcesParams {
    pub id: String,
}

/// struct for passing parameters to the method [`list_sks_cluster_versions`]
#[derive(Clone, Debug)]
pub struct ListSksClusterVersionsParams {
    pub include_deprecated: Option<String>,
}

/// struct for passing parameters to the method [`reset_sks_cluster_field`]
#[derive(Clone, Debug)]
pub struct ResetSksClusterFieldParams {
    pub id: String,
    pub field: String,
}

/// struct for passing parameters to the method [`reset_sks_nodepool_field`]
#[derive(Clone, Debug)]
pub struct ResetSksNodepoolFieldParams {
    pub id: String,
    pub sks_nodepool_id: String,
    pub field: String,
}

/// struct for passing parameters to the method [`rotate_sks_ccm_credentials`]
#[derive(Clone, Debug)]
pub struct RotateSksCcmCredentialsParams {
    pub id: String,
}

/// struct for passing parameters to the method [`rotate_sks_operators_ca`]
#[derive(Clone, Debug)]
pub struct RotateSksOperatorsCaParams {
    pub id: String,
}

/// struct for passing parameters to the method [`scale_sks_nodepool`]
#[derive(Clone, Debug)]
pub struct ScaleSksNodepoolParams {
    pub id: String,
    pub sks_nodepool_id: String,
    pub scale_sks_nodepool_request: crate::models::ScaleSksNodepoolRequest,
}

/// struct for passing parameters to the method [`update_sks_cluster`]
#[derive(Clone, Debug)]
pub struct UpdateSksClusterParams {
    pub id: String,
    pub update_sks_cluster_request: crate::models::UpdateSksClusterRequest,
}

/// struct for passing parameters to the method [`update_sks_nodepool`]
#[derive(Clone, Debug)]
pub struct UpdateSksNodepoolParams {
    pub id: String,
    pub sks_nodepool_id: String,
    pub update_sks_nodepool_request: crate::models::UpdateSksNodepoolRequest,
}

/// struct for passing parameters to the method [`upgrade_sks_cluster`]
#[derive(Clone, Debug)]
pub struct UpgradeSksClusterParams {
    pub id: String,
    pub upgrade_sks_cluster_request: crate::models::UpgradeSksClusterRequest,
}

/// struct for passing parameters to the method [`upgrade_sks_cluster_service_level`]
#[derive(Clone, Debug)]
pub struct UpgradeSksClusterServiceLevelParams {
    pub id: String,
}

/// struct for typed errors of method [`create_sks_cluster`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateSksClusterError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_sks_nodepool`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateSksNodepoolError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_sks_cluster`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteSksClusterError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_sks_nodepool`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteSksNodepoolError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`evict_sks_nodepool_members`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EvictSksNodepoolMembersError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`generate_sks_cluster_kubeconfig`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GenerateSksClusterKubeconfigError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_sks_cluster`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSksClusterError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_sks_cluster_authority_cert`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSksClusterAuthorityCertError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_sks_nodepool`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSksNodepoolError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_sks_cluster_deprecated_resources`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListSksClusterDeprecatedResourcesError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_sks_cluster_versions`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListSksClusterVersionsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_sks_clusters`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListSksClustersError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`reset_sks_cluster_field`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ResetSksClusterFieldError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`reset_sks_nodepool_field`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ResetSksNodepoolFieldError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`rotate_sks_ccm_credentials`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RotateSksCcmCredentialsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`rotate_sks_operators_ca`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RotateSksOperatorsCaError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`scale_sks_nodepool`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ScaleSksNodepoolError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`update_sks_cluster`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateSksClusterError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`update_sks_nodepool`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateSksNodepoolError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`upgrade_sks_cluster`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpgradeSksClusterError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`upgrade_sks_cluster_service_level`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpgradeSksClusterServiceLevelError {
    UnknownValue(serde_json::Value),
}

///
pub async fn create_sks_cluster(
    configuration: &configuration::Configuration,
    params: CreateSksClusterParams,
) -> Result<crate::models::Operation, Error<CreateSksClusterError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let create_sks_cluster_request = params.create_sks_cluster_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/sks-cluster", local_var_configuration.base_path);
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    local_var_req_builder = local_var_req_builder.json(&create_sks_cluster_request);

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<CreateSksClusterError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn create_sks_nodepool(
    configuration: &configuration::Configuration,
    params: CreateSksNodepoolParams,
) -> Result<crate::models::Operation, Error<CreateSksNodepoolError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let create_sks_nodepool_request = params.create_sks_nodepool_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/nodepool",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    local_var_req_builder = local_var_req_builder.json(&create_sks_nodepool_request);

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<CreateSksNodepoolError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn delete_sks_cluster(
    configuration: &configuration::Configuration,
    params: DeleteSksClusterParams,
) -> Result<crate::models::Operation, Error<DeleteSksClusterError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DeleteSksClusterError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn delete_sks_nodepool(
    configuration: &configuration::Configuration,
    params: DeleteSksNodepoolParams,
) -> Result<crate::models::Operation, Error<DeleteSksNodepoolError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let sks_nodepool_id = params.sks_nodepool_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/nodepool/{sks_nodepool_id}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id),
        sks_nodepool_id = crate::apis::urlencode(sks_nodepool_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<DeleteSksNodepoolError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// This operation evicts the specified Compute instances member from the Nodepool, shrinking it to `&lt;current nodepool size&gt; - &lt;# evicted members&gt;`.
pub async fn evict_sks_nodepool_members(
    configuration: &configuration::Configuration,
    params: EvictSksNodepoolMembersParams,
) -> Result<crate::models::Operation, Error<EvictSksNodepoolMembersError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let sks_nodepool_id = params.sks_nodepool_id;
    let evict_sks_nodepool_members_request = params.evict_sks_nodepool_members_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/nodepool/{sks_nodepool_id}:evict",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id),
        sks_nodepool_id = crate::apis::urlencode(sks_nodepool_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    local_var_req_builder = local_var_req_builder.json(&evict_sks_nodepool_members_request);

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<EvictSksNodepoolMembersError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// This operation returns a Kubeconfig file encoded in base64.
pub async fn generate_sks_cluster_kubeconfig(
    configuration: &configuration::Configuration,
    params: GenerateSksClusterKubeconfigParams,
) -> Result<
    crate::models::GenerateSksClusterKubeconfig200Response,
    Error<GenerateSksClusterKubeconfigError>,
> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let sks_kubeconfig_request = params.sks_kubeconfig_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster-kubeconfig/{id}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    local_var_req_builder = local_var_req_builder.json(&sks_kubeconfig_request);

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<GenerateSksClusterKubeconfigError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn get_sks_cluster(
    configuration: &configuration::Configuration,
    params: GetSksClusterParams,
) -> Result<crate::models::SksCluster, Error<GetSksClusterError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<GetSksClusterError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// This operation returns the certificate for the given SKS cluster authority encoded in base64.
pub async fn get_sks_cluster_authority_cert(
    configuration: &configuration::Configuration,
    params: GetSksClusterAuthorityCertParams,
) -> Result<
    crate::models::GetSksClusterAuthorityCert200Response,
    Error<GetSksClusterAuthorityCertError>,
> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let authority = params.authority;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/authority/{authority}/cert",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id),
        authority = crate::apis::urlencode(authority)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<GetSksClusterAuthorityCertError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn get_sks_nodepool(
    configuration: &configuration::Configuration,
    params: GetSksNodepoolParams,
) -> Result<crate::models::SksNodepool, Error<GetSksNodepoolError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let sks_nodepool_id = params.sks_nodepool_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/nodepool/{sks_nodepool_id}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id),
        sks_nodepool_id = crate::apis::urlencode(sks_nodepool_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<GetSksNodepoolError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// This operation returns the deprecated resources for a given cluster
pub async fn list_sks_cluster_deprecated_resources(
    configuration: &configuration::Configuration,
    params: ListSksClusterDeprecatedResourcesParams,
) -> Result<
    Vec<::std::collections::HashMap<String, String>>,
    Error<ListSksClusterDeprecatedResourcesError>,
> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster-deprecated-resources/{id}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<ListSksClusterDeprecatedResourcesError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn list_sks_cluster_versions(
    configuration: &configuration::Configuration,
    params: ListSksClusterVersionsParams,
) -> Result<crate::models::ListSksClusterVersions200Response, Error<ListSksClusterVersionsError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let include_deprecated = params.include_deprecated;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/sks-cluster-version", local_var_configuration.base_path);
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_str) = include_deprecated {
        local_var_req_builder =
            local_var_req_builder.query(&[("include-deprecated", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<ListSksClusterVersionsError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn list_sks_clusters(
    configuration: &configuration::Configuration,
) -> Result<crate::models::ListSksClusters200Response, Error<ListSksClustersError>> {
    let local_var_configuration = configuration;

    // unbox the parameters

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!("{}/sks-cluster", local_var_configuration.base_path);
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<ListSksClustersError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn reset_sks_cluster_field(
    configuration: &configuration::Configuration,
    params: ResetSksClusterFieldParams,
) -> Result<crate::models::Operation, Error<ResetSksClusterFieldError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let field = params.field;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/{field}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id),
        field = crate::apis::urlencode(field)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<ResetSksClusterFieldError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn reset_sks_nodepool_field(
    configuration: &configuration::Configuration,
    params: ResetSksNodepoolFieldParams,
) -> Result<crate::models::Operation, Error<ResetSksNodepoolFieldError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let sks_nodepool_id = params.sks_nodepool_id;
    let field = params.field;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/nodepool/{sks_nodepool_id}/{field}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id),
        sks_nodepool_id = crate::apis::urlencode(sks_nodepool_id),
        field = crate::apis::urlencode(field)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<ResetSksNodepoolFieldError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn rotate_sks_ccm_credentials(
    configuration: &configuration::Configuration,
    params: RotateSksCcmCredentialsParams,
) -> Result<crate::models::Operation, Error<RotateSksCcmCredentialsError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/rotate-ccm-credentials",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<RotateSksCcmCredentialsError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn rotate_sks_operators_ca(
    configuration: &configuration::Configuration,
    params: RotateSksOperatorsCaParams,
) -> Result<crate::models::Operation, Error<RotateSksOperatorsCaError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/rotate-operators-ca",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<RotateSksOperatorsCaError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn scale_sks_nodepool(
    configuration: &configuration::Configuration,
    params: ScaleSksNodepoolParams,
) -> Result<crate::models::Operation, Error<ScaleSksNodepoolError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let sks_nodepool_id = params.sks_nodepool_id;
    let scale_sks_nodepool_request = params.scale_sks_nodepool_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/nodepool/{sks_nodepool_id}:scale",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id),
        sks_nodepool_id = crate::apis::urlencode(sks_nodepool_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    local_var_req_builder = local_var_req_builder.json(&scale_sks_nodepool_request);

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<ScaleSksNodepoolError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn update_sks_cluster(
    configuration: &configuration::Configuration,
    params: UpdateSksClusterParams,
) -> Result<crate::models::Operation, Error<UpdateSksClusterError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let update_sks_cluster_request = params.update_sks_cluster_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    local_var_req_builder = local_var_req_builder.json(&update_sks_cluster_request);

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<UpdateSksClusterError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn update_sks_nodepool(
    configuration: &configuration::Configuration,
    params: UpdateSksNodepoolParams,
) -> Result<crate::models::Operation, Error<UpdateSksNodepoolError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let sks_nodepool_id = params.sks_nodepool_id;
    let update_sks_nodepool_request = params.update_sks_nodepool_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/nodepool/{sks_nodepool_id}",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id),
        sks_nodepool_id = crate::apis::urlencode(sks_nodepool_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    local_var_req_builder = local_var_req_builder.json(&update_sks_nodepool_request);

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<UpdateSksNodepoolError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn upgrade_sks_cluster(
    configuration: &configuration::Configuration,
    params: UpgradeSksClusterParams,
) -> Result<crate::models::Operation, Error<UpgradeSksClusterError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;
    let upgrade_sks_cluster_request = params.upgrade_sks_cluster_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/upgrade",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    local_var_req_builder = local_var_req_builder.json(&upgrade_sks_cluster_request);

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<UpgradeSksClusterError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

///
pub async fn upgrade_sks_cluster_service_level(
    configuration: &configuration::Configuration,
    params: UpgradeSksClusterServiceLevelParams,
) -> Result<crate::models::Operation, Error<UpgradeSksClusterServiceLevelError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let id = params.id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/sks-cluster/{id}/upgrade-service-level",
        local_var_configuration.base_path,
        id = crate::apis::urlencode(id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }

    let mut local_var_req = local_var_req_builder.build()?;
    let _ = sign_request(&mut local_var_req, configuration);
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_content = local_var_resp.text().await?;

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        serde_json::from_str(&local_var_content).map_err(Error::from)
    } else {
        let local_var_entity: Option<UpgradeSksClusterServiceLevelError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
        };
        Err(Error::ResponseError(local_var_error))
    }
}