slack-api-sdk-apimatic 1.1.1__py3-none-any.whl

slackwebapi/controllers/conversations_controller.py

@@ -0,0 +1,1217 @@
+"""slackwebapi.
+
+This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ).
+"""
+
+# ruff: noqa: D410, E501, E101, D206
+from apimatic_core.authentication.multiple.single_auth import (
+    Single,
+)
+from apimatic_core.request_builder import RequestBuilder
+from apimatic_core.response_handler import ResponseHandler
+from apimatic_core.types.parameter import Parameter
+
+from slackwebapi.api_helper import APIHelper
+from slackwebapi.configuration import Server
+from slackwebapi.controllers.base_controller import (
+    BaseController,
+)
+from slackwebapi.exceptions.conversations_archive_error_schema_exception import (
+    ConversationsArchiveErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_close_error_schema_exception import (
+    ConversationsCloseErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_create_error_schema_exception import (
+    ConversationsCreateErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_history_error_schema_exception import (
+    ConversationsHistoryErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_info_error_schema_exception import (
+    ConversationsInfoErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_invite_error_schema_1_exception import (
+    ConversationsInviteErrorSchema1Exception,
+)
+from slackwebapi.exceptions.conversations_join_error_schema_exception import (
+    ConversationsJoinErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_kick_error_schema_exception import (
+    ConversationsKickErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_leave_error_schema_exception import (
+    ConversationsLeaveErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_list_error_schema_exception import (
+    ConversationsListErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_mark_error_schema_exception import (
+    ConversationsMarkErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_members_error_schema_exception import (
+    ConversationsMembersErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_open_error_schema_exception import (
+    ConversationsOpenErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_rename_error_schema_exception import (
+    ConversationsRenameErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_replies_error_schema_exception import (
+    ConversationsRepliesErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_set_purpose_error_schema_exception import (
+    ConversationsSetPurposeErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_set_topic_error_schema_exception import (
+    ConversationsSetTopicErrorSchemaException,
+)
+from slackwebapi.exceptions.conversations_unarchive_error_schema_exception import (
+    ConversationsUnarchiveErrorSchemaException,
+)
+from slackwebapi.http.http_method_enum import (
+    HttpMethodEnum,
+)
+from slackwebapi.models.conversations_archive_success_schema import (
+    ConversationsArchiveSuccessSchema,
+)
+from slackwebapi.models.conversations_close_success_schema import (
+    ConversationsCloseSuccessSchema,
+)
+from slackwebapi.models.conversations_create_success_schema import (
+    ConversationsCreateSuccessSchema,
+)
+from slackwebapi.models.conversations_history_success_schema import (
+    ConversationsHistorySuccessSchema,
+)
+from slackwebapi.models.conversations_info_success_schema import (
+    ConversationsInfoSuccessSchema,
+)
+from slackwebapi.models.conversations_invite_error_schema import (
+    ConversationsInviteErrorSchema,
+)
+from slackwebapi.models.conversations_join_success_schema import (
+    ConversationsJoinSuccessSchema,
+)
+from slackwebapi.models.conversations_kick_success_schema import (
+    ConversationsKickSuccessSchema,
+)
+from slackwebapi.models.conversations_leave_success_schema import (
+    ConversationsLeaveSuccessSchema,
+)
+from slackwebapi.models.conversations_list_success_schema import (
+    ConversationsListSuccessSchema,
+)
+from slackwebapi.models.conversations_mark_success_schema import (
+    ConversationsMarkSuccessSchema,
+)
+from slackwebapi.models.conversations_members_success_schema import (
+    ConversationsMembersSuccessSchema,
+)
+from slackwebapi.models.conversations_open_success_schema import (
+    ConversationsOpenSuccessSchema,
+)
+from slackwebapi.models.conversations_rename_success_schema import (
+    ConversationsRenameSuccessSchema,
+)
+from slackwebapi.models.conversations_replies_success_schema import (
+    ConversationsRepliesSuccessSchema,
+)
+from slackwebapi.models.conversations_set_purpose_success_schema import (
+    ConversationsSetPurposeSuccessSchema,
+)
+from slackwebapi.models.conversations_set_topic_success_schema import (
+    ConversationsSetTopicSuccessSchema,
+)
+from slackwebapi.models.conversations_unarchive_success_schema import (
+    ConversationsUnarchiveSuccessSchema,
+)
+
+
+class ConversationsController(BaseController):
+    """A Controller to access Endpoints in the slackwebapi API."""
+
+    def __init__(self, config):
+        """Initialize ConversationsController object."""
+        super(ConversationsController, self).__init__(config)
+
+    def conversations_archive(self,
+                              token=None,
+                              channel=None):
+        """Perform a POST request to /conversations.archive.
+
+        Archives a conversation.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): ID of conversation to archive
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.archive")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsArchiveSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsArchiveErrorSchemaException),
+        ).execute()
+
+    def conversations_close(self,
+                            token=None,
+                            channel=None):
+        """Perform a POST request to /conversations.close.
+
+        Closes a direct message or multi-person direct message.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): Conversation to close.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.close")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsCloseSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsCloseErrorSchemaException),
+        ).execute()
+
+    def conversations_create(self,
+                             token=None,
+                             name=None,
+                             is_private=None):
+        """Perform a POST request to /conversations.create.
+
+        Initiates a public or private channel-based conversation
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            name (str, optional): Name of the public or private channel to create
+            is_private (bool, optional): Create a private channel instead of a public
+                one
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. If successful, the
+                command returns a rather stark [conversation
+                object](/types/conversation)
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.create")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("name")
+                .value(name))
+            .form_param(Parameter()
+                .key("is_private")
+                .value(is_private))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsCreateSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response when name already in use",
+                ConversationsCreateErrorSchemaException),
+        ).execute()
+
+    def conversations_history(self,
+                              token=None,
+                              channel=None,
+                              latest=None,
+                              oldest=None,
+                              inclusive=None,
+                              limit=None,
+                              cursor=None):
+        """Perform a GET request to /conversations.history.
+
+        Fetches a conversation's history of messages and events.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:history`
+            channel (str, optional): Conversation ID to fetch history for.
+            latest (float, optional): End of time range of messages to include in
+                results.
+            oldest (float, optional): Start of time range of messages to include in
+                results.
+            inclusive (bool, optional): Include messages with latest or oldest
+                timestamp in results only when either timestamp is specified.
+            limit (int, optional): The maximum number of items to return. Fewer than
+                the requested number of items may be returned, even if the end of the
+                users list hasn't been reached.
+            cursor (str, optional): Paginate through collections of data by setting
+                the `cursor` parameter to a `next_cursor` attribute returned by a
+                previous request's `response_metadata`. Default value fetches the
+                first "page" of the collection. See [pagination](/docs/pagination)
+                for more detail.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success
+                response containing a channel's messages
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.history")
+            .http_method(HttpMethodEnum.GET)
+            .header_param(Parameter()
+                .key("Content-Type")
+                .value("application/x-www-form-urlencoded"))
+            .query_param(Parameter()
+                .key("token")
+                .value(token))
+            .query_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .query_param(Parameter()
+                .key("latest")
+                .value(latest))
+            .query_param(Parameter()
+                .key("oldest")
+                .value(oldest))
+            .query_param(Parameter()
+                .key("inclusive")
+                .value(inclusive))
+            .query_param(Parameter()
+                .key("limit")
+                .value(limit))
+            .query_param(Parameter()
+                .key("cursor")
+                .value(cursor))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsHistorySuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsHistoryErrorSchemaException),
+        ).execute()
+
+    def conversations_info(self,
+                           token=None,
+                           channel=None,
+                           include_locale=None,
+                           include_num_members=None):
+        """Perform a GET request to /conversations.info.
+
+        Retrieve information about a conversation.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:read`
+            channel (str, optional): Conversation ID to learn more about
+            include_locale (bool, optional): Set this to `true` to receive the locale
+                for this conversation. Defaults to `false`
+            include_num_members (bool, optional): Set to `true` to include the member
+                count for the specified conversation. Defaults to `false`
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success
+                response for a public channel. (Also, a response from a private
+                channel and a multi-party IM is very similar to this example.)
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.info")
+            .http_method(HttpMethodEnum.GET)
+            .header_param(Parameter()
+                .key("Content-Type")
+                .value("application/x-www-form-urlencoded"))
+            .query_param(Parameter()
+                .key("token")
+                .value(token))
+            .query_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .query_param(Parameter()
+                .key("include_locale")
+                .value(include_locale))
+            .query_param(Parameter()
+                .key("include_num_members")
+                .value(include_num_members))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsInfoSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response when a channel cannot be found",
+                ConversationsInfoErrorSchemaException),
+        ).execute()
+
+    def conversations_invite(self,
+                             token=None,
+                             channel=None,
+                             users=None):
+        """Perform a POST request to /conversations.invite.
+
+        Invites users to a channel.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): The ID of the public or private channel to
+                invite user(s) to.
+            users (str, optional): A comma separated list of user IDs. Up to 1000
+                users may be listed.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success
+                response when an invitation is extended
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.invite")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .form_param(Parameter()
+                .key("users")
+                .value(users))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsInviteErrorSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response when an invite is attempted on a conversation"
+                " type that does not support it",
+                ConversationsInviteErrorSchema1Exception),
+        ).execute()
+
+    def conversations_join(self,
+                           token=None,
+                           channel=None):
+        """Perform a POST request to /conversations.join.
+
+        Joins an existing conversation.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `channels:write`
+            channel (str, optional): ID of conversation to join
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.join")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsJoinSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response if the conversation is archived and cannot be"
+                " joined",
+                ConversationsJoinErrorSchemaException),
+        ).execute()
+
+    def conversations_kick(self,
+                           token=None,
+                           channel=None,
+                           user=None):
+        """Perform a POST request to /conversations.kick.
+
+        Removes a user from a conversation.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): ID of conversation to remove user from.
+            user (str, optional): User ID to be removed.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.kick")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .form_param(Parameter()
+                .key("user")
+                .value(user))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsKickSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response when you attempt to kick yourself from a chan"
+                "nel",
+                ConversationsKickErrorSchemaException),
+        ).execute()
+
+    def conversations_leave(self,
+                            token=None,
+                            channel=None):
+        """Perform a POST request to /conversations.leave.
+
+        Leaves a conversation.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): Conversation to leave
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.leave")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsLeaveSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response when attempting to leave a workspace's 'gener"
+                "al' channel",
+                ConversationsLeaveErrorSchemaException),
+        ).execute()
+
+    def conversations_list(self,
+                           token=None,
+                           exclude_archived=None,
+                           types=None,
+                           limit=None,
+                           cursor=None):
+        """Perform a GET request to /conversations.list.
+
+        Lists all channels in a Slack team.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:read`
+            exclude_archived (bool, optional): Set to `true` to exclude archived
+                channels from the list
+            types (str, optional): Mix and match channel types by providing a
+                comma-separated list of any combination of `public_channel`,
+                `private_channel`, `mpim`, `im`
+            limit (int, optional): The maximum number of items to return. Fewer than
+                the requested number of items may be returned, even if the end of the
+                list hasn't been reached. Must be an integer no larger than 1000.
+            cursor (str, optional): Paginate through collections of data by setting
+                the `cursor` parameter to a `next_cursor` attribute returned by a
+                previous request's `response_metadata`. Default value fetches the
+                first "page" of the collection. See [pagination](/docs/pagination)
+                for more detail.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success
+                response with only public channels
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.list")
+            .http_method(HttpMethodEnum.GET)
+            .header_param(Parameter()
+                .key("Content-Type")
+                .value("application/x-www-form-urlencoded"))
+            .query_param(Parameter()
+                .key("token")
+                .value(token))
+            .query_param(Parameter()
+                .key("exclude_archived")
+                .value(exclude_archived))
+            .query_param(Parameter()
+                .key("types")
+                .value(types))
+            .query_param(Parameter()
+                .key("limit")
+                .value(limit))
+            .query_param(Parameter()
+                .key("cursor")
+                .value(cursor))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsListSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsListErrorSchemaException),
+        ).execute()
+
+    def conversations_mark(self,
+                           token=None,
+                           channel=None,
+                           ts=None):
+        """Perform a POST request to /conversations.mark.
+
+        Sets the read cursor in a channel.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): Channel or conversation to set the read cursor
+                for.
+            ts (float, optional): Unique identifier of message you want marked as
+                most recently seen in this conversation.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.mark")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .form_param(Parameter()
+                .key("ts")
+                .value(ts))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsMarkSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsMarkErrorSchemaException),
+        ).execute()
+
+    def conversations_members(self,
+                              token=None,
+                              channel=None,
+                              limit=None,
+                              cursor=None):
+        """Perform a GET request to /conversations.members.
+
+        Retrieve members of a conversation.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:read`
+            channel (str, optional): ID of the conversation to retrieve members for
+            limit (int, optional): The maximum number of items to return. Fewer than
+                the requested number of items may be returned, even if the end of the
+                users list hasn't been reached.
+            cursor (str, optional): Paginate through collections of data by setting
+                the `cursor` parameter to a `next_cursor` attribute returned by a
+                previous request's `response_metadata`. Default value fetches the
+                first "page" of the collection. See [pagination](/docs/pagination)
+                for more detail.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical paginated
+                success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.members")
+            .http_method(HttpMethodEnum.GET)
+            .header_param(Parameter()
+                .key("Content-Type")
+                .value("application/x-www-form-urlencoded"))
+            .query_param(Parameter()
+                .key("token")
+                .value(token))
+            .query_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .query_param(Parameter()
+                .key("limit")
+                .value(limit))
+            .query_param(Parameter()
+                .key("cursor")
+                .value(cursor))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsMembersSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response when an invalid cursor is provided",
+                ConversationsMembersErrorSchemaException),
+        ).execute()
+
+    def conversations_open(self,
+                           token=None,
+                           channel=None,
+                           users=None,
+                           return_im=None):
+        """Perform a POST request to /conversations.open.
+
+        Opens or resumes a direct message or multi-person direct message.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): Resume a conversation by supplying an `im` or
+                `mpim`'s ID. Or provide the `users` field instead.
+            users (str, optional): Comma separated lists of users. If only one user
+                is included, this creates a 1:1 DM.  The ordering of the users is
+                preserved whenever a multi-person direct message is returned. Supply
+                a `channel` when not supplying `users`.
+            return_im (bool, optional): Boolean, indicates you want the full IM
+                channel definition in the response.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.open")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .form_param(Parameter()
+                .key("users")
+                .value(users))
+            .form_param(Parameter()
+                .key("return_im")
+                .value(return_im))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsOpenSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsOpenErrorSchemaException),
+        ).execute()
+
+    def conversations_rename(self,
+                             token=None,
+                             channel=None,
+                             name=None):
+        """Perform a POST request to /conversations.rename.
+
+        Renames a conversation.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): ID of conversation to rename
+            name (str, optional): New name for conversation.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.rename")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .form_param(Parameter()
+                .key("name")
+                .value(name))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsRenameSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response when the calling user is not a member of the "
+                "conversation",
+                ConversationsRenameErrorSchemaException),
+        ).execute()
+
+    def conversations_replies(self,
+                              token=None,
+                              channel=None,
+                              ts=None,
+                              latest=None,
+                              oldest=None,
+                              inclusive=None,
+                              limit=None,
+                              cursor=None):
+        """Perform a GET request to /conversations.replies.
+
+        Retrieve a thread of messages posted to a conversation
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:history`
+            channel (str, optional): Conversation ID to fetch thread from.
+            ts (float, optional): Unique identifier of a thread's parent message.
+                `ts` must be the timestamp of an existing message with 0 or more
+                replies. If there are no replies then just the single message
+                referenced by `ts` will return - it is just an ordinary, unthreaded
+                message.
+            latest (float, optional): End of time range of messages to include in
+                results.
+            oldest (float, optional): Start of time range of messages to include in
+                results.
+            inclusive (bool, optional): Include messages with latest or oldest
+                timestamp in results only when either timestamp is specified.
+            limit (int, optional): The maximum number of items to return. Fewer than
+                the requested number of items may be returned, even if the end of the
+                users list hasn't been reached.
+            cursor (str, optional): Paginate through collections of data by setting
+                the `cursor` parameter to a `next_cursor` attribute returned by a
+                previous request's `response_metadata`. Default value fetches the
+                first "page" of the collection. See [pagination](/docs/pagination)
+                for more detail.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.replies")
+            .http_method(HttpMethodEnum.GET)
+            .header_param(Parameter()
+                .key("Content-Type")
+                .value("application/x-www-form-urlencoded"))
+            .query_param(Parameter()
+                .key("token")
+                .value(token))
+            .query_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .query_param(Parameter()
+                .key("ts")
+                .value(ts))
+            .query_param(Parameter()
+                .key("latest")
+                .value(latest))
+            .query_param(Parameter()
+                .key("oldest")
+                .value(oldest))
+            .query_param(Parameter()
+                .key("inclusive")
+                .value(inclusive))
+            .query_param(Parameter()
+                .key("limit")
+                .value(limit))
+            .query_param(Parameter()
+                .key("cursor")
+                .value(cursor))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsRepliesSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsRepliesErrorSchemaException),
+        ).execute()
+
+    def conversations_set_purpose(self,
+                                  token=None,
+                                  channel=None,
+                                  purpose=None):
+        """Perform a POST request to /conversations.setPurpose.
+
+        Sets the purpose for a conversation.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): Conversation to set the purpose of
+            purpose (str, optional): A new, specialer purpose
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.setPurpose")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .form_param(Parameter()
+                .key("purpose")
+                .value(purpose))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsSetPurposeSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsSetPurposeErrorSchemaException),
+        ).execute()
+
+    def conversations_set_topic(self,
+                                token=None,
+                                channel=None,
+                                topic=None):
+        """Perform a POST request to /conversations.setTopic.
+
+        Sets the topic for a conversation.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): Conversation to set the topic of
+            topic (str, optional): The new topic string. Does not support formatting
+                or linkification.
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.setTopic")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .form_param(Parameter()
+                .key("topic")
+                .value(topic))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsSetTopicSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsSetTopicErrorSchemaException),
+        ).execute()
+
+    def conversations_unarchive(self,
+                                token=None,
+                                channel=None):
+        """Perform a POST request to /conversations.unarchive.
+
+        Reverses conversation archival.
+
+        Args:
+            token (str, optional): Authentication token. Requires scope:
+                `conversations:write`
+            channel (str, optional): ID of conversation to unarchive
+
+        Returns:
+            ApiResponse: An object with the response value as well as other useful
+                information such as status codes and headers. Typical success response
+
+        Raises:
+            ApiException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/conversations.unarchive")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("token")
+                .value(token))
+            .form_param(Parameter()
+                .key("channel")
+                .value(channel))
+            .header_param(Parameter()
+                            .key("content-type")
+                            .value("application/x-www-form-urlencoded"))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("slackAuth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(ConversationsUnarchiveSuccessSchema.from_dictionary)
+            .is_api_response(True)
+            .local_error("default",
+                "Typical error response",
+                ConversationsUnarchiveErrorSchemaException),
+        ).execute()