# coding: utf-8

"""
    Slack Web API

    One way to interact with the Slack platform is its HTTP RPC-based Web API, a collection of methods requiring OAuth 2.0-based user, bot, or workspace tokens blessed with related OAuth scopes.

    The version of the OpenAPI document: 1.7.0
    Generated by OpenAPI Generator (https://openapi-generator.tech)

    Do not edit the class manually.
"""  # noqa: E501

import warnings
from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
from typing import Any, Dict, List, Optional, Tuple, Union
from typing_extensions import Annotated

from pydantic import Field, StrictBool, StrictInt, StrictStr
from typing import Optional
from typing_extensions import Annotated
from slack_beta_ti.models.admin_conversations_archive_schema import AdminConversationsArchiveSchema
from slack_beta_ti.models.admin_conversations_convert_to_private_schema import AdminConversationsConvertToPrivateSchema
from slack_beta_ti.models.admin_conversations_create_schema import AdminConversationsCreateSchema
from slack_beta_ti.models.admin_conversations_delete_schema import AdminConversationsDeleteSchema
from slack_beta_ti.models.admin_conversations_get_conversation_prefs_schema import AdminConversationsGetConversationPrefsSchema
from slack_beta_ti.models.admin_conversations_get_teams_schema import AdminConversationsGetTeamsSchema
from slack_beta_ti.models.admin_conversations_invite_schema import AdminConversationsInviteSchema
from slack_beta_ti.models.admin_conversations_rename_schema import AdminConversationsRenameSchema
from slack_beta_ti.models.admin_conversations_rename_schema1 import AdminConversationsRenameSchema1
from slack_beta_ti.models.admin_conversations_search_schema import AdminConversationsSearchSchema
from slack_beta_ti.models.admin_conversations_set_conversation_prefs_schema import AdminConversationsSetConversationPrefsSchema
from slack_beta_ti.models.admin_conversations_unarchive_schema import AdminConversationsUnarchiveSchema
from slack_beta_ti.models.default_success_template import DefaultSuccessTemplate

from slack_beta_ti.api_client import ApiClient, RequestSerialized
from slack_beta_ti.api_response import ApiResponse
from slack_beta_ti.rest import RESTResponseType


class AdminApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def admin_apps_approve(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:write`")],
        app_id: Annotated[Optional[StrictStr], Field(description="The id of the app to approve.")] = None,
        request_id: Annotated[Optional[StrictStr], Field(description="The id of the request to approve.")] = None,
        team_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_apps_approve

        Approve an app for installation on a workspace.

        :param token: Authentication token. Requires scope: `admin.apps:write` (required)
        :type token: str
        :param app_id: The id of the app to approve.
        :type app_id: str
        :param request_id: The id of the request to approve.
        :type request_id: str
        :param team_id:
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_approve_serialize(
            token=token,
            app_id=app_id,
            request_id=request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_apps_approve_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:write`")],
        app_id: Annotated[Optional[StrictStr], Field(description="The id of the app to approve.")] = None,
        request_id: Annotated[Optional[StrictStr], Field(description="The id of the request to approve.")] = None,
        team_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_apps_approve

        Approve an app for installation on a workspace.

        :param token: Authentication token. Requires scope: `admin.apps:write` (required)
        :type token: str
        :param app_id: The id of the app to approve.
        :type app_id: str
        :param request_id: The id of the request to approve.
        :type request_id: str
        :param team_id:
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_approve_serialize(
            token=token,
            app_id=app_id,
            request_id=request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_apps_approve_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:write`")],
        app_id: Annotated[Optional[StrictStr], Field(description="The id of the app to approve.")] = None,
        request_id: Annotated[Optional[StrictStr], Field(description="The id of the request to approve.")] = None,
        team_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_apps_approve

        Approve an app for installation on a workspace.

        :param token: Authentication token. Requires scope: `admin.apps:write` (required)
        :type token: str
        :param app_id: The id of the app to approve.
        :type app_id: str
        :param request_id: The id of the request to approve.
        :type request_id: str
        :param team_id:
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_approve_serialize(
            token=token,
            app_id=app_id,
            request_id=request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_apps_approve_serialize(
        self,
        token,
        app_id,
        request_id,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if app_id is not None:
            _form_params.append(('app_id', app_id))
        if request_id is not None:
            _form_params.append(('request_id', request_id))
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.apps.approve',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_apps_approved_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        team_id: Optional[StrictStr] = None,
        enterprise_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_apps_approved_list

        List approved apps for an org or workspace.

        :param token: Authentication token. Requires scope: `admin.apps:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param team_id:
        :type team_id: str
        :param enterprise_id:
        :type enterprise_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_approved_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            team_id=team_id,
            enterprise_id=enterprise_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_apps_approved_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        team_id: Optional[StrictStr] = None,
        enterprise_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_apps_approved_list

        List approved apps for an org or workspace.

        :param token: Authentication token. Requires scope: `admin.apps:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param team_id:
        :type team_id: str
        :param enterprise_id:
        :type enterprise_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_approved_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            team_id=team_id,
            enterprise_id=enterprise_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_apps_approved_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        team_id: Optional[StrictStr] = None,
        enterprise_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_apps_approved_list

        List approved apps for an org or workspace.

        :param token: Authentication token. Requires scope: `admin.apps:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param team_id:
        :type team_id: str
        :param enterprise_id:
        :type enterprise_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_approved_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            team_id=team_id,
            enterprise_id=enterprise_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_apps_approved_list_serialize(
        self,
        token,
        limit,
        cursor,
        team_id,
        enterprise_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if token is not None:
            
            _query_params.append(('token', token))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        if enterprise_id is not None:
            
            _query_params.append(('enterprise_id', enterprise_id))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.apps.approved.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_apps_requests_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        team_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_apps_requests_list

        List app requests for a team/workspace.

        :param token: Authentication token. Requires scope: `admin.apps:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param team_id:
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_requests_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_apps_requests_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        team_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_apps_requests_list

        List app requests for a team/workspace.

        :param token: Authentication token. Requires scope: `admin.apps:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param team_id:
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_requests_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_apps_requests_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        team_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_apps_requests_list

        List app requests for a team/workspace.

        :param token: Authentication token. Requires scope: `admin.apps:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param team_id:
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_requests_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_apps_requests_list_serialize(
        self,
        token,
        limit,
        cursor,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if token is not None:
            
            _query_params.append(('token', token))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.apps.requests.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_apps_restrict(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:write`")],
        app_id: Annotated[Optional[StrictStr], Field(description="The id of the app to restrict.")] = None,
        request_id: Annotated[Optional[StrictStr], Field(description="The id of the request to restrict.")] = None,
        team_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_apps_restrict

        Restrict an app for installation on a workspace.

        :param token: Authentication token. Requires scope: `admin.apps:write` (required)
        :type token: str
        :param app_id: The id of the app to restrict.
        :type app_id: str
        :param request_id: The id of the request to restrict.
        :type request_id: str
        :param team_id:
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_restrict_serialize(
            token=token,
            app_id=app_id,
            request_id=request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_apps_restrict_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:write`")],
        app_id: Annotated[Optional[StrictStr], Field(description="The id of the app to restrict.")] = None,
        request_id: Annotated[Optional[StrictStr], Field(description="The id of the request to restrict.")] = None,
        team_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_apps_restrict

        Restrict an app for installation on a workspace.

        :param token: Authentication token. Requires scope: `admin.apps:write` (required)
        :type token: str
        :param app_id: The id of the app to restrict.
        :type app_id: str
        :param request_id: The id of the request to restrict.
        :type request_id: str
        :param team_id:
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_restrict_serialize(
            token=token,
            app_id=app_id,
            request_id=request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_apps_restrict_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:write`")],
        app_id: Annotated[Optional[StrictStr], Field(description="The id of the app to restrict.")] = None,
        request_id: Annotated[Optional[StrictStr], Field(description="The id of the request to restrict.")] = None,
        team_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_apps_restrict

        Restrict an app for installation on a workspace.

        :param token: Authentication token. Requires scope: `admin.apps:write` (required)
        :type token: str
        :param app_id: The id of the app to restrict.
        :type app_id: str
        :param request_id: The id of the request to restrict.
        :type request_id: str
        :param team_id:
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_restrict_serialize(
            token=token,
            app_id=app_id,
            request_id=request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_apps_restrict_serialize(
        self,
        token,
        app_id,
        request_id,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if app_id is not None:
            _form_params.append(('app_id', app_id))
        if request_id is not None:
            _form_params.append(('request_id', request_id))
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.apps.restrict',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_apps_restricted_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        team_id: Optional[StrictStr] = None,
        enterprise_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_apps_restricted_list

        List restricted apps for an org or workspace.

        :param token: Authentication token. Requires scope: `admin.apps:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param team_id:
        :type team_id: str
        :param enterprise_id:
        :type enterprise_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_restricted_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            team_id=team_id,
            enterprise_id=enterprise_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_apps_restricted_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        team_id: Optional[StrictStr] = None,
        enterprise_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_apps_restricted_list

        List restricted apps for an org or workspace.

        :param token: Authentication token. Requires scope: `admin.apps:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param team_id:
        :type team_id: str
        :param enterprise_id:
        :type enterprise_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_restricted_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            team_id=team_id,
            enterprise_id=enterprise_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_apps_restricted_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.apps:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        team_id: Optional[StrictStr] = None,
        enterprise_id: Optional[StrictStr] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_apps_restricted_list

        List restricted apps for an org or workspace.

        :param token: Authentication token. Requires scope: `admin.apps:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param team_id:
        :type team_id: str
        :param enterprise_id:
        :type enterprise_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_apps_restricted_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            team_id=team_id,
            enterprise_id=enterprise_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_apps_restricted_list_serialize(
        self,
        token,
        limit,
        cursor,
        team_id,
        enterprise_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if token is not None:
            
            _query_params.append(('token', token))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        if enterprise_id is not None:
            
            _query_params.append(('enterprise_id', enterprise_id))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.apps.restricted.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_archive(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to archive.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsArchiveSchema:
        """admin_conversations_archive

        Archive a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to archive. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_archive_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsArchiveSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_archive_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to archive.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsArchiveSchema]:
        """admin_conversations_archive

        Archive a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to archive. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_archive_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsArchiveSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_archive_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to archive.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_archive

        Archive a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to archive. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_archive_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsArchiveSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_archive_serialize(
        self,
        token,
        channel_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.archive',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_convert_to_private(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to convert to private.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsConvertToPrivateSchema:
        """admin_conversations_convert_to_private

        Convert a public channel to a private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to convert to private. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_convert_to_private_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsConvertToPrivateSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_convert_to_private_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to convert to private.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsConvertToPrivateSchema]:
        """admin_conversations_convert_to_private

        Convert a public channel to a private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to convert to private. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_convert_to_private_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsConvertToPrivateSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_convert_to_private_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to convert to private.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_convert_to_private

        Convert a public channel to a private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to convert to private. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_convert_to_private_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsConvertToPrivateSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_convert_to_private_serialize(
        self,
        token,
        channel_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.convertToPrivate',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_create(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        name: Annotated[StrictStr, Field(description="Name of the public or private channel to create.")],
        is_private: Annotated[StrictBool, Field(description="When `true`, creates a private channel instead of a public channel")],
        description: Annotated[Optional[StrictStr], Field(description="Description of the public or private channel to create.")] = None,
        org_wide: Annotated[Optional[StrictBool], Field(description="When `true`, the channel will be available org-wide. Note: if the channel is not `org_wide=true`, you must specify a `team_id` for this channel")] = None,
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace to create the channel in. Note: this argument is required unless you set `org_wide=true`.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsCreateSchema:
        """admin_conversations_create

        Create a public or private channel-based conversation.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param name: Name of the public or private channel to create. (required)
        :type name: str
        :param is_private: When `true`, creates a private channel instead of a public channel (required)
        :type is_private: bool
        :param description: Description of the public or private channel to create.
        :type description: str
        :param org_wide: When `true`, the channel will be available org-wide. Note: if the channel is not `org_wide=true`, you must specify a `team_id` for this channel
        :type org_wide: bool
        :param team_id: The workspace to create the channel in. Note: this argument is required unless you set `org_wide=true`.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_create_serialize(
            token=token,
            name=name,
            is_private=is_private,
            description=description,
            org_wide=org_wide,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsCreateSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_create_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        name: Annotated[StrictStr, Field(description="Name of the public or private channel to create.")],
        is_private: Annotated[StrictBool, Field(description="When `true`, creates a private channel instead of a public channel")],
        description: Annotated[Optional[StrictStr], Field(description="Description of the public or private channel to create.")] = None,
        org_wide: Annotated[Optional[StrictBool], Field(description="When `true`, the channel will be available org-wide. Note: if the channel is not `org_wide=true`, you must specify a `team_id` for this channel")] = None,
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace to create the channel in. Note: this argument is required unless you set `org_wide=true`.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsCreateSchema]:
        """admin_conversations_create

        Create a public or private channel-based conversation.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param name: Name of the public or private channel to create. (required)
        :type name: str
        :param is_private: When `true`, creates a private channel instead of a public channel (required)
        :type is_private: bool
        :param description: Description of the public or private channel to create.
        :type description: str
        :param org_wide: When `true`, the channel will be available org-wide. Note: if the channel is not `org_wide=true`, you must specify a `team_id` for this channel
        :type org_wide: bool
        :param team_id: The workspace to create the channel in. Note: this argument is required unless you set `org_wide=true`.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_create_serialize(
            token=token,
            name=name,
            is_private=is_private,
            description=description,
            org_wide=org_wide,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsCreateSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_create_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        name: Annotated[StrictStr, Field(description="Name of the public or private channel to create.")],
        is_private: Annotated[StrictBool, Field(description="When `true`, creates a private channel instead of a public channel")],
        description: Annotated[Optional[StrictStr], Field(description="Description of the public or private channel to create.")] = None,
        org_wide: Annotated[Optional[StrictBool], Field(description="When `true`, the channel will be available org-wide. Note: if the channel is not `org_wide=true`, you must specify a `team_id` for this channel")] = None,
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace to create the channel in. Note: this argument is required unless you set `org_wide=true`.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_create

        Create a public or private channel-based conversation.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param name: Name of the public or private channel to create. (required)
        :type name: str
        :param is_private: When `true`, creates a private channel instead of a public channel (required)
        :type is_private: bool
        :param description: Description of the public or private channel to create.
        :type description: str
        :param org_wide: When `true`, the channel will be available org-wide. Note: if the channel is not `org_wide=true`, you must specify a `team_id` for this channel
        :type org_wide: bool
        :param team_id: The workspace to create the channel in. Note: this argument is required unless you set `org_wide=true`.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_create_serialize(
            token=token,
            name=name,
            is_private=is_private,
            description=description,
            org_wide=org_wide,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsCreateSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_create_serialize(
        self,
        token,
        name,
        is_private,
        description,
        org_wide,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if name is not None:
            _form_params.append(('name', name))
        if description is not None:
            _form_params.append(('description', description))
        if is_private is not None:
            _form_params.append(('is_private', is_private))
        if org_wide is not None:
            _form_params.append(('org_wide', org_wide))
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.create',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_delete(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to delete.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsDeleteSchema:
        """admin_conversations_delete

        Delete a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to delete. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_delete_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsDeleteSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_delete_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to delete.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsDeleteSchema]:
        """admin_conversations_delete

        Delete a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to delete. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_delete_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsDeleteSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_delete_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to delete.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_delete

        Delete a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to delete. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_delete_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsDeleteSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_delete_serialize(
        self,
        token,
        channel_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.delete',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_disconnect_shared(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to be disconnected from some workspaces.")],
        leaving_team_ids: Annotated[Optional[StrictStr], Field(description="The team to be removed from the channel. Currently only a single team id can be specified.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsRenameSchema:
        """admin_conversations_disconnect_shared

        Disconnect a connected channel from one or more workspaces.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to be disconnected from some workspaces. (required)
        :type channel_id: str
        :param leaving_team_ids: The team to be removed from the channel. Currently only a single team id can be specified.
        :type leaving_team_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_disconnect_shared_serialize(
            token=token,
            channel_id=channel_id,
            leaving_team_ids=leaving_team_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsRenameSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_disconnect_shared_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to be disconnected from some workspaces.")],
        leaving_team_ids: Annotated[Optional[StrictStr], Field(description="The team to be removed from the channel. Currently only a single team id can be specified.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsRenameSchema]:
        """admin_conversations_disconnect_shared

        Disconnect a connected channel from one or more workspaces.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to be disconnected from some workspaces. (required)
        :type channel_id: str
        :param leaving_team_ids: The team to be removed from the channel. Currently only a single team id can be specified.
        :type leaving_team_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_disconnect_shared_serialize(
            token=token,
            channel_id=channel_id,
            leaving_team_ids=leaving_team_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsRenameSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_disconnect_shared_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to be disconnected from some workspaces.")],
        leaving_team_ids: Annotated[Optional[StrictStr], Field(description="The team to be removed from the channel. Currently only a single team id can be specified.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_disconnect_shared

        Disconnect a connected channel from one or more workspaces.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to be disconnected from some workspaces. (required)
        :type channel_id: str
        :param leaving_team_ids: The team to be removed from the channel. Currently only a single team id can be specified.
        :type leaving_team_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_disconnect_shared_serialize(
            token=token,
            channel_id=channel_id,
            leaving_team_ids=leaving_team_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsRenameSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_disconnect_shared_serialize(
        self,
        token,
        channel_id,
        leaving_team_ids,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        if leaving_team_ids is not None:
            _form_params.append(('leaving_team_ids', leaving_team_ids))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.disconnectShared',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_ekm_list_original_connected_channel_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_ids: Annotated[Optional[StrictStr], Field(description="A comma-separated list of channels to filter to.")] = None,
        team_ids: Annotated[Optional[StrictStr], Field(description="A comma-separated list of the workspaces to which the channels you would like returned belong.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_conversations_ekm_list_original_connected_channel_info

        List all disconnected channels—i.e., channels that were once connected to other workspaces and then disconnected—and the corresponding original channel IDs for key revocation with EKM.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_ids: A comma-separated list of channels to filter to.
        :type channel_ids: str
        :param team_ids: A comma-separated list of the workspaces to which the channels you would like returned belong.
        :type team_ids: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_ekm_list_original_connected_channel_info_serialize(
            token=token,
            channel_ids=channel_ids,
            team_ids=team_ids,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_ekm_list_original_connected_channel_info_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_ids: Annotated[Optional[StrictStr], Field(description="A comma-separated list of channels to filter to.")] = None,
        team_ids: Annotated[Optional[StrictStr], Field(description="A comma-separated list of the workspaces to which the channels you would like returned belong.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_conversations_ekm_list_original_connected_channel_info

        List all disconnected channels—i.e., channels that were once connected to other workspaces and then disconnected—and the corresponding original channel IDs for key revocation with EKM.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_ids: A comma-separated list of channels to filter to.
        :type channel_ids: str
        :param team_ids: A comma-separated list of the workspaces to which the channels you would like returned belong.
        :type team_ids: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_ekm_list_original_connected_channel_info_serialize(
            token=token,
            channel_ids=channel_ids,
            team_ids=team_ids,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_ekm_list_original_connected_channel_info_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_ids: Annotated[Optional[StrictStr], Field(description="A comma-separated list of channels to filter to.")] = None,
        team_ids: Annotated[Optional[StrictStr], Field(description="A comma-separated list of the workspaces to which the channels you would like returned belong.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_ekm_list_original_connected_channel_info

        List all disconnected channels—i.e., channels that were once connected to other workspaces and then disconnected—and the corresponding original channel IDs for key revocation with EKM.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_ids: A comma-separated list of channels to filter to.
        :type channel_ids: str
        :param team_ids: A comma-separated list of the workspaces to which the channels you would like returned belong.
        :type team_ids: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_ekm_list_original_connected_channel_info_serialize(
            token=token,
            channel_ids=channel_ids,
            team_ids=team_ids,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_ekm_list_original_connected_channel_info_serialize(
        self,
        token,
        channel_ids,
        team_ids,
        limit,
        cursor,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if token is not None:
            
            _query_params.append(('token', token))
            
        if channel_ids is not None:
            
            _query_params.append(('channel_ids', channel_ids))
            
        if team_ids is not None:
            
            _query_params.append(('team_ids', team_ids))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.conversations.ekm.listOriginalConnectedChannelInfo',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_get_conversation_prefs(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to get preferences for.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsGetConversationPrefsSchema:
        """admin_conversations_get_conversation_prefs

        Get conversation preferences for a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_id: The channel to get preferences for. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_get_conversation_prefs_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsGetConversationPrefsSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_get_conversation_prefs_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to get preferences for.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsGetConversationPrefsSchema]:
        """admin_conversations_get_conversation_prefs

        Get conversation preferences for a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_id: The channel to get preferences for. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_get_conversation_prefs_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsGetConversationPrefsSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_get_conversation_prefs_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to get preferences for.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_get_conversation_prefs

        Get conversation preferences for a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_id: The channel to get preferences for. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_get_conversation_prefs_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsGetConversationPrefsSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_get_conversation_prefs_serialize(
        self,
        token,
        channel_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if channel_id is not None:
            
            _query_params.append(('channel_id', channel_id))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.conversations.getConversationPrefs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_get_teams(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to determine connected workspaces within the organization for.")],
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsGetTeamsSchema:
        """admin_conversations_get_teams

        Get all the workspaces a given public or private channel is connected to within this Enterprise org.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_id: The channel to determine connected workspaces within the organization for. (required)
        :type channel_id: str
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_get_teams_serialize(
            token=token,
            channel_id=channel_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsGetTeamsSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_get_teams_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to determine connected workspaces within the organization for.")],
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsGetTeamsSchema]:
        """admin_conversations_get_teams

        Get all the workspaces a given public or private channel is connected to within this Enterprise org.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_id: The channel to determine connected workspaces within the organization for. (required)
        :type channel_id: str
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_get_teams_serialize(
            token=token,
            channel_id=channel_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsGetTeamsSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_get_teams_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to determine connected workspaces within the organization for.")],
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_get_teams

        Get all the workspaces a given public or private channel is connected to within this Enterprise org.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_id: The channel to determine connected workspaces within the organization for. (required)
        :type channel_id: str
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_get_teams_serialize(
            token=token,
            channel_id=channel_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsGetTeamsSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_get_teams_serialize(
        self,
        token,
        channel_id,
        cursor,
        limit,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if channel_id is not None:
            
            _query_params.append(('channel_id', channel_id))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.conversations.getTeams',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_invite(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        user_ids: Annotated[StrictStr, Field(description="The users to invite.")],
        channel_id: Annotated[StrictStr, Field(description="The channel that the users will be invited to.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsInviteSchema:
        """admin_conversations_invite

        Invite a user to a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param user_ids: The users to invite. (required)
        :type user_ids: str
        :param channel_id: The channel that the users will be invited to. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_invite_serialize(
            token=token,
            user_ids=user_ids,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsInviteSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_invite_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        user_ids: Annotated[StrictStr, Field(description="The users to invite.")],
        channel_id: Annotated[StrictStr, Field(description="The channel that the users will be invited to.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsInviteSchema]:
        """admin_conversations_invite

        Invite a user to a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param user_ids: The users to invite. (required)
        :type user_ids: str
        :param channel_id: The channel that the users will be invited to. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_invite_serialize(
            token=token,
            user_ids=user_ids,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsInviteSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_invite_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        user_ids: Annotated[StrictStr, Field(description="The users to invite.")],
        channel_id: Annotated[StrictStr, Field(description="The channel that the users will be invited to.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_invite

        Invite a user to a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param user_ids: The users to invite. (required)
        :type user_ids: str
        :param channel_id: The channel that the users will be invited to. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_invite_serialize(
            token=token,
            user_ids=user_ids,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsInviteSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_invite_serialize(
        self,
        token,
        user_ids,
        channel_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if user_ids is not None:
            _form_params.append(('user_ids', user_ids))
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.invite',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_rename(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to rename.")],
        name: StrictStr,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsRenameSchema1:
        """admin_conversations_rename

        Rename a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to rename. (required)
        :type channel_id: str
        :param name: (required)
        :type name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_rename_serialize(
            token=token,
            channel_id=channel_id,
            name=name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsRenameSchema1",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_rename_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to rename.")],
        name: StrictStr,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsRenameSchema1]:
        """admin_conversations_rename

        Rename a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to rename. (required)
        :type channel_id: str
        :param name: (required)
        :type name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_rename_serialize(
            token=token,
            channel_id=channel_id,
            name=name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsRenameSchema1",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_rename_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to rename.")],
        name: StrictStr,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_rename

        Rename a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to rename. (required)
        :type channel_id: str
        :param name: (required)
        :type name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_rename_serialize(
            token=token,
            channel_id=channel_id,
            name=name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsRenameSchema1",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_rename_serialize(
        self,
        token,
        channel_id,
        name,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        if name is not None:
            _form_params.append(('name', name))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.rename',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_restrict_access_add_group(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        group_id: Annotated[StrictStr, Field(description="The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to be an allowlist for the private channel.")],
        channel_id: Annotated[StrictStr, Field(description="The channel to link this group to.")],
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_conversations_restrict_access_add_group

        Add an allowlist of IDP groups for accessing a channel

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param group_id: The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to be an allowlist for the private channel. (required)
        :type group_id: str
        :param channel_id: The channel to link this group to. (required)
        :type channel_id: str
        :param team_id: The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_restrict_access_add_group_serialize(
            token=token,
            group_id=group_id,
            channel_id=channel_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_restrict_access_add_group_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        group_id: Annotated[StrictStr, Field(description="The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to be an allowlist for the private channel.")],
        channel_id: Annotated[StrictStr, Field(description="The channel to link this group to.")],
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_conversations_restrict_access_add_group

        Add an allowlist of IDP groups for accessing a channel

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param group_id: The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to be an allowlist for the private channel. (required)
        :type group_id: str
        :param channel_id: The channel to link this group to. (required)
        :type channel_id: str
        :param team_id: The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_restrict_access_add_group_serialize(
            token=token,
            group_id=group_id,
            channel_id=channel_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_restrict_access_add_group_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        group_id: Annotated[StrictStr, Field(description="The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to be an allowlist for the private channel.")],
        channel_id: Annotated[StrictStr, Field(description="The channel to link this group to.")],
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_restrict_access_add_group

        Add an allowlist of IDP groups for accessing a channel

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param group_id: The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to be an allowlist for the private channel. (required)
        :type group_id: str
        :param channel_id: The channel to link this group to. (required)
        :type channel_id: str
        :param team_id: The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_restrict_access_add_group_serialize(
            token=token,
            group_id=group_id,
            channel_id=channel_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_restrict_access_add_group_serialize(
        self,
        token,
        group_id,
        channel_id,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if token is not None:
            _form_params.append(('token', token))
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if group_id is not None:
            _form_params.append(('group_id', group_id))
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.restrictAccess.addGroup',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_restrict_access_list_groups(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_id: StrictStr,
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_conversations_restrict_access_list_groups

        List all IDP Groups linked to a channel

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_id: (required)
        :type channel_id: str
        :param team_id: The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_restrict_access_list_groups_serialize(
            token=token,
            channel_id=channel_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_restrict_access_list_groups_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_id: StrictStr,
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_conversations_restrict_access_list_groups

        List all IDP Groups linked to a channel

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_id: (required)
        :type channel_id: str
        :param team_id: The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_restrict_access_list_groups_serialize(
            token=token,
            channel_id=channel_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_restrict_access_list_groups_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        channel_id: StrictStr,
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_restrict_access_list_groups

        List all IDP Groups linked to a channel

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param channel_id: (required)
        :type channel_id: str
        :param team_id: The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_restrict_access_list_groups_serialize(
            token=token,
            channel_id=channel_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_restrict_access_list_groups_serialize(
        self,
        token,
        channel_id,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if token is not None:
            
            _query_params.append(('token', token))
            
        if channel_id is not None:
            
            _query_params.append(('channel_id', channel_id))
            
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.conversations.restrictAccess.listGroups',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_restrict_access_remove_group(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        team_id: Annotated[StrictStr, Field(description="The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.")],
        group_id: Annotated[StrictStr, Field(description="The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to remove from the private channel.")],
        channel_id: Annotated[StrictStr, Field(description="The channel to remove the linked group from.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_conversations_restrict_access_remove_group

        Remove a linked IDP group linked from a private channel

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param team_id: The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization. (required)
        :type team_id: str
        :param group_id: The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to remove from the private channel. (required)
        :type group_id: str
        :param channel_id: The channel to remove the linked group from. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_restrict_access_remove_group_serialize(
            token=token,
            team_id=team_id,
            group_id=group_id,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_restrict_access_remove_group_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        team_id: Annotated[StrictStr, Field(description="The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.")],
        group_id: Annotated[StrictStr, Field(description="The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to remove from the private channel.")],
        channel_id: Annotated[StrictStr, Field(description="The channel to remove the linked group from.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_conversations_restrict_access_remove_group

        Remove a linked IDP group linked from a private channel

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param team_id: The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization. (required)
        :type team_id: str
        :param group_id: The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to remove from the private channel. (required)
        :type group_id: str
        :param channel_id: The channel to remove the linked group from. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_restrict_access_remove_group_serialize(
            token=token,
            team_id=team_id,
            group_id=group_id,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_restrict_access_remove_group_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        team_id: Annotated[StrictStr, Field(description="The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization.")],
        group_id: Annotated[StrictStr, Field(description="The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to remove from the private channel.")],
        channel_id: Annotated[StrictStr, Field(description="The channel to remove the linked group from.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_restrict_access_remove_group

        Remove a linked IDP group linked from a private channel

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param team_id: The workspace where the channel exists. This argument is required for channels only tied to one workspace, and optional for channels that are shared across an organization. (required)
        :type team_id: str
        :param group_id: The [IDP Group](https://slack.com/help/articles/115001435788-Connect-identity-provider-groups-to-your-Enterprise-Grid-org) ID to remove from the private channel. (required)
        :type group_id: str
        :param channel_id: The channel to remove the linked group from. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_restrict_access_remove_group_serialize(
            token=token,
            team_id=team_id,
            group_id=group_id,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_restrict_access_remove_group_serialize(
        self,
        token,
        team_id,
        group_id,
        channel_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if token is not None:
            _form_params.append(('token', token))
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if group_id is not None:
            _form_params.append(('group_id', group_id))
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.restrictAccess.removeGroup',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_search(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        team_ids: Annotated[Optional[StrictStr], Field(description="Comma separated string of team IDs, signifying the workspaces to search through.")] = None,
        query: Annotated[Optional[StrictStr], Field(description="Name of the the channel to query by.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of items to be returned. Must be between 1 - 20 both inclusive. Default is 10.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        search_channel_types: Annotated[Optional[StrictStr], Field(description="The type of channel to include or exclude in the search. For example `private` will search private channels, while `private_exclude` will exclude them. For a full list of types, check the [Types section](#types).")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="Possible values are `relevant` (search ranking based on what we think is closest), `name` (alphabetical), `member_count` (number of users in the channel), and `created` (date channel was created). You can optionally pair this with the `sort_dir` arg to change how it is sorted ")] = None,
        sort_dir: Annotated[Optional[StrictStr], Field(description="Sort direction. Possible values are `asc` for ascending order like (1, 2, 3) or (a, b, c), and `desc` for descending order like (3, 2, 1) or (c, b, a)")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsSearchSchema:
        """admin_conversations_search

        Search for public or private channels in an Enterprise organization.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param team_ids: Comma separated string of team IDs, signifying the workspaces to search through.
        :type team_ids: str
        :param query: Name of the the channel to query by.
        :type query: str
        :param limit: Maximum number of items to be returned. Must be between 1 - 20 both inclusive. Default is 10.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :param search_channel_types: The type of channel to include or exclude in the search. For example `private` will search private channels, while `private_exclude` will exclude them. For a full list of types, check the [Types section](#types).
        :type search_channel_types: str
        :param sort: Possible values are `relevant` (search ranking based on what we think is closest), `name` (alphabetical), `member_count` (number of users in the channel), and `created` (date channel was created). You can optionally pair this with the `sort_dir` arg to change how it is sorted 
        :type sort: str
        :param sort_dir: Sort direction. Possible values are `asc` for ascending order like (1, 2, 3) or (a, b, c), and `desc` for descending order like (3, 2, 1) or (c, b, a)
        :type sort_dir: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_search_serialize(
            token=token,
            team_ids=team_ids,
            query=query,
            limit=limit,
            cursor=cursor,
            search_channel_types=search_channel_types,
            sort=sort,
            sort_dir=sort_dir,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsSearchSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_search_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        team_ids: Annotated[Optional[StrictStr], Field(description="Comma separated string of team IDs, signifying the workspaces to search through.")] = None,
        query: Annotated[Optional[StrictStr], Field(description="Name of the the channel to query by.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of items to be returned. Must be between 1 - 20 both inclusive. Default is 10.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        search_channel_types: Annotated[Optional[StrictStr], Field(description="The type of channel to include or exclude in the search. For example `private` will search private channels, while `private_exclude` will exclude them. For a full list of types, check the [Types section](#types).")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="Possible values are `relevant` (search ranking based on what we think is closest), `name` (alphabetical), `member_count` (number of users in the channel), and `created` (date channel was created). You can optionally pair this with the `sort_dir` arg to change how it is sorted ")] = None,
        sort_dir: Annotated[Optional[StrictStr], Field(description="Sort direction. Possible values are `asc` for ascending order like (1, 2, 3) or (a, b, c), and `desc` for descending order like (3, 2, 1) or (c, b, a)")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsSearchSchema]:
        """admin_conversations_search

        Search for public or private channels in an Enterprise organization.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param team_ids: Comma separated string of team IDs, signifying the workspaces to search through.
        :type team_ids: str
        :param query: Name of the the channel to query by.
        :type query: str
        :param limit: Maximum number of items to be returned. Must be between 1 - 20 both inclusive. Default is 10.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :param search_channel_types: The type of channel to include or exclude in the search. For example `private` will search private channels, while `private_exclude` will exclude them. For a full list of types, check the [Types section](#types).
        :type search_channel_types: str
        :param sort: Possible values are `relevant` (search ranking based on what we think is closest), `name` (alphabetical), `member_count` (number of users in the channel), and `created` (date channel was created). You can optionally pair this with the `sort_dir` arg to change how it is sorted 
        :type sort: str
        :param sort_dir: Sort direction. Possible values are `asc` for ascending order like (1, 2, 3) or (a, b, c), and `desc` for descending order like (3, 2, 1) or (c, b, a)
        :type sort_dir: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_search_serialize(
            token=token,
            team_ids=team_ids,
            query=query,
            limit=limit,
            cursor=cursor,
            search_channel_types=search_channel_types,
            sort=sort,
            sort_dir=sort_dir,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsSearchSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_search_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:read`")],
        team_ids: Annotated[Optional[StrictStr], Field(description="Comma separated string of team IDs, signifying the workspaces to search through.")] = None,
        query: Annotated[Optional[StrictStr], Field(description="Name of the the channel to query by.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of items to be returned. Must be between 1 - 20 both inclusive. Default is 10.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        search_channel_types: Annotated[Optional[StrictStr], Field(description="The type of channel to include or exclude in the search. For example `private` will search private channels, while `private_exclude` will exclude them. For a full list of types, check the [Types section](#types).")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="Possible values are `relevant` (search ranking based on what we think is closest), `name` (alphabetical), `member_count` (number of users in the channel), and `created` (date channel was created). You can optionally pair this with the `sort_dir` arg to change how it is sorted ")] = None,
        sort_dir: Annotated[Optional[StrictStr], Field(description="Sort direction. Possible values are `asc` for ascending order like (1, 2, 3) or (a, b, c), and `desc` for descending order like (3, 2, 1) or (c, b, a)")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_search

        Search for public or private channels in an Enterprise organization.

        :param token: Authentication token. Requires scope: `admin.conversations:read` (required)
        :type token: str
        :param team_ids: Comma separated string of team IDs, signifying the workspaces to search through.
        :type team_ids: str
        :param query: Name of the the channel to query by.
        :type query: str
        :param limit: Maximum number of items to be returned. Must be between 1 - 20 both inclusive. Default is 10.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :param search_channel_types: The type of channel to include or exclude in the search. For example `private` will search private channels, while `private_exclude` will exclude them. For a full list of types, check the [Types section](#types).
        :type search_channel_types: str
        :param sort: Possible values are `relevant` (search ranking based on what we think is closest), `name` (alphabetical), `member_count` (number of users in the channel), and `created` (date channel was created). You can optionally pair this with the `sort_dir` arg to change how it is sorted 
        :type sort: str
        :param sort_dir: Sort direction. Possible values are `asc` for ascending order like (1, 2, 3) or (a, b, c), and `desc` for descending order like (3, 2, 1) or (c, b, a)
        :type sort_dir: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_search_serialize(
            token=token,
            team_ids=team_ids,
            query=query,
            limit=limit,
            cursor=cursor,
            search_channel_types=search_channel_types,
            sort=sort,
            sort_dir=sort_dir,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsSearchSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_search_serialize(
        self,
        token,
        team_ids,
        query,
        limit,
        cursor,
        search_channel_types,
        sort,
        sort_dir,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if team_ids is not None:
            
            _query_params.append(('team_ids', team_ids))
            
        if query is not None:
            
            _query_params.append(('query', query))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if search_channel_types is not None:
            
            _query_params.append(('search_channel_types', search_channel_types))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        if sort_dir is not None:
            
            _query_params.append(('sort_dir', sort_dir))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.conversations.search',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_set_conversation_prefs(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to set the prefs for")],
        prefs: Annotated[StrictStr, Field(description="The prefs for this channel in a stringified JSON format.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsSetConversationPrefsSchema:
        """admin_conversations_set_conversation_prefs

        Set the posting permissions for a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to set the prefs for (required)
        :type channel_id: str
        :param prefs: The prefs for this channel in a stringified JSON format. (required)
        :type prefs: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_set_conversation_prefs_serialize(
            token=token,
            channel_id=channel_id,
            prefs=prefs,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsSetConversationPrefsSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_set_conversation_prefs_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to set the prefs for")],
        prefs: Annotated[StrictStr, Field(description="The prefs for this channel in a stringified JSON format.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsSetConversationPrefsSchema]:
        """admin_conversations_set_conversation_prefs

        Set the posting permissions for a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to set the prefs for (required)
        :type channel_id: str
        :param prefs: The prefs for this channel in a stringified JSON format. (required)
        :type prefs: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_set_conversation_prefs_serialize(
            token=token,
            channel_id=channel_id,
            prefs=prefs,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsSetConversationPrefsSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_set_conversation_prefs_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to set the prefs for")],
        prefs: Annotated[StrictStr, Field(description="The prefs for this channel in a stringified JSON format.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_set_conversation_prefs

        Set the posting permissions for a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to set the prefs for (required)
        :type channel_id: str
        :param prefs: The prefs for this channel in a stringified JSON format. (required)
        :type prefs: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_set_conversation_prefs_serialize(
            token=token,
            channel_id=channel_id,
            prefs=prefs,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsSetConversationPrefsSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_set_conversation_prefs_serialize(
        self,
        token,
        channel_id,
        prefs,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        if prefs is not None:
            _form_params.append(('prefs', prefs))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.setConversationPrefs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_set_teams(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The encoded `channel_id` to add or remove to workspaces.")],
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace to which the channel belongs. Omit this argument if the channel is a cross-workspace shared channel.")] = None,
        target_team_ids: Annotated[Optional[StrictStr], Field(description="A comma-separated list of workspaces to which the channel should be shared. Not required if the channel is being shared org-wide.")] = None,
        org_channel: Annotated[Optional[StrictBool], Field(description="True if channel has to be converted to an org channel")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_conversations_set_teams

        Set the workspaces in an Enterprise grid org that connect to a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The encoded `channel_id` to add or remove to workspaces. (required)
        :type channel_id: str
        :param team_id: The workspace to which the channel belongs. Omit this argument if the channel is a cross-workspace shared channel.
        :type team_id: str
        :param target_team_ids: A comma-separated list of workspaces to which the channel should be shared. Not required if the channel is being shared org-wide.
        :type target_team_ids: str
        :param org_channel: True if channel has to be converted to an org channel
        :type org_channel: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_set_teams_serialize(
            token=token,
            channel_id=channel_id,
            team_id=team_id,
            target_team_ids=target_team_ids,
            org_channel=org_channel,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_set_teams_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The encoded `channel_id` to add or remove to workspaces.")],
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace to which the channel belongs. Omit this argument if the channel is a cross-workspace shared channel.")] = None,
        target_team_ids: Annotated[Optional[StrictStr], Field(description="A comma-separated list of workspaces to which the channel should be shared. Not required if the channel is being shared org-wide.")] = None,
        org_channel: Annotated[Optional[StrictBool], Field(description="True if channel has to be converted to an org channel")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_conversations_set_teams

        Set the workspaces in an Enterprise grid org that connect to a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The encoded `channel_id` to add or remove to workspaces. (required)
        :type channel_id: str
        :param team_id: The workspace to which the channel belongs. Omit this argument if the channel is a cross-workspace shared channel.
        :type team_id: str
        :param target_team_ids: A comma-separated list of workspaces to which the channel should be shared. Not required if the channel is being shared org-wide.
        :type target_team_ids: str
        :param org_channel: True if channel has to be converted to an org channel
        :type org_channel: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_set_teams_serialize(
            token=token,
            channel_id=channel_id,
            team_id=team_id,
            target_team_ids=target_team_ids,
            org_channel=org_channel,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_set_teams_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The encoded `channel_id` to add or remove to workspaces.")],
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace to which the channel belongs. Omit this argument if the channel is a cross-workspace shared channel.")] = None,
        target_team_ids: Annotated[Optional[StrictStr], Field(description="A comma-separated list of workspaces to which the channel should be shared. Not required if the channel is being shared org-wide.")] = None,
        org_channel: Annotated[Optional[StrictBool], Field(description="True if channel has to be converted to an org channel")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_set_teams

        Set the workspaces in an Enterprise grid org that connect to a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The encoded `channel_id` to add or remove to workspaces. (required)
        :type channel_id: str
        :param team_id: The workspace to which the channel belongs. Omit this argument if the channel is a cross-workspace shared channel.
        :type team_id: str
        :param target_team_ids: A comma-separated list of workspaces to which the channel should be shared. Not required if the channel is being shared org-wide.
        :type target_team_ids: str
        :param org_channel: True if channel has to be converted to an org channel
        :type org_channel: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_set_teams_serialize(
            token=token,
            channel_id=channel_id,
            team_id=team_id,
            target_team_ids=target_team_ids,
            org_channel=org_channel,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_set_teams_serialize(
        self,
        token,
        channel_id,
        team_id,
        target_team_ids,
        org_channel,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if target_team_ids is not None:
            _form_params.append(('target_team_ids', target_team_ids))
        if org_channel is not None:
            _form_params.append(('org_channel', org_channel))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.setTeams',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_conversations_unarchive(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to unarchive.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> AdminConversationsUnarchiveSchema:
        """admin_conversations_unarchive

        Unarchive a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to unarchive. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_unarchive_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsUnarchiveSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_conversations_unarchive_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to unarchive.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[AdminConversationsUnarchiveSchema]:
        """admin_conversations_unarchive

        Unarchive a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to unarchive. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_unarchive_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsUnarchiveSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_conversations_unarchive_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.conversations:write`")],
        channel_id: Annotated[StrictStr, Field(description="The channel to unarchive.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_conversations_unarchive

        Unarchive a public or private channel.

        :param token: Authentication token. Requires scope: `admin.conversations:write` (required)
        :type token: str
        :param channel_id: The channel to unarchive. (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_conversations_unarchive_serialize(
            token=token,
            channel_id=channel_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AdminConversationsUnarchiveSchema",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_conversations_unarchive_serialize(
        self,
        token,
        channel_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if channel_id is not None:
            _form_params.append(('channel_id', channel_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.conversations.unarchive',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_emoji_add(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        url: Annotated[StrictStr, Field(description="The URL of a file to use as an image for the emoji. Square images under 128KB and with transparent backgrounds work best.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_emoji_add

        Add an emoji.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :param url: The URL of a file to use as an image for the emoji. Square images under 128KB and with transparent backgrounds work best. (required)
        :type url: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_add_serialize(
            token=token,
            name=name,
            url=url,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_emoji_add_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        url: Annotated[StrictStr, Field(description="The URL of a file to use as an image for the emoji. Square images under 128KB and with transparent backgrounds work best.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_emoji_add

        Add an emoji.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :param url: The URL of a file to use as an image for the emoji. Square images under 128KB and with transparent backgrounds work best. (required)
        :type url: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_add_serialize(
            token=token,
            name=name,
            url=url,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_emoji_add_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        url: Annotated[StrictStr, Field(description="The URL of a file to use as an image for the emoji. Square images under 128KB and with transparent backgrounds work best.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_emoji_add

        Add an emoji.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :param url: The URL of a file to use as an image for the emoji. Square images under 128KB and with transparent backgrounds work best. (required)
        :type url: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_add_serialize(
            token=token,
            name=name,
            url=url,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_emoji_add_serialize(
        self,
        token,
        name,
        url,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if token is not None:
            _form_params.append(('token', token))
        if name is not None:
            _form_params.append(('name', name))
        if url is not None:
            _form_params.append(('url', url))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.emoji.add',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_emoji_add_alias(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be aliased. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        alias_for: Annotated[StrictStr, Field(description="The alias of the emoji.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_emoji_add_alias

        Add an emoji alias.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be aliased. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :param alias_for: The alias of the emoji. (required)
        :type alias_for: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_add_alias_serialize(
            token=token,
            name=name,
            alias_for=alias_for,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_emoji_add_alias_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be aliased. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        alias_for: Annotated[StrictStr, Field(description="The alias of the emoji.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_emoji_add_alias

        Add an emoji alias.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be aliased. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :param alias_for: The alias of the emoji. (required)
        :type alias_for: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_add_alias_serialize(
            token=token,
            name=name,
            alias_for=alias_for,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_emoji_add_alias_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be aliased. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        alias_for: Annotated[StrictStr, Field(description="The alias of the emoji.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_emoji_add_alias

        Add an emoji alias.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be aliased. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :param alias_for: The alias of the emoji. (required)
        :type alias_for: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_add_alias_serialize(
            token=token,
            name=name,
            alias_for=alias_for,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_emoji_add_alias_serialize(
        self,
        token,
        name,
        alias_for,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if token is not None:
            _form_params.append(('token', token))
        if name is not None:
            _form_params.append(('name', name))
        if alias_for is not None:
            _form_params.append(('alias_for', alias_for))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.emoji.addAlias',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_emoji_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_emoji_list

        List emoji for an Enterprise Grid organization.

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_list_serialize(
            token=token,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_emoji_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_emoji_list

        List emoji for an Enterprise Grid organization.

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_list_serialize(
            token=token,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_emoji_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_emoji_list

        List emoji for an Enterprise Grid organization.

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page
        :type cursor: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_list_serialize(
            token=token,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_emoji_list_serialize(
        self,
        token,
        cursor,
        limit,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if token is not None:
            
            _query_params.append(('token', token))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.emoji.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_emoji_remove(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_emoji_remove

        Remove an emoji across an Enterprise Grid organization

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_remove_serialize(
            token=token,
            name=name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_emoji_remove_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_emoji_remove

        Remove an emoji across an Enterprise Grid organization

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_remove_serialize(
            token=token,
            name=name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_emoji_remove_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_emoji_remove

        Remove an emoji across an Enterprise Grid organization

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be removed. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_remove_serialize(
            token=token,
            name=name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_emoji_remove_serialize(
        self,
        token,
        name,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if token is not None:
            _form_params.append(('token', token))
        if name is not None:
            _form_params.append(('name', name))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.emoji.remove',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_emoji_rename(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be renamed. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        new_name: Annotated[StrictStr, Field(description="The new name of the emoji.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_emoji_rename

        Rename an emoji.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be renamed. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :param new_name: The new name of the emoji. (required)
        :type new_name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_rename_serialize(
            token=token,
            name=name,
            new_name=new_name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_emoji_rename_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be renamed. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        new_name: Annotated[StrictStr, Field(description="The new name of the emoji.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_emoji_rename

        Rename an emoji.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be renamed. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :param new_name: The new name of the emoji. (required)
        :type new_name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_rename_serialize(
            token=token,
            name=name,
            new_name=new_name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_emoji_rename_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        name: Annotated[StrictStr, Field(description="The name of the emoji to be renamed. Colons (`:myemoji:`) around the value are not required, although they may be included.")],
        new_name: Annotated[StrictStr, Field(description="The new name of the emoji.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_emoji_rename

        Rename an emoji.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param name: The name of the emoji to be renamed. Colons (`:myemoji:`) around the value are not required, although they may be included. (required)
        :type name: str
        :param new_name: The new name of the emoji. (required)
        :type new_name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_emoji_rename_serialize(
            token=token,
            name=name,
            new_name=new_name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_emoji_rename_serialize(
        self,
        token,
        name,
        new_name,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if token is not None:
            _form_params.append(('token', token))
        if name is not None:
            _form_params.append(('name', name))
        if new_name is not None:
            _form_params.append(('new_name', new_name))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.emoji.rename',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_invite_requests_approve(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:write`")],
        invite_request_id: Annotated[StrictStr, Field(description="ID of the request to invite.")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite request was made.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_invite_requests_approve

        Approve a workspace invite request.

        :param token: Authentication token. Requires scope: `admin.invites:write` (required)
        :type token: str
        :param invite_request_id: ID of the request to invite. (required)
        :type invite_request_id: str
        :param team_id: ID for the workspace where the invite request was made.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_approve_serialize(
            token=token,
            invite_request_id=invite_request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_invite_requests_approve_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:write`")],
        invite_request_id: Annotated[StrictStr, Field(description="ID of the request to invite.")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite request was made.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_invite_requests_approve

        Approve a workspace invite request.

        :param token: Authentication token. Requires scope: `admin.invites:write` (required)
        :type token: str
        :param invite_request_id: ID of the request to invite. (required)
        :type invite_request_id: str
        :param team_id: ID for the workspace where the invite request was made.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_approve_serialize(
            token=token,
            invite_request_id=invite_request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_invite_requests_approve_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:write`")],
        invite_request_id: Annotated[StrictStr, Field(description="ID of the request to invite.")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite request was made.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_invite_requests_approve

        Approve a workspace invite request.

        :param token: Authentication token. Requires scope: `admin.invites:write` (required)
        :type token: str
        :param invite_request_id: ID of the request to invite. (required)
        :type invite_request_id: str
        :param team_id: ID for the workspace where the invite request was made.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_approve_serialize(
            token=token,
            invite_request_id=invite_request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_invite_requests_approve_serialize(
        self,
        token,
        invite_request_id,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if invite_request_id is not None:
            _form_params.append(('invite_request_id', invite_request_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.inviteRequests.approve',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_invite_requests_approved_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:read`")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite requests were made.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Value of the `next_cursor` field sent as part of the previous API response")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_invite_requests_approved_list

        List all approved workspace invite requests.

        :param token: Authentication token. Requires scope: `admin.invites:read` (required)
        :type token: str
        :param team_id: ID for the workspace where the invite requests were made.
        :type team_id: str
        :param cursor: Value of the `next_cursor` field sent as part of the previous API response
        :type cursor: str
        :param limit: The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_approved_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_invite_requests_approved_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:read`")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite requests were made.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Value of the `next_cursor` field sent as part of the previous API response")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_invite_requests_approved_list

        List all approved workspace invite requests.

        :param token: Authentication token. Requires scope: `admin.invites:read` (required)
        :type token: str
        :param team_id: ID for the workspace where the invite requests were made.
        :type team_id: str
        :param cursor: Value of the `next_cursor` field sent as part of the previous API response
        :type cursor: str
        :param limit: The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_approved_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_invite_requests_approved_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:read`")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite requests were made.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Value of the `next_cursor` field sent as part of the previous API response")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_invite_requests_approved_list

        List all approved workspace invite requests.

        :param token: Authentication token. Requires scope: `admin.invites:read` (required)
        :type token: str
        :param team_id: ID for the workspace where the invite requests were made.
        :type team_id: str
        :param cursor: Value of the `next_cursor` field sent as part of the previous API response
        :type cursor: str
        :param limit: The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_approved_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_invite_requests_approved_list_serialize(
        self,
        token,
        team_id,
        cursor,
        limit,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.inviteRequests.approved.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_invite_requests_denied_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:read`")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite requests were made.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Value of the `next_cursor` field sent as part of the previous api response")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The number of results that will be returned by the API on each invocation. Must be between 1 - 1000 both inclusive")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_invite_requests_denied_list

        List all denied workspace invite requests.

        :param token: Authentication token. Requires scope: `admin.invites:read` (required)
        :type token: str
        :param team_id: ID for the workspace where the invite requests were made.
        :type team_id: str
        :param cursor: Value of the `next_cursor` field sent as part of the previous api response
        :type cursor: str
        :param limit: The number of results that will be returned by the API on each invocation. Must be between 1 - 1000 both inclusive
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_denied_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_invite_requests_denied_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:read`")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite requests were made.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Value of the `next_cursor` field sent as part of the previous api response")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The number of results that will be returned by the API on each invocation. Must be between 1 - 1000 both inclusive")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_invite_requests_denied_list

        List all denied workspace invite requests.

        :param token: Authentication token. Requires scope: `admin.invites:read` (required)
        :type token: str
        :param team_id: ID for the workspace where the invite requests were made.
        :type team_id: str
        :param cursor: Value of the `next_cursor` field sent as part of the previous api response
        :type cursor: str
        :param limit: The number of results that will be returned by the API on each invocation. Must be between 1 - 1000 both inclusive
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_denied_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_invite_requests_denied_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:read`")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite requests were made.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Value of the `next_cursor` field sent as part of the previous api response")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The number of results that will be returned by the API on each invocation. Must be between 1 - 1000 both inclusive")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_invite_requests_denied_list

        List all denied workspace invite requests.

        :param token: Authentication token. Requires scope: `admin.invites:read` (required)
        :type token: str
        :param team_id: ID for the workspace where the invite requests were made.
        :type team_id: str
        :param cursor: Value of the `next_cursor` field sent as part of the previous api response
        :type cursor: str
        :param limit: The number of results that will be returned by the API on each invocation. Must be between 1 - 1000 both inclusive
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_denied_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_invite_requests_denied_list_serialize(
        self,
        token,
        team_id,
        cursor,
        limit,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.inviteRequests.denied.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_invite_requests_deny(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:write`")],
        invite_request_id: Annotated[StrictStr, Field(description="ID of the request to invite.")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite request was made.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_invite_requests_deny

        Deny a workspace invite request.

        :param token: Authentication token. Requires scope: `admin.invites:write` (required)
        :type token: str
        :param invite_request_id: ID of the request to invite. (required)
        :type invite_request_id: str
        :param team_id: ID for the workspace where the invite request was made.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_deny_serialize(
            token=token,
            invite_request_id=invite_request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_invite_requests_deny_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:write`")],
        invite_request_id: Annotated[StrictStr, Field(description="ID of the request to invite.")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite request was made.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_invite_requests_deny

        Deny a workspace invite request.

        :param token: Authentication token. Requires scope: `admin.invites:write` (required)
        :type token: str
        :param invite_request_id: ID of the request to invite. (required)
        :type invite_request_id: str
        :param team_id: ID for the workspace where the invite request was made.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_deny_serialize(
            token=token,
            invite_request_id=invite_request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_invite_requests_deny_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:write`")],
        invite_request_id: Annotated[StrictStr, Field(description="ID of the request to invite.")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite request was made.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_invite_requests_deny

        Deny a workspace invite request.

        :param token: Authentication token. Requires scope: `admin.invites:write` (required)
        :type token: str
        :param invite_request_id: ID of the request to invite. (required)
        :type invite_request_id: str
        :param team_id: ID for the workspace where the invite request was made.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_deny_serialize(
            token=token,
            invite_request_id=invite_request_id,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_invite_requests_deny_serialize(
        self,
        token,
        invite_request_id,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if invite_request_id is not None:
            _form_params.append(('invite_request_id', invite_request_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.inviteRequests.deny',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_invite_requests_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:read`")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite requests were made.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Value of the `next_cursor` field sent as part of the previous API response")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_invite_requests_list

        List all pending workspace invite requests.

        :param token: Authentication token. Requires scope: `admin.invites:read` (required)
        :type token: str
        :param team_id: ID for the workspace where the invite requests were made.
        :type team_id: str
        :param cursor: Value of the `next_cursor` field sent as part of the previous API response
        :type cursor: str
        :param limit: The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_invite_requests_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:read`")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite requests were made.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Value of the `next_cursor` field sent as part of the previous API response")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_invite_requests_list

        List all pending workspace invite requests.

        :param token: Authentication token. Requires scope: `admin.invites:read` (required)
        :type token: str
        :param team_id: ID for the workspace where the invite requests were made.
        :type team_id: str
        :param cursor: Value of the `next_cursor` field sent as part of the previous API response
        :type cursor: str
        :param limit: The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_invite_requests_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.invites:read`")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID for the workspace where the invite requests were made.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Value of the `next_cursor` field sent as part of the previous API response")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_invite_requests_list

        List all pending workspace invite requests.

        :param token: Authentication token. Requires scope: `admin.invites:read` (required)
        :type token: str
        :param team_id: ID for the workspace where the invite requests were made.
        :type team_id: str
        :param cursor: Value of the `next_cursor` field sent as part of the previous API response
        :type cursor: str
        :param limit: The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_invite_requests_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_invite_requests_list_serialize(
        self,
        token,
        team_id,
        cursor,
        limit,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.inviteRequests.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_admins_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        team_id: StrictStr,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_admins_list

        List all of the admins on a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param team_id: (required)
        :type team_id: str
        :param limit: The maximum number of items to return.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_admins_list_serialize(
            token=token,
            team_id=team_id,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_admins_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        team_id: StrictStr,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_admins_list

        List all of the admins on a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param team_id: (required)
        :type team_id: str
        :param limit: The maximum number of items to return.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_admins_list_serialize(
            token=token,
            team_id=team_id,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_admins_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        team_id: StrictStr,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_admins_list

        List all of the admins on a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param team_id: (required)
        :type team_id: str
        :param limit: The maximum number of items to return.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_admins_list_serialize(
            token=token,
            team_id=team_id,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_admins_list_serialize(
        self,
        token,
        team_id,
        limit,
        cursor,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if token is not None:
            
            _query_params.append(('token', token))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.teams.admins.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_create(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_domain: Annotated[StrictStr, Field(description="Team domain (for example, slacksoftballteam).")],
        team_name: Annotated[StrictStr, Field(description="Team name (for example, Slack Softball Team).")],
        team_description: Annotated[Optional[StrictStr], Field(description="Description for the team.")] = None,
        team_discoverability: Annotated[Optional[StrictStr], Field(description="Who can join the team. A team's discoverability can be `open`, `closed`, `invite_only`, or `unlisted`.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_create

        Create an Enterprise team.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_domain: Team domain (for example, slacksoftballteam). (required)
        :type team_domain: str
        :param team_name: Team name (for example, Slack Softball Team). (required)
        :type team_name: str
        :param team_description: Description for the team.
        :type team_description: str
        :param team_discoverability: Who can join the team. A team's discoverability can be `open`, `closed`, `invite_only`, or `unlisted`.
        :type team_discoverability: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_create_serialize(
            token=token,
            team_domain=team_domain,
            team_name=team_name,
            team_description=team_description,
            team_discoverability=team_discoverability,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_create_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_domain: Annotated[StrictStr, Field(description="Team domain (for example, slacksoftballteam).")],
        team_name: Annotated[StrictStr, Field(description="Team name (for example, Slack Softball Team).")],
        team_description: Annotated[Optional[StrictStr], Field(description="Description for the team.")] = None,
        team_discoverability: Annotated[Optional[StrictStr], Field(description="Who can join the team. A team's discoverability can be `open`, `closed`, `invite_only`, or `unlisted`.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_create

        Create an Enterprise team.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_domain: Team domain (for example, slacksoftballteam). (required)
        :type team_domain: str
        :param team_name: Team name (for example, Slack Softball Team). (required)
        :type team_name: str
        :param team_description: Description for the team.
        :type team_description: str
        :param team_discoverability: Who can join the team. A team's discoverability can be `open`, `closed`, `invite_only`, or `unlisted`.
        :type team_discoverability: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_create_serialize(
            token=token,
            team_domain=team_domain,
            team_name=team_name,
            team_description=team_description,
            team_discoverability=team_discoverability,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_create_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_domain: Annotated[StrictStr, Field(description="Team domain (for example, slacksoftballteam).")],
        team_name: Annotated[StrictStr, Field(description="Team name (for example, Slack Softball Team).")],
        team_description: Annotated[Optional[StrictStr], Field(description="Description for the team.")] = None,
        team_discoverability: Annotated[Optional[StrictStr], Field(description="Who can join the team. A team's discoverability can be `open`, `closed`, `invite_only`, or `unlisted`.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_create

        Create an Enterprise team.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_domain: Team domain (for example, slacksoftballteam). (required)
        :type team_domain: str
        :param team_name: Team name (for example, Slack Softball Team). (required)
        :type team_name: str
        :param team_description: Description for the team.
        :type team_description: str
        :param team_discoverability: Who can join the team. A team's discoverability can be `open`, `closed`, `invite_only`, or `unlisted`.
        :type team_discoverability: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_create_serialize(
            token=token,
            team_domain=team_domain,
            team_name=team_name,
            team_description=team_description,
            team_discoverability=team_discoverability,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_create_serialize(
        self,
        token,
        team_domain,
        team_name,
        team_description,
        team_discoverability,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_domain is not None:
            _form_params.append(('team_domain', team_domain))
        if team_name is not None:
            _form_params.append(('team_name', team_name))
        if team_description is not None:
            _form_params.append(('team_description', team_description))
        if team_discoverability is not None:
            _form_params.append(('team_discoverability', team_discoverability))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.teams.create',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 100 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_list

        List all teams on an Enterprise organization

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 100 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 100 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_list

        List all teams on an Enterprise organization

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 100 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 100 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_list

        List all teams on an Enterprise organization

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param limit: The maximum number of items to return. Must be between 1 - 100 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_list_serialize(
            token=token,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_list_serialize(
        self,
        token,
        limit,
        cursor,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.teams.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_owners_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        team_id: StrictStr,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_owners_list

        List all of the owners on a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param team_id: (required)
        :type team_id: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_owners_list_serialize(
            token=token,
            team_id=team_id,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_owners_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        team_id: StrictStr,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_owners_list

        List all of the owners on a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param team_id: (required)
        :type team_id: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_owners_list_serialize(
            token=token,
            team_id=team_id,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_owners_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        team_id: StrictStr,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of items to return. Must be between 1 - 1000 both inclusive.")] = None,
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_owners_list

        List all of the owners on a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param team_id: (required)
        :type team_id: str
        :param limit: The maximum number of items to return. Must be between 1 - 1000 both inclusive.
        :type limit: int
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_owners_list_serialize(
            token=token,
            team_id=team_id,
            limit=limit,
            cursor=cursor,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_owners_list_serialize(
        self,
        token,
        team_id,
        limit,
        cursor,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if token is not None:
            
            _query_params.append(('token', token))
            
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.teams.owners.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_settings_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        team_id: StrictStr,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_settings_info

        Fetch information about settings in a workspace

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param team_id: (required)
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_info_serialize(
            token=token,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_settings_info_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        team_id: StrictStr,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_settings_info

        Fetch information about settings in a workspace

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param team_id: (required)
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_info_serialize(
            token=token,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_settings_info_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:read`")],
        team_id: StrictStr,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_settings_info

        Fetch information about settings in a workspace

        :param token: Authentication token. Requires scope: `admin.teams:read` (required)
        :type token: str
        :param team_id: (required)
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_info_serialize(
            token=token,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_settings_info_serialize(
        self,
        token,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.teams.settings.info',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_settings_set_default_channels(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the default channel for.")],
        channel_ids: Annotated[StrictStr, Field(description="An array of channel IDs.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_settings_set_default_channels

        Set the default channels of a workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: ID for the workspace to set the default channel for. (required)
        :type team_id: str
        :param channel_ids: An array of channel IDs. (required)
        :type channel_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_default_channels_serialize(
            token=token,
            team_id=team_id,
            channel_ids=channel_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_settings_set_default_channels_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the default channel for.")],
        channel_ids: Annotated[StrictStr, Field(description="An array of channel IDs.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_settings_set_default_channels

        Set the default channels of a workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: ID for the workspace to set the default channel for. (required)
        :type team_id: str
        :param channel_ids: An array of channel IDs. (required)
        :type channel_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_default_channels_serialize(
            token=token,
            team_id=team_id,
            channel_ids=channel_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_settings_set_default_channels_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the default channel for.")],
        channel_ids: Annotated[StrictStr, Field(description="An array of channel IDs.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_settings_set_default_channels

        Set the default channels of a workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: ID for the workspace to set the default channel for. (required)
        :type team_id: str
        :param channel_ids: An array of channel IDs. (required)
        :type channel_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_default_channels_serialize(
            token=token,
            team_id=team_id,
            channel_ids=channel_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_settings_set_default_channels_serialize(
        self,
        token,
        team_id,
        channel_ids,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if token is not None:
            _form_params.append(('token', token))
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if channel_ids is not None:
            _form_params.append(('channel_ids', channel_ids))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.teams.settings.setDefaultChannels',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_settings_set_description(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the description for.")],
        description: Annotated[StrictStr, Field(description="The new description for the workspace.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_settings_set_description

        Set the description of a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: ID for the workspace to set the description for. (required)
        :type team_id: str
        :param description: The new description for the workspace. (required)
        :type description: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_description_serialize(
            token=token,
            team_id=team_id,
            description=description,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_settings_set_description_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the description for.")],
        description: Annotated[StrictStr, Field(description="The new description for the workspace.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_settings_set_description

        Set the description of a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: ID for the workspace to set the description for. (required)
        :type team_id: str
        :param description: The new description for the workspace. (required)
        :type description: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_description_serialize(
            token=token,
            team_id=team_id,
            description=description,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_settings_set_description_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the description for.")],
        description: Annotated[StrictStr, Field(description="The new description for the workspace.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_settings_set_description

        Set the description of a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: ID for the workspace to set the description for. (required)
        :type team_id: str
        :param description: The new description for the workspace. (required)
        :type description: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_description_serialize(
            token=token,
            team_id=team_id,
            description=description,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_settings_set_description_serialize(
        self,
        token,
        team_id,
        description,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if description is not None:
            _form_params.append(('description', description))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.teams.settings.setDescription',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_settings_set_discoverability(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID of the workspace to set discoverability on.")],
        discoverability: Annotated[StrictStr, Field(description="This workspace's discovery setting. It must be set to one of `open`, `invite_only`, `closed`, or `unlisted`.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_settings_set_discoverability

        An API method that allows admins to set the discoverability of a given workspace

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: The ID of the workspace to set discoverability on. (required)
        :type team_id: str
        :param discoverability: This workspace's discovery setting. It must be set to one of `open`, `invite_only`, `closed`, or `unlisted`. (required)
        :type discoverability: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_discoverability_serialize(
            token=token,
            team_id=team_id,
            discoverability=discoverability,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_settings_set_discoverability_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID of the workspace to set discoverability on.")],
        discoverability: Annotated[StrictStr, Field(description="This workspace's discovery setting. It must be set to one of `open`, `invite_only`, `closed`, or `unlisted`.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_settings_set_discoverability

        An API method that allows admins to set the discoverability of a given workspace

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: The ID of the workspace to set discoverability on. (required)
        :type team_id: str
        :param discoverability: This workspace's discovery setting. It must be set to one of `open`, `invite_only`, `closed`, or `unlisted`. (required)
        :type discoverability: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_discoverability_serialize(
            token=token,
            team_id=team_id,
            discoverability=discoverability,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_settings_set_discoverability_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID of the workspace to set discoverability on.")],
        discoverability: Annotated[StrictStr, Field(description="This workspace's discovery setting. It must be set to one of `open`, `invite_only`, `closed`, or `unlisted`.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_settings_set_discoverability

        An API method that allows admins to set the discoverability of a given workspace

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: The ID of the workspace to set discoverability on. (required)
        :type team_id: str
        :param discoverability: This workspace's discovery setting. It must be set to one of `open`, `invite_only`, `closed`, or `unlisted`. (required)
        :type discoverability: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_discoverability_serialize(
            token=token,
            team_id=team_id,
            discoverability=discoverability,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_settings_set_discoverability_serialize(
        self,
        token,
        team_id,
        discoverability,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if discoverability is not None:
            _form_params.append(('discoverability', discoverability))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.teams.settings.setDiscoverability',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_settings_set_icon(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        image_url: Annotated[StrictStr, Field(description="Image URL for the icon")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the icon for.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_settings_set_icon

        Sets the icon of a workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param image_url: Image URL for the icon (required)
        :type image_url: str
        :param team_id: ID for the workspace to set the icon for. (required)
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_icon_serialize(
            token=token,
            image_url=image_url,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_settings_set_icon_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        image_url: Annotated[StrictStr, Field(description="Image URL for the icon")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the icon for.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_settings_set_icon

        Sets the icon of a workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param image_url: Image URL for the icon (required)
        :type image_url: str
        :param team_id: ID for the workspace to set the icon for. (required)
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_icon_serialize(
            token=token,
            image_url=image_url,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_settings_set_icon_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        image_url: Annotated[StrictStr, Field(description="Image URL for the icon")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the icon for.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_settings_set_icon

        Sets the icon of a workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param image_url: Image URL for the icon (required)
        :type image_url: str
        :param team_id: ID for the workspace to set the icon for. (required)
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_icon_serialize(
            token=token,
            image_url=image_url,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_settings_set_icon_serialize(
        self,
        token,
        image_url,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if token is not None:
            _form_params.append(('token', token))
        if image_url is not None:
            _form_params.append(('image_url', image_url))
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.teams.settings.setIcon',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_teams_settings_set_name(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the name for.")],
        name: Annotated[StrictStr, Field(description="The new name of the workspace.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_teams_settings_set_name

        Set the name of a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: ID for the workspace to set the name for. (required)
        :type team_id: str
        :param name: The new name of the workspace. (required)
        :type name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_name_serialize(
            token=token,
            team_id=team_id,
            name=name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_teams_settings_set_name_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the name for.")],
        name: Annotated[StrictStr, Field(description="The new name of the workspace.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_teams_settings_set_name

        Set the name of a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: ID for the workspace to set the name for. (required)
        :type team_id: str
        :param name: The new name of the workspace. (required)
        :type name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_name_serialize(
            token=token,
            team_id=team_id,
            name=name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_teams_settings_set_name_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        team_id: Annotated[StrictStr, Field(description="ID for the workspace to set the name for.")],
        name: Annotated[StrictStr, Field(description="The new name of the workspace.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_teams_settings_set_name

        Set the name of a given workspace.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param team_id: ID for the workspace to set the name for. (required)
        :type team_id: str
        :param name: The new name of the workspace. (required)
        :type name: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_teams_settings_set_name_serialize(
            token=token,
            team_id=team_id,
            name=name,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_teams_settings_set_name_serialize(
        self,
        token,
        team_id,
        name,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if name is not None:
            _form_params.append(('name', name))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.teams.settings.setName',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_usergroups_add_channels(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.usergroups:write`")],
        usergroup_id: Annotated[StrictStr, Field(description="ID of the IDP group to add default channels for.")],
        channel_ids: Annotated[StrictStr, Field(description="Comma separated string of channel IDs.")],
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace to add default channels in.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_usergroups_add_channels

        Add one or more default channels to an IDP group.

        :param token: Authentication token. Requires scope: `admin.usergroups:write` (required)
        :type token: str
        :param usergroup_id: ID of the IDP group to add default channels for. (required)
        :type usergroup_id: str
        :param channel_ids: Comma separated string of channel IDs. (required)
        :type channel_ids: str
        :param team_id: The workspace to add default channels in.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_add_channels_serialize(
            token=token,
            usergroup_id=usergroup_id,
            channel_ids=channel_ids,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_usergroups_add_channels_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.usergroups:write`")],
        usergroup_id: Annotated[StrictStr, Field(description="ID of the IDP group to add default channels for.")],
        channel_ids: Annotated[StrictStr, Field(description="Comma separated string of channel IDs.")],
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace to add default channels in.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_usergroups_add_channels

        Add one or more default channels to an IDP group.

        :param token: Authentication token. Requires scope: `admin.usergroups:write` (required)
        :type token: str
        :param usergroup_id: ID of the IDP group to add default channels for. (required)
        :type usergroup_id: str
        :param channel_ids: Comma separated string of channel IDs. (required)
        :type channel_ids: str
        :param team_id: The workspace to add default channels in.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_add_channels_serialize(
            token=token,
            usergroup_id=usergroup_id,
            channel_ids=channel_ids,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_usergroups_add_channels_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.usergroups:write`")],
        usergroup_id: Annotated[StrictStr, Field(description="ID of the IDP group to add default channels for.")],
        channel_ids: Annotated[StrictStr, Field(description="Comma separated string of channel IDs.")],
        team_id: Annotated[Optional[StrictStr], Field(description="The workspace to add default channels in.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_usergroups_add_channels

        Add one or more default channels to an IDP group.

        :param token: Authentication token. Requires scope: `admin.usergroups:write` (required)
        :type token: str
        :param usergroup_id: ID of the IDP group to add default channels for. (required)
        :type usergroup_id: str
        :param channel_ids: Comma separated string of channel IDs. (required)
        :type channel_ids: str
        :param team_id: The workspace to add default channels in.
        :type team_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_add_channels_serialize(
            token=token,
            usergroup_id=usergroup_id,
            channel_ids=channel_ids,
            team_id=team_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_usergroups_add_channels_serialize(
        self,
        token,
        usergroup_id,
        channel_ids,
        team_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if usergroup_id is not None:
            _form_params.append(('usergroup_id', usergroup_id))
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if channel_ids is not None:
            _form_params.append(('channel_ids', channel_ids))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.usergroups.addChannels',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_usergroups_add_teams(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        usergroup_id: Annotated[StrictStr, Field(description="An encoded usergroup (IDP Group) ID.")],
        team_ids: Annotated[StrictStr, Field(description="A comma separated list of encoded team (workspace) IDs. Each workspace *MUST* belong to the organization associated with the token.")],
        auto_provision: Annotated[Optional[StrictBool], Field(description="When `true`, this method automatically creates new workspace accounts for the IDP group members.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_usergroups_add_teams

        Associate one or more default workspaces with an organization-wide IDP group.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param usergroup_id: An encoded usergroup (IDP Group) ID. (required)
        :type usergroup_id: str
        :param team_ids: A comma separated list of encoded team (workspace) IDs. Each workspace *MUST* belong to the organization associated with the token. (required)
        :type team_ids: str
        :param auto_provision: When `true`, this method automatically creates new workspace accounts for the IDP group members.
        :type auto_provision: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_add_teams_serialize(
            token=token,
            usergroup_id=usergroup_id,
            team_ids=team_ids,
            auto_provision=auto_provision,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_usergroups_add_teams_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        usergroup_id: Annotated[StrictStr, Field(description="An encoded usergroup (IDP Group) ID.")],
        team_ids: Annotated[StrictStr, Field(description="A comma separated list of encoded team (workspace) IDs. Each workspace *MUST* belong to the organization associated with the token.")],
        auto_provision: Annotated[Optional[StrictBool], Field(description="When `true`, this method automatically creates new workspace accounts for the IDP group members.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_usergroups_add_teams

        Associate one or more default workspaces with an organization-wide IDP group.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param usergroup_id: An encoded usergroup (IDP Group) ID. (required)
        :type usergroup_id: str
        :param team_ids: A comma separated list of encoded team (workspace) IDs. Each workspace *MUST* belong to the organization associated with the token. (required)
        :type team_ids: str
        :param auto_provision: When `true`, this method automatically creates new workspace accounts for the IDP group members.
        :type auto_provision: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_add_teams_serialize(
            token=token,
            usergroup_id=usergroup_id,
            team_ids=team_ids,
            auto_provision=auto_provision,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_usergroups_add_teams_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.teams:write`")],
        usergroup_id: Annotated[StrictStr, Field(description="An encoded usergroup (IDP Group) ID.")],
        team_ids: Annotated[StrictStr, Field(description="A comma separated list of encoded team (workspace) IDs. Each workspace *MUST* belong to the organization associated with the token.")],
        auto_provision: Annotated[Optional[StrictBool], Field(description="When `true`, this method automatically creates new workspace accounts for the IDP group members.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_usergroups_add_teams

        Associate one or more default workspaces with an organization-wide IDP group.

        :param token: Authentication token. Requires scope: `admin.teams:write` (required)
        :type token: str
        :param usergroup_id: An encoded usergroup (IDP Group) ID. (required)
        :type usergroup_id: str
        :param team_ids: A comma separated list of encoded team (workspace) IDs. Each workspace *MUST* belong to the organization associated with the token. (required)
        :type team_ids: str
        :param auto_provision: When `true`, this method automatically creates new workspace accounts for the IDP group members.
        :type auto_provision: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_add_teams_serialize(
            token=token,
            usergroup_id=usergroup_id,
            team_ids=team_ids,
            auto_provision=auto_provision,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_usergroups_add_teams_serialize(
        self,
        token,
        usergroup_id,
        team_ids,
        auto_provision,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if usergroup_id is not None:
            _form_params.append(('usergroup_id', usergroup_id))
        if team_ids is not None:
            _form_params.append(('team_ids', team_ids))
        if auto_provision is not None:
            _form_params.append(('auto_provision', auto_provision))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.usergroups.addTeams',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_usergroups_list_channels(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.usergroups:read`")],
        usergroup_id: Annotated[StrictStr, Field(description="ID of the IDP group to list default channels for.")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID of the the workspace.")] = None,
        include_num_members: Annotated[Optional[StrictBool], Field(description="Flag to include or exclude the count of members per channel.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_usergroups_list_channels

        List the channels linked to an org-level IDP group (user group).

        :param token: Authentication token. Requires scope: `admin.usergroups:read` (required)
        :type token: str
        :param usergroup_id: ID of the IDP group to list default channels for. (required)
        :type usergroup_id: str
        :param team_id: ID of the the workspace.
        :type team_id: str
        :param include_num_members: Flag to include or exclude the count of members per channel.
        :type include_num_members: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_list_channels_serialize(
            token=token,
            usergroup_id=usergroup_id,
            team_id=team_id,
            include_num_members=include_num_members,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_usergroups_list_channels_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.usergroups:read`")],
        usergroup_id: Annotated[StrictStr, Field(description="ID of the IDP group to list default channels for.")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID of the the workspace.")] = None,
        include_num_members: Annotated[Optional[StrictBool], Field(description="Flag to include or exclude the count of members per channel.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_usergroups_list_channels

        List the channels linked to an org-level IDP group (user group).

        :param token: Authentication token. Requires scope: `admin.usergroups:read` (required)
        :type token: str
        :param usergroup_id: ID of the IDP group to list default channels for. (required)
        :type usergroup_id: str
        :param team_id: ID of the the workspace.
        :type team_id: str
        :param include_num_members: Flag to include or exclude the count of members per channel.
        :type include_num_members: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_list_channels_serialize(
            token=token,
            usergroup_id=usergroup_id,
            team_id=team_id,
            include_num_members=include_num_members,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_usergroups_list_channels_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.usergroups:read`")],
        usergroup_id: Annotated[StrictStr, Field(description="ID of the IDP group to list default channels for.")],
        team_id: Annotated[Optional[StrictStr], Field(description="ID of the the workspace.")] = None,
        include_num_members: Annotated[Optional[StrictBool], Field(description="Flag to include or exclude the count of members per channel.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_usergroups_list_channels

        List the channels linked to an org-level IDP group (user group).

        :param token: Authentication token. Requires scope: `admin.usergroups:read` (required)
        :type token: str
        :param usergroup_id: ID of the IDP group to list default channels for. (required)
        :type usergroup_id: str
        :param team_id: ID of the the workspace.
        :type team_id: str
        :param include_num_members: Flag to include or exclude the count of members per channel.
        :type include_num_members: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_list_channels_serialize(
            token=token,
            usergroup_id=usergroup_id,
            team_id=team_id,
            include_num_members=include_num_members,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_usergroups_list_channels_serialize(
        self,
        token,
        usergroup_id,
        team_id,
        include_num_members,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if usergroup_id is not None:
            
            _query_params.append(('usergroup_id', usergroup_id))
            
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        if include_num_members is not None:
            
            _query_params.append(('include_num_members', include_num_members))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.usergroups.listChannels',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_usergroups_remove_channels(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.usergroups:write`")],
        usergroup_id: Annotated[StrictStr, Field(description="ID of the IDP Group")],
        channel_ids: Annotated[StrictStr, Field(description="Comma-separated string of channel IDs")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_usergroups_remove_channels

        Remove one or more default channels from an org-level IDP group (user group).

        :param token: Authentication token. Requires scope: `admin.usergroups:write` (required)
        :type token: str
        :param usergroup_id: ID of the IDP Group (required)
        :type usergroup_id: str
        :param channel_ids: Comma-separated string of channel IDs (required)
        :type channel_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_remove_channels_serialize(
            token=token,
            usergroup_id=usergroup_id,
            channel_ids=channel_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_usergroups_remove_channels_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.usergroups:write`")],
        usergroup_id: Annotated[StrictStr, Field(description="ID of the IDP Group")],
        channel_ids: Annotated[StrictStr, Field(description="Comma-separated string of channel IDs")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_usergroups_remove_channels

        Remove one or more default channels from an org-level IDP group (user group).

        :param token: Authentication token. Requires scope: `admin.usergroups:write` (required)
        :type token: str
        :param usergroup_id: ID of the IDP Group (required)
        :type usergroup_id: str
        :param channel_ids: Comma-separated string of channel IDs (required)
        :type channel_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_remove_channels_serialize(
            token=token,
            usergroup_id=usergroup_id,
            channel_ids=channel_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_usergroups_remove_channels_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.usergroups:write`")],
        usergroup_id: Annotated[StrictStr, Field(description="ID of the IDP Group")],
        channel_ids: Annotated[StrictStr, Field(description="Comma-separated string of channel IDs")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_usergroups_remove_channels

        Remove one or more default channels from an org-level IDP group (user group).

        :param token: Authentication token. Requires scope: `admin.usergroups:write` (required)
        :type token: str
        :param usergroup_id: ID of the IDP Group (required)
        :type usergroup_id: str
        :param channel_ids: Comma-separated string of channel IDs (required)
        :type channel_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_usergroups_remove_channels_serialize(
            token=token,
            usergroup_id=usergroup_id,
            channel_ids=channel_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_usergroups_remove_channels_serialize(
        self,
        token,
        usergroup_id,
        channel_ids,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if usergroup_id is not None:
            _form_params.append(('usergroup_id', usergroup_id))
        if channel_ids is not None:
            _form_params.append(('channel_ids', channel_ids))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.usergroups.removeChannels',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_assign(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to add to the workspace.")],
        is_restricted: Annotated[Optional[StrictBool], Field(description="True if user should be added to the workspace as a guest.")] = None,
        is_ultra_restricted: Annotated[Optional[StrictBool], Field(description="True if user should be added to the workspace as a single-channel guest.")] = None,
        channel_ids: Annotated[Optional[StrictStr], Field(description="Comma separated values of channel IDs to add user in the new workspace.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_assign

        Add an Enterprise user to a workspace.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to add to the workspace. (required)
        :type user_id: str
        :param is_restricted: True if user should be added to the workspace as a guest.
        :type is_restricted: bool
        :param is_ultra_restricted: True if user should be added to the workspace as a single-channel guest.
        :type is_ultra_restricted: bool
        :param channel_ids: Comma separated values of channel IDs to add user in the new workspace.
        :type channel_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_assign_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            is_restricted=is_restricted,
            is_ultra_restricted=is_ultra_restricted,
            channel_ids=channel_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_assign_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to add to the workspace.")],
        is_restricted: Annotated[Optional[StrictBool], Field(description="True if user should be added to the workspace as a guest.")] = None,
        is_ultra_restricted: Annotated[Optional[StrictBool], Field(description="True if user should be added to the workspace as a single-channel guest.")] = None,
        channel_ids: Annotated[Optional[StrictStr], Field(description="Comma separated values of channel IDs to add user in the new workspace.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_assign

        Add an Enterprise user to a workspace.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to add to the workspace. (required)
        :type user_id: str
        :param is_restricted: True if user should be added to the workspace as a guest.
        :type is_restricted: bool
        :param is_ultra_restricted: True if user should be added to the workspace as a single-channel guest.
        :type is_ultra_restricted: bool
        :param channel_ids: Comma separated values of channel IDs to add user in the new workspace.
        :type channel_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_assign_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            is_restricted=is_restricted,
            is_ultra_restricted=is_ultra_restricted,
            channel_ids=channel_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_assign_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to add to the workspace.")],
        is_restricted: Annotated[Optional[StrictBool], Field(description="True if user should be added to the workspace as a guest.")] = None,
        is_ultra_restricted: Annotated[Optional[StrictBool], Field(description="True if user should be added to the workspace as a single-channel guest.")] = None,
        channel_ids: Annotated[Optional[StrictStr], Field(description="Comma separated values of channel IDs to add user in the new workspace.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_assign

        Add an Enterprise user to a workspace.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to add to the workspace. (required)
        :type user_id: str
        :param is_restricted: True if user should be added to the workspace as a guest.
        :type is_restricted: bool
        :param is_ultra_restricted: True if user should be added to the workspace as a single-channel guest.
        :type is_ultra_restricted: bool
        :param channel_ids: Comma separated values of channel IDs to add user in the new workspace.
        :type channel_ids: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_assign_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            is_restricted=is_restricted,
            is_ultra_restricted=is_ultra_restricted,
            channel_ids=channel_ids,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_assign_serialize(
        self,
        token,
        team_id,
        user_id,
        is_restricted,
        is_ultra_restricted,
        channel_ids,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if user_id is not None:
            _form_params.append(('user_id', user_id))
        if is_restricted is not None:
            _form_params.append(('is_restricted', is_restricted))
        if is_ultra_restricted is not None:
            _form_params.append(('is_ultra_restricted', is_ultra_restricted))
        if channel_ids is not None:
            _form_params.append(('channel_ids', channel_ids))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.users.assign',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_invite(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        email: Annotated[StrictStr, Field(description="The email address of the person to invite.")],
        channel_ids: Annotated[StrictStr, Field(description="A comma-separated list of `channel_id`s for this user to join. At least one channel is required.")],
        custom_message: Annotated[Optional[StrictStr], Field(description="An optional message to send to the user in the invite email.")] = None,
        real_name: Annotated[Optional[StrictStr], Field(description="Full name of the user.")] = None,
        resend: Annotated[Optional[StrictBool], Field(description="Allow this invite to be resent in the future if a user has not signed up yet. (default: false)")] = None,
        is_restricted: Annotated[Optional[StrictBool], Field(description="Is this user a multi-channel guest user? (default: false)")] = None,
        is_ultra_restricted: Annotated[Optional[StrictBool], Field(description="Is this user a single channel guest user? (default: false)")] = None,
        guest_expiration_ts: Annotated[Optional[StrictStr], Field(description="Timestamp when guest account should be disabled. Only include this timestamp if you are inviting a guest user and you want their account to expire on a certain date.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_invite

        Invite a user to a workspace.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param email: The email address of the person to invite. (required)
        :type email: str
        :param channel_ids: A comma-separated list of `channel_id`s for this user to join. At least one channel is required. (required)
        :type channel_ids: str
        :param custom_message: An optional message to send to the user in the invite email.
        :type custom_message: str
        :param real_name: Full name of the user.
        :type real_name: str
        :param resend: Allow this invite to be resent in the future if a user has not signed up yet. (default: false)
        :type resend: bool
        :param is_restricted: Is this user a multi-channel guest user? (default: false)
        :type is_restricted: bool
        :param is_ultra_restricted: Is this user a single channel guest user? (default: false)
        :type is_ultra_restricted: bool
        :param guest_expiration_ts: Timestamp when guest account should be disabled. Only include this timestamp if you are inviting a guest user and you want their account to expire on a certain date.
        :type guest_expiration_ts: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_invite_serialize(
            token=token,
            team_id=team_id,
            email=email,
            channel_ids=channel_ids,
            custom_message=custom_message,
            real_name=real_name,
            resend=resend,
            is_restricted=is_restricted,
            is_ultra_restricted=is_ultra_restricted,
            guest_expiration_ts=guest_expiration_ts,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_invite_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        email: Annotated[StrictStr, Field(description="The email address of the person to invite.")],
        channel_ids: Annotated[StrictStr, Field(description="A comma-separated list of `channel_id`s for this user to join. At least one channel is required.")],
        custom_message: Annotated[Optional[StrictStr], Field(description="An optional message to send to the user in the invite email.")] = None,
        real_name: Annotated[Optional[StrictStr], Field(description="Full name of the user.")] = None,
        resend: Annotated[Optional[StrictBool], Field(description="Allow this invite to be resent in the future if a user has not signed up yet. (default: false)")] = None,
        is_restricted: Annotated[Optional[StrictBool], Field(description="Is this user a multi-channel guest user? (default: false)")] = None,
        is_ultra_restricted: Annotated[Optional[StrictBool], Field(description="Is this user a single channel guest user? (default: false)")] = None,
        guest_expiration_ts: Annotated[Optional[StrictStr], Field(description="Timestamp when guest account should be disabled. Only include this timestamp if you are inviting a guest user and you want their account to expire on a certain date.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_invite

        Invite a user to a workspace.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param email: The email address of the person to invite. (required)
        :type email: str
        :param channel_ids: A comma-separated list of `channel_id`s for this user to join. At least one channel is required. (required)
        :type channel_ids: str
        :param custom_message: An optional message to send to the user in the invite email.
        :type custom_message: str
        :param real_name: Full name of the user.
        :type real_name: str
        :param resend: Allow this invite to be resent in the future if a user has not signed up yet. (default: false)
        :type resend: bool
        :param is_restricted: Is this user a multi-channel guest user? (default: false)
        :type is_restricted: bool
        :param is_ultra_restricted: Is this user a single channel guest user? (default: false)
        :type is_ultra_restricted: bool
        :param guest_expiration_ts: Timestamp when guest account should be disabled. Only include this timestamp if you are inviting a guest user and you want their account to expire on a certain date.
        :type guest_expiration_ts: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_invite_serialize(
            token=token,
            team_id=team_id,
            email=email,
            channel_ids=channel_ids,
            custom_message=custom_message,
            real_name=real_name,
            resend=resend,
            is_restricted=is_restricted,
            is_ultra_restricted=is_ultra_restricted,
            guest_expiration_ts=guest_expiration_ts,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_invite_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        email: Annotated[StrictStr, Field(description="The email address of the person to invite.")],
        channel_ids: Annotated[StrictStr, Field(description="A comma-separated list of `channel_id`s for this user to join. At least one channel is required.")],
        custom_message: Annotated[Optional[StrictStr], Field(description="An optional message to send to the user in the invite email.")] = None,
        real_name: Annotated[Optional[StrictStr], Field(description="Full name of the user.")] = None,
        resend: Annotated[Optional[StrictBool], Field(description="Allow this invite to be resent in the future if a user has not signed up yet. (default: false)")] = None,
        is_restricted: Annotated[Optional[StrictBool], Field(description="Is this user a multi-channel guest user? (default: false)")] = None,
        is_ultra_restricted: Annotated[Optional[StrictBool], Field(description="Is this user a single channel guest user? (default: false)")] = None,
        guest_expiration_ts: Annotated[Optional[StrictStr], Field(description="Timestamp when guest account should be disabled. Only include this timestamp if you are inviting a guest user and you want their account to expire on a certain date.")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_invite

        Invite a user to a workspace.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param email: The email address of the person to invite. (required)
        :type email: str
        :param channel_ids: A comma-separated list of `channel_id`s for this user to join. At least one channel is required. (required)
        :type channel_ids: str
        :param custom_message: An optional message to send to the user in the invite email.
        :type custom_message: str
        :param real_name: Full name of the user.
        :type real_name: str
        :param resend: Allow this invite to be resent in the future if a user has not signed up yet. (default: false)
        :type resend: bool
        :param is_restricted: Is this user a multi-channel guest user? (default: false)
        :type is_restricted: bool
        :param is_ultra_restricted: Is this user a single channel guest user? (default: false)
        :type is_ultra_restricted: bool
        :param guest_expiration_ts: Timestamp when guest account should be disabled. Only include this timestamp if you are inviting a guest user and you want their account to expire on a certain date.
        :type guest_expiration_ts: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_invite_serialize(
            token=token,
            team_id=team_id,
            email=email,
            channel_ids=channel_ids,
            custom_message=custom_message,
            real_name=real_name,
            resend=resend,
            is_restricted=is_restricted,
            is_ultra_restricted=is_ultra_restricted,
            guest_expiration_ts=guest_expiration_ts,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_invite_serialize(
        self,
        token,
        team_id,
        email,
        channel_ids,
        custom_message,
        real_name,
        resend,
        is_restricted,
        is_ultra_restricted,
        guest_expiration_ts,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if email is not None:
            _form_params.append(('email', email))
        if channel_ids is not None:
            _form_params.append(('channel_ids', channel_ids))
        if custom_message is not None:
            _form_params.append(('custom_message', custom_message))
        if real_name is not None:
            _form_params.append(('real_name', real_name))
        if resend is not None:
            _form_params.append(('resend', resend))
        if is_restricted is not None:
            _form_params.append(('is_restricted', is_restricted))
        if is_ultra_restricted is not None:
            _form_params.append(('is_ultra_restricted', is_ultra_restricted))
        if guest_expiration_ts is not None:
            _form_params.append(('guest_expiration_ts', guest_expiration_ts))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.users.invite',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_list(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:read`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="Limit for how many users to be retrieved per page")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_list

        List users on a workspace

        :param token: Authentication token. Requires scope: `admin.users:read` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :param limit: Limit for how many users to be retrieved per page
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_list_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:read`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="Limit for how many users to be retrieved per page")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_list

        List users on a workspace

        :param token: Authentication token. Requires scope: `admin.users:read` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :param limit: Limit for how many users to be retrieved per page
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_list_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:read`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        cursor: Annotated[Optional[StrictStr], Field(description="Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="Limit for how many users to be retrieved per page")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_list

        List users on a workspace

        :param token: Authentication token. Requires scope: `admin.users:read` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param cursor: Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.
        :type cursor: str
        :param limit: Limit for how many users to be retrieved per page
        :type limit: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_list_serialize(
            token=token,
            team_id=team_id,
            cursor=cursor,
            limit=limit,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_list_serialize(
        self,
        token,
        team_id,
        cursor,
        limit,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if team_id is not None:
            
            _query_params.append(('team_id', team_id))
            
        if cursor is not None:
            
            _query_params.append(('cursor', cursor))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/admin.users.list',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_remove(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to remove.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_remove

        Remove a user from a workspace.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to remove. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_remove_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_remove_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to remove.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_remove

        Remove a user from a workspace.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to remove. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_remove_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_remove_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to remove.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_remove

        Remove a user from a workspace.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to remove. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_remove_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_remove_serialize(
        self,
        token,
        team_id,
        user_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if user_id is not None:
            _form_params.append(('user_id', user_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.users.remove',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_session_invalidate(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="ID of the team that the session belongs to")],
        session_id: StrictInt,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_session_invalidate

        Invalidate a single session for a user by session_id

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: ID of the team that the session belongs to (required)
        :type team_id: str
        :param session_id: (required)
        :type session_id: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_session_invalidate_serialize(
            token=token,
            team_id=team_id,
            session_id=session_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_session_invalidate_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="ID of the team that the session belongs to")],
        session_id: StrictInt,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_session_invalidate

        Invalidate a single session for a user by session_id

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: ID of the team that the session belongs to (required)
        :type team_id: str
        :param session_id: (required)
        :type session_id: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_session_invalidate_serialize(
            token=token,
            team_id=team_id,
            session_id=session_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_session_invalidate_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="ID of the team that the session belongs to")],
        session_id: StrictInt,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_session_invalidate

        Invalidate a single session for a user by session_id

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: ID of the team that the session belongs to (required)
        :type team_id: str
        :param session_id: (required)
        :type session_id: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_session_invalidate_serialize(
            token=token,
            team_id=team_id,
            session_id=session_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_session_invalidate_serialize(
        self,
        token,
        team_id,
        session_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if session_id is not None:
            _form_params.append(('session_id', session_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.users.session.invalidate',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_session_reset(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to wipe sessions for")],
        mobile_only: Annotated[Optional[StrictBool], Field(description="Only expire mobile sessions (default: false)")] = None,
        web_only: Annotated[Optional[StrictBool], Field(description="Only expire web sessions (default: false)")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_session_reset

        Wipes all valid sessions on all devices for a given user

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param user_id: The ID of the user to wipe sessions for (required)
        :type user_id: str
        :param mobile_only: Only expire mobile sessions (default: false)
        :type mobile_only: bool
        :param web_only: Only expire web sessions (default: false)
        :type web_only: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_session_reset_serialize(
            token=token,
            user_id=user_id,
            mobile_only=mobile_only,
            web_only=web_only,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_session_reset_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to wipe sessions for")],
        mobile_only: Annotated[Optional[StrictBool], Field(description="Only expire mobile sessions (default: false)")] = None,
        web_only: Annotated[Optional[StrictBool], Field(description="Only expire web sessions (default: false)")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_session_reset

        Wipes all valid sessions on all devices for a given user

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param user_id: The ID of the user to wipe sessions for (required)
        :type user_id: str
        :param mobile_only: Only expire mobile sessions (default: false)
        :type mobile_only: bool
        :param web_only: Only expire web sessions (default: false)
        :type web_only: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_session_reset_serialize(
            token=token,
            user_id=user_id,
            mobile_only=mobile_only,
            web_only=web_only,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_session_reset_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to wipe sessions for")],
        mobile_only: Annotated[Optional[StrictBool], Field(description="Only expire mobile sessions (default: false)")] = None,
        web_only: Annotated[Optional[StrictBool], Field(description="Only expire web sessions (default: false)")] = None,
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_session_reset

        Wipes all valid sessions on all devices for a given user

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param user_id: The ID of the user to wipe sessions for (required)
        :type user_id: str
        :param mobile_only: Only expire mobile sessions (default: false)
        :type mobile_only: bool
        :param web_only: Only expire web sessions (default: false)
        :type web_only: bool
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_session_reset_serialize(
            token=token,
            user_id=user_id,
            mobile_only=mobile_only,
            web_only=web_only,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_session_reset_serialize(
        self,
        token,
        user_id,
        mobile_only,
        web_only,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if user_id is not None:
            _form_params.append(('user_id', user_id))
        if mobile_only is not None:
            _form_params.append(('mobile_only', mobile_only))
        if web_only is not None:
            _form_params.append(('web_only', web_only))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.users.session.reset',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_set_admin(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to designate as an admin.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_set_admin

        Set an existing guest, regular user, or owner to be an admin user.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to designate as an admin. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_admin_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_set_admin_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to designate as an admin.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_set_admin

        Set an existing guest, regular user, or owner to be an admin user.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to designate as an admin. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_admin_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_set_admin_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to designate as an admin.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_set_admin

        Set an existing guest, regular user, or owner to be an admin user.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to designate as an admin. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_admin_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_set_admin_serialize(
        self,
        token,
        team_id,
        user_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if user_id is not None:
            _form_params.append(('user_id', user_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.users.setAdmin',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_set_expiration(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to set an expiration for.")],
        expiration_ts: Annotated[StrictInt, Field(description="Timestamp when guest account should be disabled.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_set_expiration

        Set an expiration for a guest user

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to set an expiration for. (required)
        :type user_id: str
        :param expiration_ts: Timestamp when guest account should be disabled. (required)
        :type expiration_ts: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_expiration_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            expiration_ts=expiration_ts,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_set_expiration_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to set an expiration for.")],
        expiration_ts: Annotated[StrictInt, Field(description="Timestamp when guest account should be disabled.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_set_expiration

        Set an expiration for a guest user

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to set an expiration for. (required)
        :type user_id: str
        :param expiration_ts: Timestamp when guest account should be disabled. (required)
        :type expiration_ts: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_expiration_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            expiration_ts=expiration_ts,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_set_expiration_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to set an expiration for.")],
        expiration_ts: Annotated[StrictInt, Field(description="Timestamp when guest account should be disabled.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_set_expiration

        Set an expiration for a guest user

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to set an expiration for. (required)
        :type user_id: str
        :param expiration_ts: Timestamp when guest account should be disabled. (required)
        :type expiration_ts: int
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_expiration_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            expiration_ts=expiration_ts,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_set_expiration_serialize(
        self,
        token,
        team_id,
        user_id,
        expiration_ts,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if user_id is not None:
            _form_params.append(('user_id', user_id))
        if expiration_ts is not None:
            _form_params.append(('expiration_ts', expiration_ts))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.users.setExpiration',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_set_owner(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="Id of the user to promote to owner.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_set_owner

        Set an existing guest, regular user, or admin user to be a workspace owner.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: Id of the user to promote to owner. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_owner_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_set_owner_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="Id of the user to promote to owner.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_set_owner

        Set an existing guest, regular user, or admin user to be a workspace owner.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: Id of the user to promote to owner. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_owner_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_set_owner_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="Id of the user to promote to owner.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_set_owner

        Set an existing guest, regular user, or admin user to be a workspace owner.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: Id of the user to promote to owner. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_owner_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_set_owner_serialize(
        self,
        token,
        team_id,
        user_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if user_id is not None:
            _form_params.append(('user_id', user_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.users.setOwner',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )




    @validate_call
    def admin_users_set_regular(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to designate as a regular user.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> DefaultSuccessTemplate:
        """admin_users_set_regular

        Set an existing guest user, admin user, or owner to be a regular user.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to designate as a regular user. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_regular_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def admin_users_set_regular_with_http_info(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to designate as a regular user.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> ApiResponse[DefaultSuccessTemplate]:
        """admin_users_set_regular

        Set an existing guest user, admin user, or owner to be a regular user.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to designate as a regular user. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_regular_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def admin_users_set_regular_without_preload_content(
        self,
        token: Annotated[StrictStr, Field(description="Authentication token. Requires scope: `admin.users:write`")],
        team_id: Annotated[StrictStr, Field(description="The ID (`T1234`) of the workspace.")],
        user_id: Annotated[StrictStr, Field(description="The ID of the user to designate as a regular user.")],
        request_timeout__: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        request_auth__: Optional[Dict[StrictStr, Any]] = None,
        content_type__: Optional[StrictStr] = None,
        headers__: Optional[Dict[StrictStr, Any]] = None,
        host__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """admin_users_set_regular

        Set an existing guest user, admin user, or owner to be a regular user.

        :param token: Authentication token. Requires scope: `admin.users:write` (required)
        :type token: str
        :param team_id: The ID (`T1234`) of the workspace. (required)
        :type team_id: str
        :param user_id: The ID of the user to designate as a regular user. (required)
        :type user_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._admin_users_set_regular_serialize(
            token=token,
            team_id=team_id,
            user_id=user_id,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DefaultSuccessTemplate",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _admin_users_set_regular_serialize(
        self,
        token,
        team_id,
        user_id,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = headers__ or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if token is not None:
            _header_params['token'] = token
        # process the form parameters
        if team_id is not None:
            _form_params.append(('team_id', team_id))
        if user_id is not None:
            _form_params.append(('user_id', user_id))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if content_type__:
            _header_params['Content-Type'] = content_type__
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'slackAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/admin.users.setRegular',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            host__=host__,
            request_auth__=request_auth__
        )


