"""A Python module for interacting with Slack's Web API."""

import json

import os

from io import IOBase

from typing import Union, Sequence, Optional, Dict, Tuple, Any, List

import slack_sdk.errors as e

from slack_sdk.models.views import View

from .base_client import BaseClient, SlackResponse

from .internal_utils import (

_parse_web_class_objects,

_update_call_participants,

_warn_if_text_is_missing,

_remove_none_values,

)

from ..models.attachments import Attachment

from ..models.blocks import Block

class WebClient(BaseClient):

"""A WebClient allows apps to communicate with the Slack Platform's Web API.

https://api.slack.com/methods

The Slack Web API is an interface for querying information from

and enacting change in a Slack workspace.

This client handles constructing and sending HTTP requests to Slack

as well as parsing any responses received into a `SlackResponse`.

Attributes:

token (str): A string specifying an xoxp or xoxb token.

base_url (str): A string representing the Slack API base URL.

Default is 'https://www.slack.com/api/'

timeout (int): The maximum number of seconds the client will wait

to connect and receive a response from Slack.

Default is 30 seconds.

Methods:

api_call: Constructs a request and executes the API call to Slack.

Example of recommended usage:

```python

import os

from slack_sdk import WebClient

client = WebClient(token=os.environ['SLACK_API_TOKEN'])

response = client.chat_postMessage(

channel='#random',

text="Hello world!")

assert response["ok"]

assert response["message"]["text"] == "Hello world!"

```

Example manually creating an API request:

```python

import os

from slack_sdk import WebClient

client = WebClient(token=os.environ['SLACK_API_TOKEN'])

response = client.api_call(

api_method='chat.postMessage',

json={'channel': '#random','text': "Hello world!"}

)

assert response["ok"]

assert response["message"]["text"] == "Hello world!"

```

Note:

Any attributes or methods prefixed with _underscores are

intended to be "private" internal use only. They may be changed or

removed at anytime.

"""

def admin_analytics_getFile(

self,

*,

type: str,

date: Optional[str] = None,

metadata_only: Optional[bool] = None,

**kwargs,

) -> SlackResponse:

"""Retrieve analytics data for a given date, presented as a compressed JSON file

https://api.slack.com/methods/admin.analytics.getFile

"""

kwargs.update({"type": type})

if date is not None:

kwargs.update({"date": date})

if metadata_only is not None:

kwargs.update({"metadata_only": metadata_only})

return self.api_call("admin.analytics.getFile", params=kwargs)

