mattermost-client 0.2.0

/*
 * Mattermost API Reference
 *
 * There is also a work-in-progress [Postman API reference](https://documenter.getpostman.com/view/4508214/RW8FERUn).
 *
 * The version of the OpenAPI document: 4.0.0
 * Contact: feedback@mattermost.com
 * Generated by: https://openapi-generator.tech
 */

use reqwest;

use super::ResponseContent;
use super::{Error, configuration};

/// struct for passing parameters to the method [`add_group_members`]
#[derive(Clone, Debug, Default)]
pub struct AddGroupMembersParams {
    /// The ID of the group.
    pub group_id: String,
    pub add_group_members_request: crate::openapi::models::AddGroupMembersRequest,
}

/// struct for passing parameters to the method [`create_group`]
#[derive(Clone, Debug, Default)]
pub struct CreateGroupParams {
    /// Group object and initial members.
    pub create_group_request: crate::openapi::models::CreateGroupRequest,
}

/// struct for passing parameters to the method [`delete_group`]
#[derive(Clone, Debug, Default)]
pub struct DeleteGroupParams {
    /// The ID of the group.
    pub group_id: String,
}

/// struct for passing parameters to the method [`delete_group_members`]
#[derive(Clone, Debug, Default)]
pub struct DeleteGroupMembersParams {
    /// The ID of the group to delete.
    pub group_id: String,
    pub delete_group_members_request: crate::openapi::models::DeleteGroupMembersRequest,
}

/// struct for passing parameters to the method [`get_group`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupParams {
    /// Group GUID
    pub group_id: String,
}

/// struct for passing parameters to the method [`get_group_stats`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupStatsParams {
    /// Group GUID
    pub group_id: String,
}

/// struct for passing parameters to the method [`get_group_syncable_for_channel_id`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupSyncableForChannelIdParams {
    /// Group GUID
    pub group_id: String,
    /// Channel GUID
    pub channel_id: String,
}

/// struct for passing parameters to the method [`get_group_syncable_for_team_id`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupSyncableForTeamIdParams {
    /// Group GUID
    pub group_id: String,
    /// Team GUID
    pub team_id: String,
}

/// struct for passing parameters to the method [`get_group_syncables_channels`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupSyncablesChannelsParams {
    /// Group GUID
    pub group_id: String,
}

/// struct for passing parameters to the method [`get_group_syncables_teams`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupSyncablesTeamsParams {
    /// Group GUID
    pub group_id: String,
}

/// struct for passing parameters to the method [`get_group_users`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupUsersParams {
    /// Group GUID
    pub group_id: String,
    /// The page to select.
    pub page: Option<i32>,
    /// The number of groups per page.
    pub per_page: Option<i32>,
}

/// struct for passing parameters to the method [`get_groups`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupsParams {
    /// Team GUID which is used to return all the groups not associated to this team
    pub not_associated_to_team: String,
    /// Group GUID which is used to return all the groups not associated to this channel
    pub not_associated_to_channel: String,
    /// The page to select.
    pub page: Option<i32>,
    /// The number of groups per page.
    pub per_page: Option<i32>,
    /// String to pattern match the `name` and `display_name` field. Will return all groups whose `name` and `display_name` field match any of the text.
    pub q: Option<String>,
    /// Boolean which adds the `member_count` attribute to each group JSON object
    pub include_member_count: Option<bool>,
    /// Only return groups that have been modified since the given Unix timestamp (in milliseconds). All modified groups, including deleted and created groups, will be returned. __Minimum server version__: 5.24
    pub since: Option<i32>,
    /// Boolean which filters the group entries with the `allow_reference` attribute set.
    pub filter_allow_reference: Option<bool>,
}

/// struct for passing parameters to the method [`get_groups_associated_to_channels_by_team`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupsAssociatedToChannelsByTeamParams {
    /// Team GUID
    pub team_id: String,
    /// The page to select.
    pub page: Option<i32>,
    /// The number of groups per page.
    pub per_page: Option<i32>,
    /// Boolean which filters in the group entries with the `allow_reference` attribute set.
    pub filter_allow_reference: Option<bool>,
    /// Boolean to determine whether the pagination should be applied or not
    pub paginate: Option<bool>,
}

