slackapi-sdk 1.0.0

data/lib/slack_web_api/controllers/admin_apps_controller.rb

@@ -0,0 +1,78 @@
+# slack_web_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SlackWebApi
+  # AdminAppsController
+  class AdminAppsController < BaseController
+    # Approve an app for installation on a workspace.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.apps:write`
+    # @param [String] app_id Optional parameter: The id of the app to approve.
+    # @param [String] request_id Optional parameter: The id of the request to
+    # approve.
+    # @param [String] team_id Optional parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_apps_approve(token,
+                           app_id: nil,
+                           request_id: nil,
+                           team_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.apps.approve',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(app_id, key: 'app_id'))
+                   .form_param(new_parameter(request_id, key: 'request_id'))
+                   .form_param(new_parameter(team_id, key: 'team_id'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DefaultSuccessTemplate.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 DefaultErrorTemplateException))
+        .execute
+    end
+
+    # Restrict an app for installation on a workspace.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.apps:write`
+    # @param [String] app_id Optional parameter: The id of the app to
+    # restrict.
+    # @param [String] request_id Optional parameter: The id of the request to
+    # restrict.
+    # @param [String] team_id Optional parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_apps_restrict(token,
+                            app_id: nil,
+                            request_id: nil,
+                            team_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.apps.restrict',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(app_id, key: 'app_id'))
+                   .form_param(new_parameter(request_id, key: 'request_id'))
+                   .form_param(new_parameter(team_id, key: 'team_id'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DefaultSuccessTemplate.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 DefaultErrorTemplateException))
+        .execute
+    end
+  end
+end

data/lib/slack_web_api/controllers/admin_apps_requests_controller.rb

@@ -0,0 +1,44 @@
+# slack_web_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SlackWebApi
+  # AdminAppsRequestsController
+  class AdminAppsRequestsController < BaseController
+    # List app requests for a team/workspace.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.apps:read`
+    # @param [Integer] limit Optional parameter: The maximum number of items to
+    # return. Must be between 1 - 1000 both inclusive.
+    # @param [String] cursor Optional parameter: Set `cursor` to `next_cursor`
+    # returned by the previous call to list items in the next page
+    # @param [String] team_id Optional parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_apps_requests_list(token,
+                                 limit: nil,
+                                 cursor: nil,
+                                 team_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/admin.apps.requests.list',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(token, key: 'token')
+                                 .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'Content-Type'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .query_param(new_parameter(team_id, key: 'team_id'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DefaultSuccessTemplate.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 DefaultErrorTemplateException))
+        .execute
+    end
+  end
+end

data/lib/slack_web_api/controllers/admin_apps_restricted_controller.rb

@@ -0,0 +1,48 @@
+# slack_web_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SlackWebApi
+  # AdminAppsRestrictedController
+  class AdminAppsRestrictedController < BaseController
+    # List restricted apps for an org or workspace.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.apps:read`
+    # @param [Integer] limit Optional parameter: The maximum number of items to
+    # return. Must be between 1 - 1000 both inclusive.
+    # @param [String] cursor Optional parameter: Set `cursor` to `next_cursor`
+    # returned by the previous call to list items in the next page
+    # @param [String] team_id Optional parameter: TODO: type description here
+    # @param [String] enterprise_id Optional parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_apps_restricted_list(token,
+                                   limit: nil,
+                                   cursor: nil,
+                                   team_id: nil,
+                                   enterprise_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/admin.apps.restricted.list',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(token, key: 'token')
+                                 .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'Content-Type'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .query_param(new_parameter(team_id, key: 'team_id'))
+                   .query_param(new_parameter(enterprise_id, key: 'enterprise_id'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DefaultSuccessTemplate.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 DefaultErrorTemplateException))
+        .execute
+    end
+  end
+end

data/lib/slack_web_api/controllers/admin_conversations_controller.rb

