slack-apimatic-sdk 1.0.0

data/lib/slack_web_api/apis/admin_conversations_api.rb

@@ -0,0 +1,472 @@
+# slack_web_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SlackWebApi
+  # AdminConversationsApi
+  class AdminConversationsApi < BaseApi
+    # 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

data/lib/slack_web_api/apis/admin_conversations_ekm_api.rb

@@ -0,0 +1,51 @@
+# slack_web_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SlackWebApi
+  # AdminConversationsEkmApi
+  class AdminConversationsEkmApi < BaseApi
+    # List all disconnected channels—i.e., channels that were once connected to
+    # other workspaces and then disconnected—and the corresponding original
+    # channel IDs for key revocation with EKM.
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:read`
+    # @param [String] channel_ids Optional parameter: A comma-separated list of
+    # channels to filter to.
+    # @param [String] team_ids Optional parameter: A comma-separated list of the
+    # workspaces to which the channels you would like returned belong.
+    # @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.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_ekm_list_original_connected_channel_info(token,
+                                                                     channel_ids: nil,
+                                                                     team_ids: nil,
+                                                                     limit: nil,
+                                                                     cursor: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/admin.conversations.ekm.listOriginalConnectedChannelInfo',
+                                     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(channel_ids, key: 'channel_ids'))
+                   .query_param(new_parameter(team_ids, key: 'team_ids'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .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/apis/admin_conversations_restrict_access_api.rb

@@ -0,0 +1,129 @@
+# slack_web_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module SlackWebApi
+  # AdminConversationsRestrictAccessApi
+  class AdminConversationsRestrictAccessApi < BaseApi
+    # Add an allowlist of IDP groups for accessing a channel
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] group_id Required parameter: The [IDP
+    # Group](https://slack.com/help/articles/115001435788-Connect-identity-provi
+    # der-groups-to-your-Enterprise-Grid-org) ID to be an allowlist for the
+    # private channel.
+    # @param [String] channel_id Required parameter: The channel to link this
+    # group to.
+    # @param [String] team_id Optional parameter: The workspace where the
+    # channel exists. This argument is required for channels only tied to one
+    # workspace, and optional for channels that are shared across an
+    # organization.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_restrict_access_add_group(token,
+                                                      group_id,
+                                                      channel_id,
+                                                      team_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.restrictAccess.addGroup',
+                                     Server::DEFAULT)
+                   .form_param(new_parameter(token, key: 'token')
+                                .is_required(true))
+                   .form_param(new_parameter(group_id, key: 'group_id')
+                                .is_required(true))
+                   .form_param(new_parameter(channel_id, key: 'channel_id')
+                                .is_required(true))
+                   .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
+
+    # List all IDP Groups linked to a channel
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:read`
+    # @param [String] channel_id Required parameter: TODO: type description
+    # here
+    # @param [String] team_id Optional parameter: The workspace where the
+    # channel exists. This argument is required for channels only tied to one
+    # workspace, and optional for channels that are shared across an
+    # organization.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_restrict_access_list_groups(token,
+                                                        channel_id,
+                                                        team_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/admin.conversations.restrictAccess.listGroups',
+                                     Server::DEFAULT)
+                   .query_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(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
+
+    # Remove a linked IDP group linked from a private channel
+    # @param [String] token Required parameter: Authentication token. Requires
+    # scope: `admin.conversations:write`
+    # @param [String] team_id Required parameter: The workspace where the
+    # channel exists. This argument is required for channels only tied to one
+    # workspace, and optional for channels that are shared across an
+    # organization.
+    # @param [String] group_id Required parameter: The [IDP
+    # Group](https://slack.com/help/articles/115001435788-Connect-identity-provi
+    # der-groups-to-your-Enterprise-Grid-org) ID to remove from the private
+    # channel.
+    # @param [String] channel_id Required parameter: The channel to remove the
+    # linked group from.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def admin_conversations_restrict_access_remove_group(token,
+                                                         team_id,
+                                                         group_id,
+                                                         channel_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/admin.conversations.restrictAccess.removeGroup',
+                                     Server::DEFAULT)
+                   .form_param(new_parameter(token, key: 'token')
+                                .is_required(true))
+                   .form_param(new_parameter(team_id, key: 'team_id')
+                                .is_required(true))
+                   .form_param(new_parameter(group_id, key: 'group_id')
+                                .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(DefaultSuccessTemplate.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Typical error response',
+                                 DefaultErrorTemplateException))
+        .execute
+    end
+  end
+end