def admin_apps_approve(

self,

*,

app_id: Optional[str] = None,

request_id: Optional[str] = None,

enterprise_id: Optional[str] = None,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""Approve an app for installation on a workspace.

Either app_id or request_id is required.

These IDs can be obtained either directly via the app_requested event,

or by the admin.apps.requests.list method.

https://api.slack.com/methods/admin.apps.approve

"""

if app_id:

kwargs.update({"app_id": app_id})

elif request_id:

kwargs.update({"request_id": request_id})

else:

raise e.SlackRequestError(

"The app_id or request_id argument must be specified."

)

kwargs.update(

{

"enterprise_id": enterprise_id,

"team_id": team_id,

}

)

return self.api_call("admin.apps.approve", params=kwargs)

def admin_apps_approved_list(

self,

*,

cursor: Optional[str] = None,

limit: Optional[int] = None,

enterprise_id: Optional[str] = None,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""List approved apps for an org or workspace.

https://api.slack.com/methods/admin.apps.approved.list

"""

kwargs.update(

{

"cursor": cursor,

"limit": limit,

"enterprise_id": enterprise_id,

"team_id": team_id,

}

)

return self.api_call("admin.apps.approved.list", http_verb="GET", params=kwargs)

def admin_apps_clearResolution(

self,

*,

app_id: str,

enterprise_id: Optional[str] = None,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""Clear an app resolution

https://api.slack.com/methods/admin.apps.clearResolution

"""

kwargs.update(

{

"app_id": app_id,

"enterprise_id": enterprise_id,

"team_id": team_id,

}

)

return self.api_call(

"admin.apps.clearResolution", http_verb="POST", params=kwargs

)

def admin_apps_requests_list(

self,

*,

cursor: Optional[str] = None,

limit: Optional[int] = None,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""List app requests for a team/workspace.

https://api.slack.com/methods/admin.apps.requests.list

"""

kwargs.update(

{

"cursor": cursor,

"limit": limit,

"team_id": team_id,

}

)

return self.api_call("admin.apps.requests.list", http_verb="GET", params=kwargs)

def admin_apps_restrict(

self,

*,

app_id: Optional[str] = None,

request_id: Optional[str] = None,

enterprise_id: Optional[str] = None,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""Restrict an app for installation on a workspace.

Exactly one of the team_id or enterprise_id arguments is required, not both.

Either app_id or request_id is required. These IDs can be obtained either directly

via the app_requested event, or by the admin.apps.requests.list method.

https://api.slack.com/methods/admin.apps.restrict

"""

if app_id:

kwargs.update({"app_id": app_id})

elif request_id:

kwargs.update({"request_id": request_id})

else:

raise e.SlackRequestError(

"The app_id or request_id argument must be specified."

)

kwargs.update(

{

"enterprise_id": enterprise_id,

"team_id": team_id,

}

)

return self.api_call("admin.apps.restrict", params=kwargs)

def admin_apps_restricted_list(

self,

*,

cursor: Optional[str] = None,

limit: Optional[int] = None,

enterprise_id: Optional[str] = None,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""List restricted apps for an org or workspace.

https://api.slack.com/methods/admin.apps.restricted.list

"""

kwargs.update(

{

"cursor": cursor,

"limit": limit,

"enterprise_id": enterprise_id,

"team_id": team_id,

}

)

return self.api_call(

"admin.apps.restricted.list", http_verb="GET", params=kwargs

)

def admin_apps_uninstall(

self,

*,

app_id: str,

enterprise_id: Optional[str] = None,

team_ids: Optional[Union[str, Sequence[str]]] = None,

**kwargs,

) -> SlackResponse:

"""Uninstall an app from one or many workspaces, or an entire enterprise organization.

With an org-level token, enterprise_id or team_ids is required.

https://api.slack.com/methods/admin.apps.uninstall

"""

kwargs.update({"app_id": app_id})

if enterprise_id is not None:

kwargs.update({"enterprise_id": enterprise_id})

if team_ids is not None:

if isinstance(team_ids, (list, Tuple)):

kwargs.update({"team_ids": ",".join(team_ids)})

else:

kwargs.update({"team_ids": team_ids})

return self.api_call("admin.apps.uninstall", http_verb="POST", params=kwargs)

def admin_auth_policy_getEntities(

self,

*,

policy_name: str,

cursor: Optional[str] = None,

entity_type: Optional[str] = None,

limit: Optional[int] = None,

**kwargs,

) -> SlackResponse:

"""Fetch all the entities assigned to a particular authentication policy by name.

https://api.slack.com/methods/admin.auth.policy.getEntities

"""

kwargs.update({"policy_name": policy_name})

if cursor is not None:

kwargs.update({"cursor": cursor})

if entity_type is not None:

kwargs.update({"entity_type": entity_type})

if limit is not None:

kwargs.update({"limit": limit})

return self.api_call(

"admin.auth.policy.getEntities", http_verb="POST", params=kwargs

)

def admin_auth_policy_assignEntities(

self,

*,

entity_ids: Union[str, Sequence[str]],

policy_name: str,

entity_type: str,

**kwargs,

) -> SlackResponse:

"""Assign entities to a particular authentication policy.

https://api.slack.com/methods/admin.auth.policy.assignEntities

"""

if isinstance(entity_ids, (list, Tuple)):

kwargs.update({"entity_ids": ",".join(entity_ids)})

else:

kwargs.update({"entity_ids": entity_ids})

kwargs.update({"policy_name": policy_name})

kwargs.update({"entity_type": entity_type})

return self.api_call(

"admin.auth.policy.assignEntities", http_verb="POST", params=kwargs

)

def admin_auth_policy_removeEntities(

self,

*,

entity_ids: Union[str, Sequence[str]],

policy_name: str,

entity_type: str,

**kwargs,

) -> SlackResponse:

"""Remove specified entities from a specified authentication policy.

https://api.slack.com/methods/admin.auth.policy.removeEntities

"""

if isinstance(entity_ids, (list, Tuple)):

kwargs.update({"entity_ids": ",".join(entity_ids)})

else:

kwargs.update({"entity_ids": entity_ids})

kwargs.update({"policy_name": policy_name})

kwargs.update({"entity_type": entity_type})

return self.api_call(

"admin.auth.policy.removeEntities", http_verb="POST", params=kwargs

)

def admin_barriers_create(

self,

*,

barriered_from_usergroup_ids: Union[str, Sequence[str]],

primary_usergroup_id: str,

restricted_subjects: Union[str, Sequence[str]],

**kwargs,

) -> SlackResponse:

"""Create an Information Barrier

https://api.slack.com/methods/admin.barriers.create

"""

kwargs.update({"primary_usergroup_id": primary_usergroup_id})

if isinstance(barriered_from_usergroup_ids, (list, Tuple)):

kwargs.update(

{"barriered_from_usergroup_ids": ",".join(barriered_from_usergroup_ids)}

)

else:

kwargs.update(

{"barriered_from_usergroup_ids": barriered_from_usergroup_ids}

)

if isinstance(restricted_subjects, (list, Tuple)):

kwargs.update({"restricted_subjects": ",".join(restricted_subjects)})

else:

kwargs.update({"restricted_subjects": restricted_subjects})

return self.api_call("admin.barriers.create", http_verb="POST", params=kwargs)

def admin_barriers_delete(

self,

*,

barrier_id: str,

**kwargs,

) -> SlackResponse:

"""Delete an existing Information Barrier

https://api.slack.com/methods/admin.barriers.delete

"""

kwargs.update({"barrier_id": barrier_id})

return self.api_call("admin.barriers.delete", http_verb="POST", params=kwargs)

def admin_barriers_update(

self,

*,

barrier_id: str,

barriered_from_usergroup_ids: Union[str, Sequence[str]],

primary_usergroup_id: str,

restricted_subjects: Union[str, Sequence[str]],

**kwargs,

) -> SlackResponse:

"""Update an existing Information Barrier

https://api.slack.com/methods/admin.barriers.update

"""

kwargs.update(

{"barrier_id": barrier_id, "primary_usergroup_id": primary_usergroup_id}

)

if isinstance(barriered_from_usergroup_ids, (list, Tuple)):

kwargs.update(

{"barriered_from_usergroup_ids": ",".join(barriered_from_usergroup_ids)}

)

else:

kwargs.update(

{"barriered_from_usergroup_ids": barriered_from_usergroup_ids}

)

if isinstance(restricted_subjects, (list, Tuple)):

kwargs.update({"restricted_subjects": ",".join(restricted_subjects)})

else:

kwargs.update({"restricted_subjects": restricted_subjects})

return self.api_call("admin.barriers.update", http_verb="POST", params=kwargs)

def admin_barriers_list(

self,

*,

cursor: Optional[str] = None,

limit: Optional[int] = None,

**kwargs,

) -> SlackResponse:

"""Get all Information Barriers for your organization

https://api.slack.com/methods/admin.barriers.list"""

kwargs.update(

{

"cursor": cursor,

"limit": limit,

}

)

return self.api_call("admin.barriers.list", http_verb="GET", params=kwargs)

def admin_conversations_create(

self,

*,

is_private: bool,

name: str,

description: Optional[str] = None,

org_wide: Optional[bool] = None,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""Create a public or private channel-based conversation.

https://api.slack.com/methods/admin.conversations.create

"""

kwargs.update(

{

"is_private": is_private,

"name": name,

"description": description,

"org_wide": org_wide,

"team_id": team_id,

}

)

return self.api_call("admin.conversations.create", params=kwargs)

def admin_conversations_delete(

self,

*,

channel_id: str,

**kwargs,

) -> SlackResponse:

"""Delete a public or private channel.

https://api.slack.com/methods/admin.conversations.delete

"""

kwargs.update({"channel_id": channel_id})

return self.api_call("admin.conversations.delete", params=kwargs)

def admin_conversations_invite(

self,

*,

channel_id: str,

user_ids: Union[str, Sequence[str]],

**kwargs,

) -> SlackResponse:

"""Invite a user to a public or private channel.

https://api.slack.com/methods/admin.conversations.invite

"""

kwargs.update({"channel_id": channel_id})

if isinstance(user_ids, (list, Tuple)):

kwargs.update({"user_ids": ",".join(user_ids)})

else:

kwargs.update({"user_ids": user_ids})

# NOTE: the endpoint is unable to handle Content-Type: application/json as of Sep 3, 2020.

return self.api_call("admin.conversations.invite", params=kwargs)

def admin_conversations_archive(

self,

*,

channel_id: str,

**kwargs,

) -> SlackResponse:

"""Archive a public or private channel.

https://api.slack.com/methods/admin.conversations.archive

"""

kwargs.update({"channel_id": channel_id})

return self.api_call("admin.conversations.archive", params=kwargs)

def admin_conversations_unarchive(

self,

*,

channel_id: str,

**kwargs,

) -> SlackResponse:

"""Unarchive a public or private channel.

https://api.slack.com/methods/admin.conversations.archive

"""

kwargs.update({"channel_id": channel_id})

return self.api_call("admin.conversations.unarchive", params=kwargs)

def admin_conversations_rename(

self,

*,

channel_id: str,

name: str,

**kwargs,

) -> SlackResponse:

"""Rename a public or private channel.

https://api.slack.com/methods/admin.conversations.rename

"""

kwargs.update({"channel_id": channel_id, "name": name})

return self.api_call("admin.conversations.rename", params=kwargs)

def admin_conversations_search(

self,

*,

cursor: Optional[str] = None,

limit: Optional[int] = None,

query: Optional[str] = None,

search_channel_types: Optional[Union[str, Sequence[str]]] = None,

sort: Optional[str] = None,

sort_dir: Optional[str] = None,

team_ids: Optional[Union[str, Sequence[str]]] = None,

**kwargs,

) -> SlackResponse:

"""Search for public or private channels in an Enterprise organization.

https://api.slack.com/methods/admin.conversations.search

"""

kwargs.update(

{

"cursor": cursor,

"limit": limit,

"query": query,

"sort": sort,

"sort_dir": sort_dir,

}

)

if isinstance(search_channel_types, (list, Tuple)):

kwargs.update({"search_channel_types": ",".join(search_channel_types)})

else:

kwargs.update({"search_channel_types": search_channel_types})

if isinstance(team_ids, (list, Tuple)):

kwargs.update({"team_ids": ",".join(team_ids)})

else:

kwargs.update({"team_ids": team_ids})

return self.api_call("admin.conversations.search", params=kwargs)

def admin_conversations_convertToPrivate(

self,

*,

channel_id: str,

**kwargs,

) -> SlackResponse:

"""Convert a public channel to a private channel.

https://api.slack.com/methods/admin.conversations.convertToPrivate

"""

kwargs.update({"channel_id": channel_id})

return self.api_call("admin.conversations.convertToPrivate", params=kwargs)

def admin_conversations_setConversationPrefs(

self,

*,

channel_id: str,

prefs: Union[str, Dict[str, str]],

**kwargs,

) -> SlackResponse:

"""Set the posting permissions for a public or private channel.

https://api.slack.com/methods/admin.conversations.setConversationPrefs

"""

kwargs.update({"channel_id": channel_id})

if isinstance(prefs, dict):

kwargs.update({"prefs": json.dumps(prefs)})

else:

kwargs.update({"prefs": prefs})

return self.api_call("admin.conversations.setConversationPrefs", params=kwargs)

def admin_conversations_getConversationPrefs(

self,

*,

channel_id: str,

**kwargs,

) -> SlackResponse:

"""Get conversation preferences for a public or private channel.

https://api.slack.com/methods/admin.conversations.getConversationPrefs

"""

kwargs.update({"channel_id": channel_id})

return self.api_call("admin.conversations.getConversationPrefs", params=kwargs)

def admin_conversations_disconnectShared(

self,

*,

channel_id: str,

leaving_team_ids: Optional[Union[str, Sequence[str]]] = None,

**kwargs,

) -> SlackResponse:

"""Disconnect a connected channel from one or more workspaces.

https://api.slack.com/methods/admin.conversations.disconnectShared

"""

kwargs.update({"channel_id": channel_id})

if isinstance(leaving_team_ids, (list, Tuple)):

kwargs.update({"leaving_team_ids": ",".join(leaving_team_ids)})

else:

kwargs.update({"leaving_team_ids": leaving_team_ids})

return self.api_call("admin.conversations.disconnectShared", params=kwargs)

def admin_conversations_ekm_listOriginalConnectedChannelInfo(

self,

*,

channel_ids: Optional[Union[str, Sequence[str]]] = None,

cursor: Optional[str] = None,

limit: Optional[int] = None,

team_ids: Optional[Union[str, Sequence[str]]] = None,

**kwargs,

) -> SlackResponse:

"""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.

https://api.slack.com/methods/admin.conversations.ekm.listOriginalConnectedChannelInfo

"""

kwargs.update(

{

"cursor": cursor,

"limit": limit,

}

)

if isinstance(channel_ids, (list, Tuple)):

kwargs.update({"channel_ids": ",".join(channel_ids)})

else:

kwargs.update({"channel_ids": channel_ids})

if isinstance(team_ids, (list, Tuple)):

kwargs.update({"team_ids": ",".join(team_ids)})

else:

kwargs.update({"team_ids": team_ids})

return self.api_call(

"admin.conversations.ekm.listOriginalConnectedChannelInfo", params=kwargs

)

def admin_conversations_restrictAccess_addGroup(

self,

*,

channel_id: str,

group_id: str,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""Add an allowlist of IDP groups for accessing a channel.

https://api.slack.com/methods/admin.conversations.restrictAccess.addGroup

"""

kwargs.update(

{

"channel_id": channel_id,

"group_id": group_id,

"team_id": team_id,

}

)

return self.api_call(

"admin.conversations.restrictAccess.addGroup",

http_verb="GET",

params=kwargs,

)

def admin_conversations_restrictAccess_listGroups(

self,

*,

channel_id: str,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""List all IDP Groups linked to a channel.

https://api.slack.com/methods/admin.conversations.restrictAccess.listGroups

"""

kwargs.update(

{

"channel_id": channel_id,

"team_id": team_id,

}

)

return self.api_call(

"admin.conversations.restrictAccess.listGroups",

http_verb="GET",

params=kwargs,

)

def admin_conversations_restrictAccess_removeGroup(

self,

*,

channel_id: str,

group_id: str,

team_id: str,

**kwargs,

) -> SlackResponse:

"""Remove a linked IDP group linked from a private channel.

https://api.slack.com/methods/admin.conversations.restrictAccess.removeGroup

"""

kwargs.update(

{

"channel_id": channel_id,

"group_id": group_id,

"team_id": team_id,

}

)

return self.api_call(

"admin.conversations.restrictAccess.removeGroup",

http_verb="GET",

params=kwargs,

)

def admin_conversations_setTeams(

self,

*,

channel_id: str,

org_channel: Optional[bool] = None,

target_team_ids: Optional[Union[str, Sequence[str]]] = None,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

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

https://api.slack.com/methods/admin.conversations.setTeams

"""

kwargs.update(

{

"channel_id": channel_id,

"org_channel": org_channel,

"team_id": team_id,

}

)

if isinstance(target_team_ids, (list, Tuple)):

kwargs.update({"target_team_ids": ",".join(target_team_ids)})

else:

kwargs.update({"target_team_ids": target_team_ids})

return self.api_call("admin.conversations.setTeams", params=kwargs)

def admin_conversations_getTeams(

self,

*,

channel_id: str,

cursor: Optional[str] = None,

limit: Optional[int] = None,

**kwargs,

) -> SlackResponse:

"""Set the workspaces in an Enterprise grid org that connect to a channel.

https://api.slack.com/methods/admin.conversations.getTeams

"""

kwargs.update(

{

"channel_id": channel_id,

"cursor": cursor,

"limit": limit,

}

)

return self.api_call("admin.conversations.getTeams", params=kwargs)

def admin_conversations_getCustomRetention(

self,

*,

channel_id: str,

**kwargs,

) -> SlackResponse:

"""Get a channel's retention policy

https://api.slack.com/methods/admin.conversations.getCustomRetention

"""

kwargs.update({"channel_id": channel_id})

return self.api_call("admin.conversations.getCustomRetention", params=kwargs)

def admin_conversations_removeCustomRetention(

self,

*,

channel_id: str,

**kwargs,

) -> SlackResponse:

"""Remove a channel's retention policy

https://api.slack.com/methods/admin.conversations.removeCustomRetention

"""

kwargs.update({"channel_id": channel_id})

return self.api_call("admin.conversations.removeCustomRetention", params=kwargs)

def admin_conversations_setCustomRetention(

self,

*,

channel_id: str,

duration_days: int,

**kwargs,

) -> SlackResponse:

"""Set a channel's retention policy

https://api.slack.com/methods/admin.conversations.setCustomRetention

"""

kwargs.update({"channel_id": channel_id, "duration_days": duration_days})

return self.api_call("admin.conversations.setCustomRetention", params=kwargs)

def admin_emoji_add(

self,

*,

name: str,

url: str,

**kwargs,

) -> SlackResponse:

"""Add an emoji.

https://api.slack.com/methods/admin.emoji.add

"""

kwargs.update({"name": name, "url": url})

return self.api_call("admin.emoji.add", http_verb="GET", params=kwargs)

def admin_emoji_addAlias(

self,

*,

alias_for: str,

name: str,

**kwargs,

) -> SlackResponse:

"""Add an emoji alias.

https://api.slack.com/methods/admin.emoji.addAlias

"""

kwargs.update({"alias_for": alias_for, "name": name})

return self.api_call("admin.emoji.addAlias", http_verb="GET", params=kwargs)

def admin_emoji_list(

self,

*,

cursor: Optional[str] = None,

limit: Optional[int] = None,

**kwargs,

) -> SlackResponse:

"""List emoji for an Enterprise Grid organization.

https://api.slack.com/methods/admin.emoji.list

"""

kwargs.update({"cursor": cursor, "limit": limit})

return self.api_call("admin.emoji.list", http_verb="GET", params=kwargs)

def admin_emoji_remove(

self,

*,

name: str,

**kwargs,

) -> SlackResponse:

"""Remove an emoji across an Enterprise Grid organization.

https://api.slack.com/methods/admin.emoji.remove

"""

kwargs.update({"name": name})

return self.api_call("admin.emoji.remove", http_verb="GET", params=kwargs)

def admin_emoji_rename(

self,

*,

name: str,

new_name: str,

**kwargs,

) -> SlackResponse:

"""Rename an emoji.

https://api.slack.com/methods/admin.emoji.rename

"""

kwargs.update({"name": name, "new_name": new_name})

return self.api_call("admin.emoji.rename", http_verb="GET", params=kwargs)

def admin_users_session_reset(

self,

*,

user_id: str,

mobile_only: Optional[bool] = None,

web_only: Optional[bool] = None,

**kwargs,

) -> SlackResponse:

"""Wipes all valid sessions on all devices for a given user.

https://api.slack.com/methods/admin.users.session.reset

"""

kwargs.update(

{

"user_id": user_id,

"mobile_only": mobile_only,

"web_only": web_only,

}

)

return self.api_call("admin.users.session.reset", params=kwargs)

def admin_users_session_invalidate(

self,

*,

session_id: str,

team_id: str,

**kwargs,

) -> SlackResponse:

"""Invalidate a single session for a user by session_id.

https://api.slack.com/methods/admin.users.session.invalidate

"""

kwargs.update({"session_id": session_id, "team_id": team_id})

return self.api_call("admin.users.session.invalidate", params=kwargs)

def admin_users_session_list(

self,

*,

cursor: Optional[str] = None,

limit: Optional[int] = None,

team_id: Optional[str] = None,

user_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""Lists all active user sessions for an organization

https://api.slack.com/methods/admin.users.session.list

"""

kwargs.update(

{

"cursor": cursor,

"limit": limit,

"team_id": team_id,

"user_id": user_id,

}

)

return self.api_call("admin.users.session.list", params=kwargs)

def admin_teams_settings_setDefaultChannels(

self,

*,

team_id: str,

channel_ids: Union[str, Sequence[str]],

**kwargs,

) -> SlackResponse:

"""Set the default channels of a workspace.

https://api.slack.com/methods/admin.teams.settings.setDefaultChannels

"""

kwargs.update({"team_id": team_id})

if isinstance(channel_ids, (list, Tuple)):

kwargs.update({"channel_ids": ",".join(channel_ids)})

else:

kwargs.update({"channel_ids": channel_ids})

return self.api_call(

"admin.teams.settings.setDefaultChannels", http_verb="GET", params=kwargs

)

def admin_users_session_getSettings(

self,

*,

user_ids: Union[str, Sequence[str]],

**kwargs,

) -> SlackResponse:

"""Get user-specific session settings—the session duration

and what happens when the client closes—given a list of users.

https://api.slack.com/methods/admin.users.session.getSettings

"""

if isinstance(user_ids, (list, Tuple)):

kwargs.update({"user_ids": ",".join(user_ids)})

else:

kwargs.update({"user_ids": user_ids})

return self.api_call("admin.users.session.getSettings", params=kwargs)

def admin_users_session_setSettings(

self,

*,

user_ids: Union[str, Sequence[str]],

desktop_app_browser_quit: Optional[bool] = None,

duration: Optional[int] = None,

**kwargs,

) -> SlackResponse:

"""Configure the user-level session settings—the session duration

and what happens when the client closes—for one or more users.

https://api.slack.com/methods/admin.users.session.setSettings

"""

if isinstance(user_ids, (list, Tuple)):

kwargs.update({"user_ids": ",".join(user_ids)})

else:

kwargs.update({"user_ids": user_ids})

kwargs.update(

{

"desktop_app_browser_quit": desktop_app_browser_quit,

"duration": duration,

}

)

return self.api_call("admin.users.session.setSettings", params=kwargs)

def admin_users_session_clearSettings(

self,

*,

user_ids: Union[str, Sequence[str]],

**kwargs,

) -> SlackResponse:

"""Clear user-specific session settings—the session duration

and what happens when the client closes—for a list of users.

https://api.slack.com/methods/admin.users.session.clearSettings

"""

if isinstance(user_ids, (list, Tuple)):

kwargs.update({"user_ids": ",".join(user_ids)})

else:

kwargs.update({"user_ids": user_ids})

return self.api_call("admin.users.session.clearSettings", params=kwargs)

def admin_inviteRequests_approve(

self,

*,

invite_request_id: str,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse:

"""Approve a workspace invite request.

https://api.slack.com/methods/admin.inviteRequests.approve

"""

kwargs.update({"invite_request_id": invite_request_id, "team_id": team_id})

return self.api_call("admin.inviteRequests.approve", params=kwargs)

def admin_inviteRequests_approved_list(

self,

*,

cursor: Optional[str] = None,

limit: Optional[int] = None,

team_id: Optional[str] = None,

**kwargs,

) -> SlackResponse: