gitbundle_sdk/apis/

groups_api.rs

/*
 * GitBundle API
 *
 * GitBundle API documentation.
 *
 * The version of the OpenAPI document: 3.3.0
 *
 * Generated by: https://openapi-generator.tech
 */

use reqwest;
use serde::{de::Error as _, Deserialize, Serialize};

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

/// struct for typed errors of method [`delete_groups_runner`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteGroupsRunnerError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_groups_variable`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteGroupsVariableError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_member`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteMemberError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_connectors`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetConnectorsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_events`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetEventsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_group`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetGroupError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_reseted_runner_register_token`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetGroupsResetedRunnerRegisterTokenError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_runner`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetGroupsRunnerError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_runner_register_token`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetGroupsRunnerRegisterTokenError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_runners`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetGroupsRunnersError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_variable`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetGroupsVariableError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_variables`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetGroupsVariablesError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_members`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetMembersError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repos`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetReposError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_service_accounts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetServiceAccountsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_sub_groups`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSubGroupsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_group`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchGroupError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_groups_runner`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchGroupsRunnerError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_groups_variable`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchGroupsVariableError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_member`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchMemberError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_group`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostGroupError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_groups_variable`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostGroupsVariableError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_import`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostImportError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_import_repos`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostImportReposError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_member`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostMemberError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_move`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostMoveError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_purge`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostPurgeError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_restore`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostRestoreError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`soft_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SoftDeleteError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

pub async fn delete_groups_runner(
    configuration: &configuration::Configuration,
    group_ref: &str,
    runner_uuid: &str,
) -> Result<(), Error<DeleteGroupsRunnerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_path_runner_uuid = runner_uuid;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/runners/{runner_uuid}",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref),
        runner_uuid = crate::apis::urlencode(p_path_runner_uuid)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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<DeleteGroupsRunnerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn delete_groups_variable(
    configuration: &configuration::Configuration,
    group_ref: &str,
    variable_identifier: &str,
) -> Result<(), Error<DeleteGroupsVariableError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_path_variable_identifier = variable_identifier;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/variables/{variable_identifier}",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref),
        variable_identifier = crate::apis::urlencode(p_path_variable_identifier)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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<DeleteGroupsVariableError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn delete_member(
    configuration: &configuration::Configuration,
    group_ref: &str,
    user_identifier: &str,
) -> Result<(), Error<DeleteMemberError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_path_user_identifier = user_identifier;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/members/{user_identifier}",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref),
        user_identifier = crate::apis::urlencode(p_path_user_identifier)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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<DeleteMemberError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_connectors(
    configuration: &configuration::Configuration,
    group_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
) -> Result<Vec<models::ConnectorModel>, Error<GetConnectorsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/connectors",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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 => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ConnectorModel&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ConnectorModel&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetConnectorsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_events(
    configuration: &configuration::Configuration,
    group_ref: &str,
) -> Result<Vec<i32>, Error<GetEventsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/events",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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 => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;i32&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;i32&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetEventsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_group(
    configuration: &configuration::Configuration,
    group_ref: &str,
) -> Result<models::GroupModel, Error<GetGroupError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;

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

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

pub async fn get_groups_reseted_runner_register_token(
    configuration: &configuration::Configuration,
    group_ref: &str,
) -> Result<models::RegisterTokenModel, Error<GetGroupsResetedRunnerRegisterTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/runners/register_token/reseted",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

pub async fn get_groups_runner(
    configuration: &configuration::Configuration,
    group_ref: &str,
    runner_uuid: &str,
) -> Result<models::RunnerModel, Error<GetGroupsRunnerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_path_runner_uuid = runner_uuid;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/runners/{runner_uuid}",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref),
        runner_uuid = crate::apis::urlencode(p_path_runner_uuid)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

pub async fn get_groups_runner_register_token(
    configuration: &configuration::Configuration,
    group_ref: &str,
) -> Result<models::RegisterTokenModel, Error<GetGroupsRunnerRegisterTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/runners/register_token",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

pub async fn get_groups_runners(
    configuration: &configuration::Configuration,
    group_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
) -> Result<Vec<models::RunnerCreator>, Error<GetGroupsRunnersError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/runners",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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 => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RunnerCreator&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RunnerCreator&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetGroupsRunnersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_groups_variable(
    configuration: &configuration::Configuration,
    group_ref: &str,
    variable_identifier: &str,
) -> Result<models::VariableModel, Error<GetGroupsVariableError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_path_variable_identifier = variable_identifier;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/variables/{variable_identifier}",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref),
        variable_identifier = crate::apis::urlencode(p_path_variable_identifier)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

pub async fn get_groups_variables(
    configuration: &configuration::Configuration,
    group_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    types: Option<Vec<models::VariableType>>,
    sort: Option<models::VariableSort>,
    order: Option<models::OrderOption>,
) -> Result<Vec<models::VariableGroup>, Error<GetGroupsVariablesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_types = types;
    let p_query_sort = sort;
    let p_query_order = order;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/variables",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_types {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .iter()
                    .map(|p| ("types".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "types",
                &param_value
                    .iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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 => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::VariableGroup&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::VariableGroup&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetGroupsVariablesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_members(
    configuration: &configuration::Configuration,
    group_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    sort: Option<models::MembershipSort>,
    order: Option<models::OrderOption>,
) -> Result<Vec<models::MembershipUserGroup>, Error<GetMembersError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_sort = sort;
    let p_query_order = order;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/members",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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 => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::MembershipUserGroup&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::MembershipUserGroup&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetMembersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repos(
    configuration: &configuration::Configuration,
    group_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    sort: Option<models::RepoSort>,
    order: Option<models::OrderOption>,
) -> Result<Vec<models::RepoParent>, Error<GetReposError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_sort = sort;
    let p_query_order = order;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/repos",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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 => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetReposError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_service_accounts(
    configuration: &configuration::Configuration,
    group_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    sort: Option<models::UserSort>,
    order: Option<models::OrderOption>,
) -> Result<Vec<models::UserModel>, Error<GetServiceAccountsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_sort = sort;
    let p_query_order = order;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/service-accounts",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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 => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::UserModel&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::UserModel&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetServiceAccountsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_sub_groups(
    configuration: &configuration::Configuration,
    group_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    sort: Option<models::GroupSort>,
    order: Option<models::OrderOption>,
) -> Result<Vec<models::GroupModel>, Error<GetSubGroupsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_sort = sort;
    let p_query_order = order;

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

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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 => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::GroupModel&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::GroupModel&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSubGroupsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn patch_group(
    configuration: &configuration::Configuration,
    group_ref: &str,
    group_patch_input: models::GroupPatchInput,
) -> Result<models::GroupModel, Error<PatchGroupError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_body_group_patch_input = group_patch_input;

    let uri_str = format!(
        "{}/groups/{group_ref}/+",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_group_patch_input);

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

pub async fn patch_groups_runner(
    configuration: &configuration::Configuration,
    group_ref: &str,
    runner_uuid: &str,
    runner_patch_input: models::RunnerPatchInput,
) -> Result<models::RunnerModel, Error<PatchGroupsRunnerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_path_runner_uuid = runner_uuid;
    let p_body_runner_patch_input = runner_patch_input;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/runners/{runner_uuid}",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref),
        runner_uuid = crate::apis::urlencode(p_path_runner_uuid)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_runner_patch_input);

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

pub async fn patch_groups_variable(
    configuration: &configuration::Configuration,
    group_ref: &str,
    variable_identifier: &str,
    variable_patch_input: models::VariablePatchInput,
) -> Result<models::VariableModel, Error<PatchGroupsVariableError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_path_variable_identifier = variable_identifier;
    let p_body_variable_patch_input = variable_patch_input;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/variables/{variable_identifier}",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref),
        variable_identifier = crate::apis::urlencode(p_path_variable_identifier)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_variable_patch_input);

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

pub async fn patch_member(
    configuration: &configuration::Configuration,
    group_ref: &str,
    user_identifier: &str,
    group_member_update_input: models::GroupMemberUpdateInput,
) -> Result<models::MembershipModel, Error<PatchMemberError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_path_user_identifier = user_identifier;
    let p_body_group_member_update_input = group_member_update_input;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/members/{user_identifier}",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref),
        user_identifier = crate::apis::urlencode(p_path_user_identifier)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_group_member_update_input);

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

pub async fn post_group(
    configuration: &configuration::Configuration,
    group_create_input: models::GroupCreateInput,
) -> Result<models::GroupModel, Error<PostGroupError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_group_create_input = group_create_input;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_group_create_input);

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

pub async fn post_groups_variable(
    configuration: &configuration::Configuration,
    group_ref: &str,
    variable_create_input: models::VariableCreateInput,
) -> Result<models::VariableModel, Error<PostGroupsVariableError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_body_variable_create_input = variable_create_input;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/variables",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_variable_create_input);

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

pub async fn post_import(
    configuration: &configuration::Configuration,
    group_import_input: models::GroupImportInput,
) -> Result<models::GroupModel, Error<PostImportError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_group_import_input = group_import_input;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_group_import_input);

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

pub async fn post_import_repos(
    configuration: &configuration::Configuration,
    group_ref: &str,
    group_import_repos_input: models::GroupImportReposInput,
) -> Result<models::GroupImportReposOutput, Error<PostImportReposError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_body_group_import_repos_input = group_import_repos_input;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/import",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_group_import_repos_input);

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

pub async fn post_member(
    configuration: &configuration::Configuration,
    group_ref: &str,
    group_member_add_input: models::GroupMemberAddInput,
) -> Result<models::MembershipUserGroup, Error<PostMemberError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_body_group_member_add_input = group_member_add_input;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/members",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_group_member_add_input);

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

pub async fn post_move(
    configuration: &configuration::Configuration,
    group_ref: &str,
    group_move_input: models::GroupMoveInput,
) -> Result<models::GroupModel, Error<PostMoveError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_body_group_move_input = group_move_input;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/move",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_group_move_input);

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

pub async fn post_purge(
    configuration: &configuration::Configuration,
    group_ref: &str,
) -> Result<(), Error<PostPurgeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/purge",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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<PostPurgeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_restore(
    configuration: &configuration::Configuration,
    group_ref: &str,
    group_restore_input: models::GroupRestoreInput,
) -> Result<models::GroupModel, Error<PostRestoreError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;
    let p_body_group_restore_input = group_restore_input;

    let uri_str = format!(
        "{}/groups/{group_ref}/+/restore",
        configuration.base_path,
        group_ref = crate::apis::urlencode(p_path_group_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_group_restore_input);

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

pub async fn soft_delete(
    configuration: &configuration::Configuration,
    group_ref: &str,
) -> Result<(), Error<SoftDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_ref = group_ref;

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

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    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<SoftDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}