/// struct for passing parameters to the method [`get_groups_by_channel`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupsByChannelParams {
    /// Channel GUID
    pub channel_id: String,
    /// The page to select.
    pub page: Option<i32>,
    /// The number of groups per page.
    pub per_page: Option<i32>,
    /// Boolean which filters the group entries with the `allow_reference` attribute set.
    pub filter_allow_reference: Option<bool>,
}

/// struct for passing parameters to the method [`get_groups_by_team`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupsByTeamParams {
    /// Team GUID
    pub team_id: String,
    /// The page to select.
    pub page: Option<i32>,
    /// The number of groups per page.
    pub per_page: Option<i32>,
    /// Boolean which filters in the group entries with the `allow_reference` attribute set.
    pub filter_allow_reference: Option<bool>,
}

/// struct for passing parameters to the method [`get_groups_by_user_id`]
#[derive(Clone, Debug, Default)]
pub struct GetGroupsByUserIdParams {
    /// User GUID
    pub user_id: String,
}

/// struct for passing parameters to the method [`link_group_syncable_for_channel`]
#[derive(Clone, Debug, Default)]
pub struct LinkGroupSyncableForChannelParams {
    /// Group GUID
    pub group_id: String,
    /// Channel GUID
    pub channel_id: String,
}

/// struct for passing parameters to the method [`link_group_syncable_for_team`]
#[derive(Clone, Debug, Default)]
pub struct LinkGroupSyncableForTeamParams {
    /// Group GUID
    pub group_id: String,
    /// Team GUID
    pub team_id: String,
}

/// struct for passing parameters to the method [`patch_group`]
#[derive(Clone, Debug, Default)]
pub struct PatchGroupParams {
    /// Group GUID
    pub group_id: String,
    /// Group object that is to be updated
    pub patch_group_request: crate::openapi::models::PatchGroupRequest,
}

/// struct for passing parameters to the method [`patch_group_syncable_for_channel`]
#[derive(Clone, Debug, Default)]
pub struct PatchGroupSyncableForChannelParams {
    /// Group GUID
    pub group_id: String,
    /// Channel GUID
    pub channel_id: String,
    /// GroupSyncable object that is to be updated
    pub patch_group_syncable_for_team_request:
        crate::openapi::models::PatchGroupSyncableForTeamRequest,
}

/// struct for passing parameters to the method [`patch_group_syncable_for_team`]
#[derive(Clone, Debug, Default)]
pub struct PatchGroupSyncableForTeamParams {
    /// Group GUID
    pub group_id: String,
    /// Team GUID
    pub team_id: String,
    /// GroupSyncable object that is to be updated
    pub patch_group_syncable_for_team_request:
        crate::openapi::models::PatchGroupSyncableForTeamRequest,
}

/// struct for passing parameters to the method [`unlink_group_syncable_for_channel`]
#[derive(Clone, Debug, Default)]
pub struct UnlinkGroupSyncableForChannelParams {
    /// Group GUID
    pub group_id: String,
    /// Channel GUID
    pub channel_id: String,
}

/// struct for passing parameters to the method [`unlink_group_syncable_for_team`]
#[derive(Clone, Debug, Default)]
pub struct UnlinkGroupSyncableForTeamParams {
    /// Group GUID
    pub group_id: String,
    /// Team GUID
    pub team_id: String,
}

/// struct for passing parameters to the method [`unlink_ldap_group`]
#[derive(Clone, Debug, Default)]
pub struct UnlinkLdapGroupParams {
    /// Group GUID
    pub remote_id: String,
}