@@ -0,0 +1,472 @@
+# slack_web_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SlackWebApi
+  # AdminConversationsController
+  class AdminConversationsController < BaseController
+    # Archive a public or private channel.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] channel_id Required parameter: The channel to archive.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_archive(token,
+                                    channel_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.archive',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsArchiveSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsArchiveErrorSchemaException))
+        .execute
+    end
+
+    # Convert a public channel to a private channel.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] channel_id Required parameter: The channel to convert to
+    # private.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_convert_to_private(token,
+                                               channel_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.convertToPrivate',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsConvertToPrivateSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsConvertToPrivateErrorSchemaException))
+        .execute
+    end
+
+    # Create a public or private channel-based conversation.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] name Required parameter: Name of the public or private
+    # channel to create.
+    # @param [TrueClass | FalseClass] is_private Required parameter: When
+    # `true`, creates a private channel instead of a public channel
+    # @param [String] description Optional parameter: Description of the public
+    # or private channel to create.
+    # @param [TrueClass | FalseClass] org_wide Optional parameter: 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
+    # @param [String] team_id Optional parameter: The workspace to create the
+    # channel in. Note: this argument is required unless you set
+    # `org_wide=true`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_create(token,
+                                   name,
+                                   is_private,
+                                   description: nil,
+                                   org_wide: nil,
+                                   team_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.create',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(name, key: 'name')
+                                .is_required(true))
+                   .form_param(new_parameter(is_private, key: 'is_private')
+                                .is_required(true))
+                   .form_param(new_parameter(description, key: 'description'))
+                   .form_param(new_parameter(org_wide, key: 'org_wide'))
+                   .form_param(new_parameter(team_id, key: 'team_id'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsCreateSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsCreateErrorSchemaException))
+        .execute
+    end
+
+    # Delete a public or private channel.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] channel_id Required parameter: The channel to delete.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_delete(token,
+                                   channel_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.delete',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsDeleteSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsDeleteErrorSchemaException))
+        .execute
+    end
+
+    # Disconnect a connected channel from one or more workspaces.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] channel_id Required parameter: The channel to be
+    # disconnected from some workspaces.
+    # @param [String] leaving_team_ids Optional parameter: The team to be
+    # removed from the channel. Currently only a single team id can be
+    # specified.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_disconnect_shared(token,
+                                              channel_id,
+                                              leaving_team_ids: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.disconnectShared',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .form_param(new_parameter(leaving_team_ids, key: 'leaving_team_ids'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsRenameSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsDisconnectSharedErrorSchemaException))
+        .execute
+    end
+
+    # Get conversation preferences for a public or private channel.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:read`
+    # @param [String] channel_id Required parameter: The channel to get
+    # preferences for.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_get_conversation_prefs(token,
+                                                   channel_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/admin.conversations.getConversationPrefs',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .query_param(new_parameter(channel_id, key: 'channel_id')
+                                 .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'Content-Type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsGetConversationPrefsSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsUnarchiveErrorSchemaException))
+        .execute
+    end
+
+    # Get all the workspaces a given public or private channel is connected to
+    # within this Enterprise org.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:read`
+    # @param [String] channel_id Required parameter: The channel to determine
+    # connected workspaces within the organization for.
+    # @param [String] cursor Optional parameter: Set `cursor` to `next_cursor`
+    # returned by the previous call to list items in the next page
+    # @param [Integer] limit Optional parameter: The maximum number of items to
+    # return. Must be between 1 - 1000 both inclusive.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_get_teams(token,
+                                      channel_id,
+                                      cursor: nil,
+                                      limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/admin.conversations.getTeams',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .query_param(new_parameter(channel_id, key: 'channel_id')
+                                 .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'Content-Type'))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsGetTeamsSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsGetTeamsErrorSchemaException))
+        .execute
+    end
+
+    # Invite a user to a public or private channel.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] user_ids Required parameter: The users to invite.
+    # @param [String] channel_id Required parameter: The channel that the users
+    # will be invited to.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_invite(token,
+                                   user_ids,
+                                   channel_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.invite',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(user_ids, key: 'user_ids')
+                                .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsInviteSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsInviteErrorSchemaException))
+        .execute
+    end
+
+    # Rename a public or private channel.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] channel_id Required parameter: The channel to rename.
+    # @param [String] name Required parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_rename(token,
+                                   channel_id,
+                                   name)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.rename',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .form_param(new_parameter(name, key: 'name')
+                                .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsRenameSchema1.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsUnarchiveErrorSchema2Exception))
+        .execute
+    end
+
+    # Search for public or private channels in an Enterprise organization.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:read`
+    # @param [String] team_ids Optional parameter: Comma separated string of
+    # team IDs, signifying the workspaces to search through.
+    # @param [String] query Optional parameter: Name of the the channel to query
+    # by.
+    # @param [Integer] limit Optional parameter: Maximum number of items to be
+    # returned. Must be between 1 - 20 both inclusive. Default is 10.
+    # @param [String] cursor Optional parameter: Set `cursor` to `next_cursor`
+    # returned by the previous call to list items in the next page.
+    # @param [String] search_channel_types Optional parameter: 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).
+    # @param [String] sort Optional parameter: 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
+    # @param [String] sort_dir Optional parameter: 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)
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_search(token,
+                                   team_ids: nil,
+                                   query: nil,
+                                   limit: nil,
+                                   cursor: nil,
+                                   search_channel_types: nil,
+                                   sort: nil,
+                                   sort_dir: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/admin.conversations.search',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'Content-Type'))
+                   .query_param(new_parameter(team_ids, key: 'team_ids'))
+                   .query_param(new_parameter(query, key: 'query'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .query_param(new_parameter(search_channel_types, key: 'search_channel_types'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(sort_dir, key: 'sort_dir'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsSearchSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsSearchErrorSchemaException))
+        .execute
+    end
+
+    # Set the posting permissions for a public or private channel.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] channel_id Required parameter: The channel to set the
+    # prefs for
+    # @param [String] prefs Required parameter: The prefs for this channel in a
+    # stringified JSON format.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_set_conversation_prefs(token,
+                                                   channel_id,
+                                                   prefs)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.setConversationPrefs',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .form_param(new_parameter(prefs, key: 'prefs')
+                                .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsSetConversationPrefsSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsSetConversationPrefsErrorSchemaException))
+        .execute
+    end
+
+    # Set the workspaces in an Enterprise grid org that connect to a public or
+    # private channel.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] channel_id Required parameter: The encoded `channel_id` to
+    # add or remove to workspaces.
+    # @param [String] team_id Optional parameter: The workspace to which the
+    # channel belongs. Omit this argument if the channel is a cross-workspace
+    # shared channel.
+    # @param [String] target_team_ids Optional parameter: A comma-separated list
+    # of workspaces to which the channel should be shared. Not required if the
+    # channel is being shared org-wide.
+    # @param [TrueClass | FalseClass] org_channel Optional parameter: True if
+    # channel has to be converted to an org channel
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_set_teams(token,
+                                      channel_id,
+                                      team_id: nil,
+                                      target_team_ids: nil,
+                                      org_channel: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.setTeams',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .form_param(new_parameter(team_id, key: 'team_id'))
+                   .form_param(new_parameter(target_team_ids, key: 'target_team_ids'))
+                   .form_param(new_parameter(org_channel, key: 'org_channel'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DefaultSuccessTemplate.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 DefaultErrorTemplateException))
+        .execute
+    end
+
+    # Unarchive a public or private channel.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] channel_id Required parameter: The channel to unarchive.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_unarchive(token,
+                                      channel_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.unarchive',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(token, key: 'token')
+                                  .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('slackAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AdminConversationsUnarchiveSchema.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 AdminConversationsUnarchiveErrorSchema3Exception))
+        .execute
+    end
+  end
+end