/// struct for typed errors of method [`add_group_members`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum AddGroupMembersError {
    Status403(crate::openapi::models::AppError),
    Status501(),
    Status404(),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_group`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum CreateGroupError {
    Status501(),
    Status400(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_group`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum DeleteGroupError {
    Status403(crate::openapi::models::AppError),
    Status501(),
    Status404(),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_group_members`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum DeleteGroupMembersError {
    Status403(crate::openapi::models::AppError),
    Status501(),
    Status404(),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_group`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_group_stats`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupStatsError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status500(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_group_syncable_for_channel_id`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupSyncableForChannelIdError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status500(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_group_syncable_for_team_id`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupSyncableForTeamIdError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status500(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_group_syncables_channels`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupSyncablesChannelsError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status500(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_group_syncables_teams`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupSyncablesTeamsError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status500(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_group_users`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupUsersError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status500(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupsError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_associated_to_channels_by_team`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupsAssociatedToChannelsByTeamError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status500(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_by_channel`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupsByChannelError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status500(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_by_team`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupsByTeamError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status500(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_groups_by_user_id`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum GetGroupsByUserIdError {
    Status400(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`link_group_syncable_for_channel`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum LinkGroupSyncableForChannelError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`link_group_syncable_for_team`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum LinkGroupSyncableForTeamError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_group`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum PatchGroupError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_group_syncable_for_channel`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum PatchGroupSyncableForChannelError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_group_syncable_for_team`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum PatchGroupSyncableForTeamError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`unlink_group_syncable_for_channel`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum UnlinkGroupSyncableForChannelError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`unlink_group_syncable_for_team`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum UnlinkGroupSyncableForTeamError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    Status501(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`unlink_ldap_group`]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum UnlinkLdapGroupError {
    Status400(crate::openapi::models::AppError),
    Status401(crate::openapi::models::AppError),
    Status403(crate::openapi::models::AppError),
    UnknownValue(serde_json::Value),
}

/// Adds members to a custom group.  ##### Permissions Must have `custom_group_manage_members` permission for the given group.  __Minimum server version__: 6.3
pub async fn add_group_members(
    configuration: &configuration::Configuration,
    params: AddGroupMembersParams,
) -> Result<crate::openapi::models::StatusOk, Error<AddGroupMembersError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let add_group_members_request = params.add_group_members_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/members",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };
    local_var_req_builder = local_var_req_builder.json(&add_group_members_request);

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Create a `custom` type group.  #### Permission Must have `create_custom_group` permission.  __Minimum server version__: 6.3
pub async fn create_group(
    configuration: &configuration::Configuration,
    params: CreateGroupParams,
) -> Result<(), Error<CreateGroupError>> {
    let local_var_configuration = configuration;

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

    let local_var_client = &local_var_configuration.client;

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

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };
    local_var_req_builder = local_var_req_builder.json(&create_group_request);

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Soft deletes a custom group.  ##### Permissions Must have `custom_group_delete` permission for the given group.  __Minimum server version__: 6.3
pub async fn delete_group(
    configuration: &configuration::Configuration,
    params: DeleteGroupParams,
) -> Result<crate::openapi::models::StatusOk, Error<DeleteGroupError>> {
    let local_var_configuration = configuration;

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

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Soft deletes a custom group members.  ##### Permissions Must have `custom_group_manage_members` permission for the given group.  __Minimum server version__: 6.3
pub async fn delete_group_members(
    configuration: &configuration::Configuration,
    params: DeleteGroupMembersParams,
) -> Result<crate::openapi::models::StatusOk, Error<DeleteGroupMembersError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let delete_group_members_request = params.delete_group_members_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/members",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };
    local_var_req_builder = local_var_req_builder.json(&delete_group_members_request);

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Get group from the provided group id string  ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn get_group(
    configuration: &configuration::Configuration,
    params: GetGroupParams,
) -> Result<crate::openapi::models::Group, Error<GetGroupError>> {
    let local_var_configuration = configuration;

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

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Retrieve the stats of a given group.  ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.26
pub async fn get_group_stats(
    configuration: &configuration::Configuration,
    params: GetGroupStatsParams,
) -> Result<crate::openapi::models::GetGroupStats200Response, Error<GetGroupStatsError>> {
    let local_var_configuration = configuration;

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

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/stats",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Get the GroupSyncable object with group_id and channel_id from params ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn get_group_syncable_for_channel_id(
    configuration: &configuration::Configuration,
    params: GetGroupSyncableForChannelIdParams,
) -> Result<crate::openapi::models::GroupSyncableChannel, Error<GetGroupSyncableForChannelIdError>>
{
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let channel_id = params.channel_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/channels/{channel_id}",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id),
        channel_id = super::urlencode(channel_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Get the GroupSyncable object with group_id and team_id from params ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn get_group_syncable_for_team_id(
    configuration: &configuration::Configuration,
    params: GetGroupSyncableForTeamIdParams,
) -> Result<crate::openapi::models::GroupSyncableTeam, Error<GetGroupSyncableForTeamIdError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let team_id = params.team_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/teams/{team_id}",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id),
        team_id = super::urlencode(team_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Retrieve the list of channels associated to the group ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn get_group_syncables_channels(
    configuration: &configuration::Configuration,
    params: GetGroupSyncablesChannelsParams,
) -> Result<Vec<crate::openapi::models::GroupSyncableChannels>, Error<GetGroupSyncablesChannelsError>>
{
    let local_var_configuration = configuration;

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

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/channels",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Retrieve the list of teams associated to the group ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn get_group_syncables_teams(
    configuration: &configuration::Configuration,
    params: GetGroupSyncablesTeamsParams,
) -> Result<Vec<crate::openapi::models::GroupSyncableTeams>, Error<GetGroupSyncablesTeamsError>> {
    let local_var_configuration = configuration;

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

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/teams",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Retrieve the list of users associated with a given group.  ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn get_group_users(
    configuration: &configuration::Configuration,
    params: GetGroupUsersParams,
) -> Result<crate::openapi::models::GetGroupUsers200Response, Error<GetGroupUsersError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let page = params.page;
    let per_page = params.per_page;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/members",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_str) = page {
        local_var_req_builder =
            local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = per_page {
        local_var_req_builder =
            local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Retrieve a list of all groups not associated to a particular channel or team.  `not_associated_to_team` **OR** `not_associated_to_channel` is required.  If you use `not_associated_to_team`, you must be a team admin for that particular team (permission to manage that team).  If you use `not_associated_to_channel`, you must be a channel admin for that particular channel (permission to manage that channel).  __Minimum server version__: 5.11
pub async fn get_groups(
    configuration: &configuration::Configuration,
    params: GetGroupsParams,
) -> Result<Vec<crate::openapi::models::Group>, Error<GetGroupsError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let not_associated_to_team = params.not_associated_to_team;
    let not_associated_to_channel = params.not_associated_to_channel;
    let page = params.page;
    let per_page = params.per_page;
    let q = params.q;
    let include_member_count = params.include_member_count;
    let since = params.since;
    let filter_allow_reference = params.filter_allow_reference;

    let local_var_client = &local_var_configuration.client;

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

    if let Some(ref local_var_str) = page {
        local_var_req_builder =
            local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = per_page {
        local_var_req_builder =
            local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = q {
        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = include_member_count {
        local_var_req_builder =
            local_var_req_builder.query(&[("include_member_count", &local_var_str.to_string())]);
    }
    local_var_req_builder = local_var_req_builder.query(&[(
        "not_associated_to_team",
        &not_associated_to_team.to_string(),
    )]);
    local_var_req_builder = local_var_req_builder.query(&[(
        "not_associated_to_channel",
        &not_associated_to_channel.to_string(),
    )]);
    if let Some(ref local_var_str) = since {
        local_var_req_builder =
            local_var_req_builder.query(&[("since", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = filter_allow_reference {
        local_var_req_builder =
            local_var_req_builder.query(&[("filter_allow_reference", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Retrieve the set of groups associated with the channels in the given team grouped by channel.  ##### Permissions Must have `manage_system` permission or can access only for current user  __Minimum server version__: 5.11
pub async fn get_groups_associated_to_channels_by_team(
    configuration: &configuration::Configuration,
    params: GetGroupsAssociatedToChannelsByTeamParams,
) -> Result<
    Vec<::std::collections::HashMap<String, Vec<crate::openapi::models::GroupWithSchemeAdmin>>>,
    Error<GetGroupsAssociatedToChannelsByTeamError>,
> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let team_id = params.team_id;
    let page = params.page;
    let per_page = params.per_page;
    let filter_allow_reference = params.filter_allow_reference;
    let paginate = params.paginate;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/teams/{team_id}/groups_by_channels",
        local_var_configuration.base_path,
        team_id = super::urlencode(team_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_str) = page {
        local_var_req_builder =
            local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = per_page {
        local_var_req_builder =
            local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = filter_allow_reference {
        local_var_req_builder =
            local_var_req_builder.query(&[("filter_allow_reference", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = paginate {
        local_var_req_builder =
            local_var_req_builder.query(&[("paginate", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Retrieve the list of groups associated with a given channel.  ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn get_groups_by_channel(
    configuration: &configuration::Configuration,
    params: GetGroupsByChannelParams,
) -> Result<Vec<crate::openapi::models::Group>, Error<GetGroupsByChannelError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let channel_id = params.channel_id;
    let page = params.page;
    let per_page = params.per_page;
    let filter_allow_reference = params.filter_allow_reference;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/channels/{channel_id}/groups",
        local_var_configuration.base_path,
        channel_id = super::urlencode(channel_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_str) = page {
        local_var_req_builder =
            local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = per_page {
        local_var_req_builder =
            local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = filter_allow_reference {
        local_var_req_builder =
            local_var_req_builder.query(&[("filter_allow_reference", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Retrieve the list of groups associated with a given team.  __Minimum server version__: 5.11
pub async fn get_groups_by_team(
    configuration: &configuration::Configuration,
    params: GetGroupsByTeamParams,
) -> Result<Vec<crate::openapi::models::Group>, Error<GetGroupsByTeamError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let team_id = params.team_id;
    let page = params.page;
    let per_page = params.per_page;
    let filter_allow_reference = params.filter_allow_reference;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/teams/{team_id}/groups",
        local_var_configuration.base_path,
        team_id = super::urlencode(team_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    if let Some(ref local_var_str) = page {
        local_var_req_builder =
            local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = per_page {
        local_var_req_builder =
            local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = filter_allow_reference {
        local_var_req_builder =
            local_var_req_builder.query(&[("filter_allow_reference", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Retrieve the list of groups associated to the user  __Minimum server version__: 5.24
pub async fn get_groups_by_user_id(
    configuration: &configuration::Configuration,
    params: GetGroupsByUserIdParams,
) -> Result<Vec<crate::openapi::models::Group>, Error<GetGroupsByUserIdError>> {
    let local_var_configuration = configuration;

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

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/users/{user_id}/groups",
        local_var_configuration.base_path,
        user_id = super::urlencode(user_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Link a channel to a group ##### Permissions If the channel is private, you must have `manage_private_channel_members` permission. Otherwise, you must have the `manage_public_channel_members` permission.  __Minimum server version__: 5.11
pub async fn link_group_syncable_for_channel(
    configuration: &configuration::Configuration,
    params: LinkGroupSyncableForChannelParams,
) -> Result<crate::openapi::models::GroupSyncableChannel, Error<LinkGroupSyncableForChannelError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let channel_id = params.channel_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/channels/{channel_id}/link",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id),
        channel_id = super::urlencode(channel_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Link a team to a group ##### Permissions Must have `manage_team` permission.  __Minimum server version__: 5.11
pub async fn link_group_syncable_for_team(
    configuration: &configuration::Configuration,
    params: LinkGroupSyncableForTeamParams,
) -> Result<crate::openapi::models::GroupSyncableTeam, Error<LinkGroupSyncableForTeamError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let team_id = params.team_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/teams/{team_id}/link",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id),
        team_id = super::urlencode(team_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Partially update a group by providing only the fields you want to update. Omitted fields will not be updated. The fields that can be updated are defined in the request body, all other provided fields will be ignored.  ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn patch_group(
    configuration: &configuration::Configuration,
    params: PatchGroupParams,
) -> Result<crate::openapi::models::Group, Error<PatchGroupError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let patch_group_request = params.patch_group_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/patch",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };
    local_var_req_builder = local_var_req_builder.json(&patch_group_request);

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Partially update a GroupSyncable by providing only the fields you want to update. Omitted fields will not be updated. The fields that can be updated are defined in the request body, all other provided fields will be ignored.  ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn patch_group_syncable_for_channel(
    configuration: &configuration::Configuration,
    params: PatchGroupSyncableForChannelParams,
) -> Result<crate::openapi::models::GroupSyncableChannel, Error<PatchGroupSyncableForChannelError>>
{
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let channel_id = params.channel_id;
    let patch_group_syncable_for_team_request = params.patch_group_syncable_for_team_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/channels/{channel_id}/patch",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id),
        channel_id = super::urlencode(channel_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };
    local_var_req_builder = local_var_req_builder.json(&patch_group_syncable_for_team_request);

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Partially update a GroupSyncable by providing only the fields you want to update. Omitted fields will not be updated. The fields that can be updated are defined in the request body, all other provided fields will be ignored.  ##### Permissions Must have `manage_system` permission.  __Minimum server version__: 5.11
pub async fn patch_group_syncable_for_team(
    configuration: &configuration::Configuration,
    params: PatchGroupSyncableForTeamParams,
) -> Result<crate::openapi::models::GroupSyncableTeam, Error<PatchGroupSyncableForTeamError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let team_id = params.team_id;
    let patch_group_syncable_for_team_request = params.patch_group_syncable_for_team_request;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/teams/{team_id}/patch",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id),
        team_id = super::urlencode(team_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());

    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
        local_var_req_builder =
            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
    }
    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
    };
    local_var_req_builder = local_var_req_builder.json(&patch_group_syncable_for_team_request);

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Delete a link from a channel to a group ##### Permissions If the channel is private, you must have `manage_private_channel_members` permission. Otherwise, you must have the `manage_public_channel_members` permission.  __Minimum server version__: 5.11
pub async fn unlink_group_syncable_for_channel(
    configuration: &configuration::Configuration,
    params: UnlinkGroupSyncableForChannelParams,
) -> Result<crate::openapi::models::StatusOk, Error<UnlinkGroupSyncableForChannelError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let channel_id = params.channel_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/channels/{channel_id}/link",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id),
        channel_id = super::urlencode(channel_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// Delete a link from a team to a group ##### Permissions Must have `manage_team` permission.  __Minimum server version__: 5.11
pub async fn unlink_group_syncable_for_team(
    configuration: &configuration::Configuration,
    params: UnlinkGroupSyncableForTeamParams,
) -> Result<crate::openapi::models::StatusOk, Error<UnlinkGroupSyncableForTeamError>> {
    let local_var_configuration = configuration;

    // unbox the parameters
    let group_id = params.group_id;
    let team_id = params.team_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/groups/{group_id}/teams/{team_id}/link",
        local_var_configuration.base_path,
        group_id = super::urlencode(group_id),
        team_id = super::urlencode(team_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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

/// ##### Permissions Must have `manage_system` permission. __Minimum server version__: 5.11
pub async fn unlink_ldap_group(
    configuration: &configuration::Configuration,
    params: UnlinkLdapGroupParams,
) -> Result<crate::openapi::models::StatusOk, Error<UnlinkLdapGroupError>> {
    let local_var_configuration = configuration;

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

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/api/v4/ldap/groups/{remote_id}/link",
        local_var_configuration.base_path,
        remote_id = super::urlencode(remote_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

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

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

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

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