• Home
• com.slack.api
• slack-api-client
• 1.28.0
• source code
• AsyncMethodsClientImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.slack.api.methods.impl.AsyncMethodsClientImpl Maven / Gradle / Ivy

package com.slack.api.methods.impl;

import com.slack.api.RequestConfigurator;
import com.slack.api.SlackConfig;
import com.slack.api.methods.AsyncMethodsClient;
import com.slack.api.methods.MethodsClient;
import com.slack.api.methods.SlackApiRequest;
import com.slack.api.methods.request.admin.analytics.AdminAnalyticsGetFileRequest;
import com.slack.api.methods.request.admin.apps.*;
import com.slack.api.methods.request.admin.auth.policy.AdminAuthPolicyAssignEntitiesRequest;
import com.slack.api.methods.request.admin.auth.policy.AdminAuthPolicyGetEntitiesRequest;
import com.slack.api.methods.request.admin.auth.policy.AdminAuthPolicyRemoveEntitiesRequest;
import com.slack.api.methods.request.admin.barriers.AdminBarriersCreateRequest;
import com.slack.api.methods.request.admin.barriers.AdminBarriersDeleteRequest;
import com.slack.api.methods.request.admin.barriers.AdminBarriersListRequest;
import com.slack.api.methods.request.admin.barriers.AdminBarriersUpdateRequest;
import com.slack.api.methods.request.admin.conversations.*;
import com.slack.api.methods.request.admin.conversations.ekm.AdminConversationsEkmListOriginalConnectedChannelInfoRequest;
import com.slack.api.methods.request.admin.conversations.restrict_access.AdminConversationsRestrictAccessAddGroupRequest;
import com.slack.api.methods.request.admin.conversations.restrict_access.AdminConversationsRestrictAccessListGroupsRequest;
import com.slack.api.methods.request.admin.conversations.restrict_access.AdminConversationsRestrictAccessRemoveGroupRequest;
import com.slack.api.methods.request.admin.conversations.whitelist.AdminConversationsWhitelistAddRequest;
import com.slack.api.methods.request.admin.conversations.whitelist.AdminConversationsWhitelistListGroupsLinkedToChannelRequest;
import com.slack.api.methods.request.admin.conversations.whitelist.AdminConversationsWhitelistRemoveRequest;
import com.slack.api.methods.request.admin.emoji.*;
import com.slack.api.methods.request.admin.invite_requests.*;
import com.slack.api.methods.request.admin.roles.AdminRolesAddAssignmentsRequest;
import com.slack.api.methods.request.admin.roles.AdminRolesListAssignmentsRequest;
import com.slack.api.methods.request.admin.roles.AdminRolesRemoveAssignmentsRequest;
import com.slack.api.methods.request.admin.teams.AdminTeamsAdminsListRequest;
import com.slack.api.methods.request.admin.teams.AdminTeamsCreateRequest;
import com.slack.api.methods.request.admin.teams.AdminTeamsListRequest;
import com.slack.api.methods.request.admin.teams.owners.AdminTeamsOwnersListRequest;
import com.slack.api.methods.request.admin.teams.settings.*;
import com.slack.api.methods.request.admin.usergroups.AdminUsergroupsAddChannelsRequest;
import com.slack.api.methods.request.admin.usergroups.AdminUsergroupsAddTeamsRequest;
import com.slack.api.methods.request.admin.usergroups.AdminUsergroupsListChannelsRequest;
import com.slack.api.methods.request.admin.usergroups.AdminUsergroupsRemoveChannelsRequest;
import com.slack.api.methods.request.admin.users.*;
import com.slack.api.methods.request.admin.users.unsupported_versions.AdminUsersUnsupportedVersionsExportRequest;
import com.slack.api.methods.request.api.ApiTestRequest;
import com.slack.api.methods.request.apps.AppsUninstallRequest;
import com.slack.api.methods.request.apps.connections.AppsConnectionsOpenRequest;
import com.slack.api.methods.request.apps.event.authorizations.AppsEventAuthorizationsListRequest;
import com.slack.api.methods.request.auth.AuthRevokeRequest;
import com.slack.api.methods.request.auth.AuthTestRequest;
import com.slack.api.methods.request.auth.teams.AuthTeamsListRequest;
import com.slack.api.methods.request.bookmarks.BookmarksAddRequest;
import com.slack.api.methods.request.bookmarks.BookmarksEditRequest;
import com.slack.api.methods.request.bookmarks.BookmarksListRequest;
import com.slack.api.methods.request.bookmarks.BookmarksRemoveRequest;
import com.slack.api.methods.request.bots.BotsInfoRequest;
import com.slack.api.methods.request.calls.CallsAddRequest;
import com.slack.api.methods.request.calls.CallsEndRequest;
import com.slack.api.methods.request.calls.CallsInfoRequest;
import com.slack.api.methods.request.calls.CallsUpdateRequest;
import com.slack.api.methods.request.calls.participants.CallsParticipantsAddRequest;
import com.slack.api.methods.request.calls.participants.CallsParticipantsRemoveRequest;
import com.slack.api.methods.request.chat.*;
import com.slack.api.methods.request.chat.scheduled_messages.ChatScheduledMessagesListRequest;
import com.slack.api.methods.request.conversations.*;
import com.slack.api.methods.request.dialog.DialogOpenRequest;
import com.slack.api.methods.request.dnd.*;
import com.slack.api.methods.request.emoji.EmojiListRequest;
import com.slack.api.methods.request.files.*;
import com.slack.api.methods.request.files.remote.*;
import com.slack.api.methods.request.migration.MigrationExchangeRequest;
import com.slack.api.methods.request.oauth.OAuthAccessRequest;
import com.slack.api.methods.request.oauth.OAuthTokenRequest;
import com.slack.api.methods.request.oauth.OAuthV2AccessRequest;
import com.slack.api.methods.request.oauth.OAuthV2ExchangeRequest;
import com.slack.api.methods.request.openid.connect.OpenIDConnectTokenRequest;
import com.slack.api.methods.request.openid.connect.OpenIDConnectUserInfoRequest;
import com.slack.api.methods.request.pins.PinsAddRequest;
import com.slack.api.methods.request.pins.PinsListRequest;
import com.slack.api.methods.request.pins.PinsRemoveRequest;
import com.slack.api.methods.request.reactions.ReactionsAddRequest;
import com.slack.api.methods.request.reactions.ReactionsGetRequest;
import com.slack.api.methods.request.reactions.ReactionsListRequest;
import com.slack.api.methods.request.reactions.ReactionsRemoveRequest;
import com.slack.api.methods.request.reminders.*;
import com.slack.api.methods.request.rtm.RTMConnectRequest;
import com.slack.api.methods.request.rtm.RTMStartRequest;
import com.slack.api.methods.request.search.SearchAllRequest;
import com.slack.api.methods.request.search.SearchFilesRequest;
import com.slack.api.methods.request.search.SearchMessagesRequest;
import com.slack.api.methods.request.stars.StarsAddRequest;
import com.slack.api.methods.request.stars.StarsListRequest;
import com.slack.api.methods.request.stars.StarsRemoveRequest;
import com.slack.api.methods.request.team.*;
import com.slack.api.methods.request.team.profile.TeamProfileGetRequest;
import com.slack.api.methods.request.usergroups.*;
import com.slack.api.methods.request.usergroups.users.UsergroupsUsersListRequest;
import com.slack.api.methods.request.usergroups.users.UsergroupsUsersUpdateRequest;
import com.slack.api.methods.request.users.*;
import com.slack.api.methods.request.users.profile.UsersProfileGetRequest;
import com.slack.api.methods.request.users.profile.UsersProfileSetRequest;
import com.slack.api.methods.request.views.ViewsOpenRequest;
import com.slack.api.methods.request.views.ViewsPublishRequest;
import com.slack.api.methods.request.views.ViewsPushRequest;
import com.slack.api.methods.request.views.ViewsUpdateRequest;
import com.slack.api.methods.request.workflows.WorkflowsStepCompletedRequest;
import com.slack.api.methods.request.workflows.WorkflowsStepFailedRequest;
import com.slack.api.methods.request.workflows.WorkflowsUpdateStepRequest;
import com.slack.api.methods.response.admin.analytics.AdminAnalyticsGetFileResponse;
import com.slack.api.methods.response.admin.apps.*;
import com.slack.api.methods.response.admin.auth.policy.AdminAuthPolicyAssignEntitiesResponse;
import com.slack.api.methods.response.admin.auth.policy.AdminAuthPolicyGetEntitiesResponse;
import com.slack.api.methods.response.admin.auth.policy.AdminAuthPolicyRemoveEntitiesResponse;
import com.slack.api.methods.response.admin.barriers.AdminBarriersCreateResponse;
import com.slack.api.methods.response.admin.barriers.AdminBarriersDeleteResponse;
import com.slack.api.methods.response.admin.barriers.AdminBarriersListResponse;
import com.slack.api.methods.response.admin.barriers.AdminBarriersUpdateResponse;
import com.slack.api.methods.response.admin.conversations.*;
import com.slack.api.methods.response.admin.conversations.ekm.AdminConversationsEkmListOriginalConnectedChannelInfoResponse;
import com.slack.api.methods.response.admin.conversations.restrict_access.AdminConversationsRestrictAccessAddGroupResponse;
import com.slack.api.methods.response.admin.conversations.restrict_access.AdminConversationsRestrictAccessListGroupsResponse;
import com.slack.api.methods.response.admin.conversations.restrict_access.AdminConversationsRestrictAccessRemoveGroupResponse;
import com.slack.api.methods.response.admin.conversations.whitelist.AdminConversationsWhitelistAddResponse;
import com.slack.api.methods.response.admin.conversations.whitelist.AdminConversationsWhitelistListGroupsLinkedToChannelResponse;
import com.slack.api.methods.response.admin.conversations.whitelist.AdminConversationsWhitelistRemoveResponse;
import com.slack.api.methods.response.admin.emoji.*;
import com.slack.api.methods.response.admin.invite_requests.*;
import com.slack.api.methods.response.admin.roles.AdminRolesAddAssignmentsResponse;
import com.slack.api.methods.response.admin.roles.AdminRolesListAssignmentsResponse;
import com.slack.api.methods.response.admin.roles.AdminRolesRemoveAssignmentsResponse;
import com.slack.api.methods.response.admin.teams.AdminTeamsAdminsListResponse;
import com.slack.api.methods.response.admin.teams.AdminTeamsCreateResponse;
import com.slack.api.methods.response.admin.teams.AdminTeamsListResponse;
import com.slack.api.methods.response.admin.teams.owners.AdminTeamsOwnersListResponse;
import com.slack.api.methods.response.admin.teams.settings.*;
import com.slack.api.methods.response.admin.usergroups.AdminUsergroupsAddChannelsResponse;
import com.slack.api.methods.response.admin.usergroups.AdminUsergroupsAddTeamsResponse;
import com.slack.api.methods.response.admin.usergroups.AdminUsergroupsListChannelsResponse;
import com.slack.api.methods.response.admin.usergroups.AdminUsergroupsRemoveChannelsResponse;
import com.slack.api.methods.response.admin.users.*;
import com.slack.api.methods.response.admin.users.unsupported_versions.AdminUsersUnsupportedVersionsExportResponse;
import com.slack.api.methods.response.api.ApiTestResponse;
import com.slack.api.methods.response.apps.AppsUninstallResponse;
import com.slack.api.methods.response.apps.connections.AppsConnectionsOpenResponse;
import com.slack.api.methods.response.apps.event.authorizations.AppsEventAuthorizationsListResponse;
import com.slack.api.methods.response.auth.AuthRevokeResponse;
import com.slack.api.methods.response.auth.AuthTestResponse;
import com.slack.api.methods.response.auth.teams.AuthTeamsListResponse;
import com.slack.api.methods.response.bookmarks.BookmarksAddResponse;
import com.slack.api.methods.response.bookmarks.BookmarksEditResponse;
import com.slack.api.methods.response.bookmarks.BookmarksListResponse;
import com.slack.api.methods.response.bookmarks.BookmarksRemoveResponse;
import com.slack.api.methods.response.bots.BotsInfoResponse;
import com.slack.api.methods.response.calls.CallsAddResponse;
import com.slack.api.methods.response.calls.CallsEndResponse;
import com.slack.api.methods.response.calls.CallsInfoResponse;
import com.slack.api.methods.response.calls.CallsUpdateResponse;
import com.slack.api.methods.response.calls.participants.CallsParticipantsAddResponse;
import com.slack.api.methods.response.calls.participants.CallsParticipantsRemoveResponse;
import com.slack.api.methods.response.chat.*;
import com.slack.api.methods.response.chat.scheduled_messages.ChatScheduledMessagesListResponse;
import com.slack.api.methods.response.conversations.*;
import com.slack.api.methods.response.dialog.DialogOpenResponse;
import com.slack.api.methods.response.dnd.*;
import com.slack.api.methods.response.emoji.EmojiListResponse;
import com.slack.api.methods.response.files.*;
import com.slack.api.methods.response.files.remote.*;
import com.slack.api.methods.response.migration.MigrationExchangeResponse;
import com.slack.api.methods.response.oauth.OAuthAccessResponse;
import com.slack.api.methods.response.oauth.OAuthTokenResponse;
import com.slack.api.methods.response.oauth.OAuthV2AccessResponse;
import com.slack.api.methods.response.oauth.OAuthV2ExchangeResponse;
import com.slack.api.methods.response.openid.connect.OpenIDConnectTokenResponse;
import com.slack.api.methods.response.openid.connect.OpenIDConnectUserInfoResponse;
import com.slack.api.methods.response.pins.PinsAddResponse;
import com.slack.api.methods.response.pins.PinsListResponse;
import com.slack.api.methods.response.pins.PinsRemoveResponse;
import com.slack.api.methods.response.reactions.ReactionsAddResponse;
import com.slack.api.methods.response.reactions.ReactionsGetResponse;
import com.slack.api.methods.response.reactions.ReactionsListResponse;
import com.slack.api.methods.response.reactions.ReactionsRemoveResponse;
import com.slack.api.methods.response.reminders.*;
import com.slack.api.methods.response.rtm.RTMConnectResponse;
import com.slack.api.methods.response.rtm.RTMStartResponse;
import com.slack.api.methods.response.search.SearchAllResponse;
import com.slack.api.methods.response.search.SearchFilesResponse;
import com.slack.api.methods.response.search.SearchMessagesResponse;
import com.slack.api.methods.response.stars.StarsAddResponse;
import com.slack.api.methods.response.stars.StarsListResponse;
import com.slack.api.methods.response.stars.StarsRemoveResponse;
import com.slack.api.methods.response.team.*;
import com.slack.api.methods.response.team.profile.TeamProfileGetResponse;
import com.slack.api.methods.response.usergroups.*;
import com.slack.api.methods.response.usergroups.users.UsergroupsUsersListResponse;
import com.slack.api.methods.response.usergroups.users.UsergroupsUsersUpdateResponse;
import com.slack.api.methods.response.users.*;
import com.slack.api.methods.response.users.profile.UsersProfileGetResponse;
import com.slack.api.methods.response.users.profile.UsersProfileSetResponse;
import com.slack.api.methods.response.views.ViewsOpenResponse;
import com.slack.api.methods.response.views.ViewsPublishResponse;
import com.slack.api.methods.response.views.ViewsPushResponse;
import com.slack.api.methods.response.views.ViewsUpdateResponse;
import com.slack.api.methods.response.workflows.WorkflowsStepCompletedResponse;
import com.slack.api.methods.response.workflows.WorkflowsStepFailedResponse;
import com.slack.api.methods.response.workflows.WorkflowsUpdateStepResponse;
import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

import static com.slack.api.methods.Methods.*;

@Slf4j
public class AsyncMethodsClientImpl implements AsyncMethodsClient {

    private final String token;
    private final MethodsClientImpl methods;
    private final AsyncRateLimitExecutor executor;

    public AsyncMethodsClientImpl(String token, MethodsClientImpl clientImpl, SlackConfig config) {
        this.token = token;
        this.methods = clientImpl;
        this.executor = AsyncRateLimitExecutor.getOrCreate(clientImpl, config);
    }

    private String token(SlackApiRequest req) {
        if (req.getToken() != null) {
            return req.getToken();
        } else {
            return this.token;
        }
    }

    private Map toMap(SlackApiRequest req) {
        Map params = new HashMap<>();
        params.put("token", token(req));
        return params;
    }

    // ----------------------------------------------------------------------------------
    // public methods
    // ----------------------------------------------------------------------------------

    @Override
    public MethodsClient underlying() {
        return this.methods;
    }

    @Override
    public CompletableFuture adminAnalyticsGetFile(AdminAnalyticsGetFileRequest req) {
        return executor.execute(ADMIN_ANALYTICS_GET_FILE, toMap(req), () -> methods.adminAnalyticsGetFile(req));
    }

    @Override
    public CompletableFuture adminAnalyticsGetFile(RequestConfigurator req) {
        return adminAnalyticsGetFile(req.configure(AdminAnalyticsGetFileRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAppsApprove(AdminAppsApproveRequest req) {
        return executor.execute(ADMIN_APPS_APPROVE, toMap(req), () -> methods.adminAppsApprove(req));
    }

    @Override
    public CompletableFuture adminAppsApprove(RequestConfigurator req) {
        return adminAppsApprove(req.configure(AdminAppsApproveRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAppsRestrict(AdminAppsRestrictRequest req) {
        return executor.execute(ADMIN_APPS_RESTRICT, toMap(req), () -> methods.adminAppsRestrict(req));
    }

    @Override
    public CompletableFuture adminAppsRestrict(RequestConfigurator req) {
        return adminAppsRestrict(req.configure(AdminAppsRestrictRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAppsApprovedList(AdminAppsApprovedListRequest req) {
        return executor.execute(ADMIN_APPS_APPROVED_LIST, toMap(req), () -> methods.adminAppsApprovedList(req));
    }

    @Override
    public CompletableFuture adminAppsApprovedList(RequestConfigurator req) {
        return adminAppsApprovedList(req.configure(AdminAppsApprovedListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAppsRestrictedList(AdminAppsRestrictedListRequest req) {
        return executor.execute(ADMIN_APPS_RESTRICTED_LIST, toMap(req), () -> methods.adminAppsRestrictedList(req));
    }

    @Override
    public CompletableFuture adminAppsRestrictedList(RequestConfigurator req) {
        return adminAppsRestrictedList(req.configure(AdminAppsRestrictedListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAppsClearResolution(AdminAppsClearResolutionRequest req) {
        return executor.execute(ADMIN_APPS_CLEAR_RESOLUTION, toMap(req), () -> methods.adminAppsClearResolution(req));
    }

    @Override
    public CompletableFuture adminAppsClearResolution(RequestConfigurator req) {
        return adminAppsClearResolution(req.configure(AdminAppsClearResolutionRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAppsUninstall(AdminAppsUninstallRequest req) {
        return executor.execute(ADMIN_APPS_UNINSTALL, toMap(req), () -> methods.adminAppsUninstall(req));
    }

    @Override
    public CompletableFuture adminAppsUninstall(RequestConfigurator req) {
        return adminAppsUninstall(req.configure(AdminAppsUninstallRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAppsRequestsCancel(AdminAppsRequestsCancelRequest req) {
        return executor.execute(ADMIN_APPS_REQUESTS_CANCEL, toMap(req), () -> methods.adminAppsRequestsCancel(req));
    }

    @Override
    public CompletableFuture adminAppsRequestsCancel(RequestConfigurator req) {
        return adminAppsRequestsCancel(req.configure(AdminAppsRequestsCancelRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAppsRequestsList(AdminAppsRequestsListRequest req) {
        return executor.execute(ADMIN_APPS_REQUESTS_LIST, toMap(req), () -> methods.adminAppsRequestsList(req));
    }

    @Override
    public CompletableFuture adminAppsRequestsList(RequestConfigurator req) {
        return adminAppsRequestsList(req.configure(AdminAppsRequestsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAuthPolicyAssignEntities(AdminAuthPolicyAssignEntitiesRequest req) {
        return executor.execute(ADMIN_AUTH_POLICY_ASSIGN_ENTITIES, toMap(req), () -> methods.adminAuthPolicyAssignEntities(req));
    }

    @Override
    public CompletableFuture adminAuthPolicyAssignEntities(RequestConfigurator req) {
        return adminAuthPolicyAssignEntities(req.configure(AdminAuthPolicyAssignEntitiesRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAuthPolicyGetEntities(AdminAuthPolicyGetEntitiesRequest req) {
        return executor.execute(ADMIN_AUTH_POLICY_GET_ENTITIES, toMap(req), () -> methods.adminAuthPolicyGetEntities(req));
    }

    @Override
    public CompletableFuture adminAuthPolicyGetEntities(RequestConfigurator req) {
        return adminAuthPolicyGetEntities(req.configure(AdminAuthPolicyGetEntitiesRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminAuthPolicyRemoveEntities(AdminAuthPolicyRemoveEntitiesRequest req) {
        return executor.execute(ADMIN_AUTH_POLICY_REMOVE_ENTITIES, toMap(req), () -> methods.adminAuthPolicyRemoveEntities(req));
    }

    @Override
    public CompletableFuture adminAuthPolicyRemoveEntities(RequestConfigurator req) {
        return adminAuthPolicyRemoveEntities(req.configure(AdminAuthPolicyRemoveEntitiesRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminBarriersCreate(AdminBarriersCreateRequest req) {
        return executor.execute(ADMIN_BARRIERS_CREATE, toMap(req), () -> methods.adminBarriersCreate(req));
    }

    @Override
    public CompletableFuture adminBarriersCreate(RequestConfigurator req) {
        return adminBarriersCreate(req.configure(AdminBarriersCreateRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminBarriersDelete(AdminBarriersDeleteRequest req) {
        return executor.execute(ADMIN_BARRIERS_DELETE, toMap(req), () -> methods.adminBarriersDelete(req));
    }

    @Override
    public CompletableFuture adminBarriersDelete(RequestConfigurator req) {
        return adminBarriersDelete(req.configure(AdminBarriersDeleteRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminBarriersList(AdminBarriersListRequest req) {
        return executor.execute(ADMIN_BARRIERS_LIST, toMap(req), () -> methods.adminBarriersList(req));
    }

    @Override
    public CompletableFuture adminBarriersList(RequestConfigurator req) {
        return adminBarriersList(req.configure(AdminBarriersListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminBarriersUpdate(AdminBarriersUpdateRequest req) {
        return executor.execute(ADMIN_BARRIERS_UPDATE, toMap(req), () -> methods.adminBarriersUpdate(req));
    }

    @Override
    public CompletableFuture adminBarriersUpdate(RequestConfigurator req) {
        return adminBarriersUpdate(req.configure(AdminBarriersUpdateRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsRestrictAccessAddGroup(AdminConversationsRestrictAccessAddGroupRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_RESTRICT_ACCESS_ADD_GROUP, toMap(req), () -> methods.adminConversationsRestrictAccessAddGroup(req));
    }

    @Override
    public CompletableFuture adminConversationsRestrictAccessAddGroup(RequestConfigurator req) {
        return adminConversationsRestrictAccessAddGroup(req.configure(AdminConversationsRestrictAccessAddGroupRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsRestrictAccessRemoveGroup(AdminConversationsRestrictAccessRemoveGroupRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_RESTRICT_ACCESS_REMOVE_GROUP, toMap(req), () -> methods.adminConversationsRestrictAccessRemoveGroup(req));
    }

    @Override
    public CompletableFuture adminConversationsRestrictAccessRemoveGroup(RequestConfigurator req) {
        return adminConversationsRestrictAccessRemoveGroup(req.configure(AdminConversationsRestrictAccessRemoveGroupRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsRestrictAccessListGroups(AdminConversationsRestrictAccessListGroupsRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_RESTRICT_ACCESS_LIST_GROUPS, toMap(req), () -> methods.adminConversationsRestrictAccessListGroups(req));
    }

    @Override
    public CompletableFuture adminConversationsRestrictAccessListGroups(RequestConfigurator req) {
        return adminConversationsRestrictAccessListGroups(req.configure(AdminConversationsRestrictAccessListGroupsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsSetTeams(AdminConversationsSetTeamsRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_SET_TEAMS, toMap(req), () -> methods.adminConversationsSetTeams(req));
    }

    @Override
    public CompletableFuture adminConversationsSetTeams(RequestConfigurator req) {
        return adminConversationsSetTeams(req.configure(AdminConversationsSetTeamsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsArchive(AdminConversationsArchiveRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_ARCHIVE, toMap(req), () -> methods.adminConversationsArchive(req));
    }

    @Override
    public CompletableFuture adminConversationsArchive(RequestConfigurator req) {
        return adminConversationsArchive(req.configure(AdminConversationsArchiveRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsConvertToPrivate(AdminConversationsConvertToPrivateRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_CONVERT_TO_PRIVATE, toMap(req), () -> methods.adminConversationsConvertToPrivate(req));
    }

    @Override
    public CompletableFuture adminConversationsConvertToPrivate(RequestConfigurator req) {
        return adminConversationsConvertToPrivate(req.configure(AdminConversationsConvertToPrivateRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsCreate(AdminConversationsCreateRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_CREATE, toMap(req), () -> methods.adminConversationsCreate(req));
    }

    @Override
    public CompletableFuture adminConversationsCreate(RequestConfigurator req) {
        return adminConversationsCreate(req.configure(AdminConversationsCreateRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsDelete(AdminConversationsDeleteRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_DELETE, toMap(req), () -> methods.adminConversationsDelete(req));
    }

    @Override
    public CompletableFuture adminConversationsDelete(RequestConfigurator req) {
        return adminConversationsDelete(req.configure(AdminConversationsDeleteRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsDisconnectShared(AdminConversationsDisconnectSharedRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_DISCONNECT_SHARED, toMap(req), () -> methods.adminConversationsDisconnectShared(req));
    }

    @Override
    public CompletableFuture adminConversationsDisconnectShared(RequestConfigurator req) {
        return adminConversationsDisconnectShared(req.configure(AdminConversationsDisconnectSharedRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsGetConversationPrefs(AdminConversationsGetConversationPrefsRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_GET_CONVERSATION_PREFS, toMap(req), () -> methods.adminConversationsGetConversationPrefs(req));
    }

    @Override
    public CompletableFuture adminConversationsGetConversationPrefs(RequestConfigurator req) {
        return adminConversationsGetConversationPrefs(req.configure(AdminConversationsGetConversationPrefsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsGetTeams(AdminConversationsGetTeamsRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_GET_TEAMS, toMap(req), () -> methods.adminConversationsGetTeams(req));
    }

    @Override
    public CompletableFuture adminConversationsGetTeams(RequestConfigurator req) {
        return adminConversationsGetTeams(req.configure(AdminConversationsGetTeamsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsInvite(AdminConversationsInviteRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_INVITE, toMap(req), () -> methods.adminConversationsInvite(req));
    }

    @Override
    public CompletableFuture adminConversationsInvite(RequestConfigurator req) {
        return adminConversationsInvite(req.configure(AdminConversationsInviteRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsRename(AdminConversationsRenameRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_RENAME, toMap(req), () -> methods.adminConversationsRename(req));
    }

    @Override
    public CompletableFuture adminConversationsRename(RequestConfigurator req) {
        return adminConversationsRename(req.configure(AdminConversationsRenameRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsSearch(AdminConversationsSearchRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_SEARCH, toMap(req), () -> methods.adminConversationsSearch(req));
    }

    @Override
    public CompletableFuture adminConversationsSearch(RequestConfigurator req) {
        return adminConversationsSearch(req.configure(AdminConversationsSearchRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsSetConversationPrefs(AdminConversationsSetConversationPrefsRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_SET_CONVERSATION_PREFS, toMap(req), () -> methods.adminConversationsSetConversationPrefs(req));
    }

    @Override
    public CompletableFuture adminConversationsSetConversationPrefs(RequestConfigurator req) {
        return adminConversationsSetConversationPrefs(req.configure(AdminConversationsSetConversationPrefsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsUnarchive(AdminConversationsUnarchiveRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_UNARCHIVE, toMap(req), () -> methods.adminConversationsUnarchive(req));
    }

    @Override
    public CompletableFuture adminConversationsUnarchive(RequestConfigurator req) {
        return adminConversationsUnarchive(req.configure(AdminConversationsUnarchiveRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsGetCustomRetention(RequestConfigurator req) {
        return adminConversationsGetCustomRetention(req.configure(AdminConversationsGetCustomRetentionRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsGetCustomRetention(AdminConversationsGetCustomRetentionRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_GET_CUSTOM_RETENTION, toMap(req), () -> methods.adminConversationsGetCustomRetention(req));
    }

    @Override
    public CompletableFuture adminConversationsRemoveCustomRetention(AdminConversationsRemoveCustomRetentionRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_REMOVE_CUSTOM_RETENTION, toMap(req), () -> methods.adminConversationsRemoveCustomRetention(req));
    }

    @Override
    public CompletableFuture adminConversationsRemoveCustomRetention(RequestConfigurator req) {
        return adminConversationsRemoveCustomRetention(req.configure(AdminConversationsRemoveCustomRetentionRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsSetCustomRetention(AdminConversationsSetCustomRetentionRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_SET_CUSTOM_RETENTION, toMap(req), () -> methods.adminConversationsSetCustomRetention(req));
    }

    @Override
    public CompletableFuture adminConversationsSetCustomRetention(RequestConfigurator req) {
        return adminConversationsSetCustomRetention(req.configure(AdminConversationsSetCustomRetentionRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsBulkArchive(AdminConversationsBulkArchiveRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_BULK_ARCHIVE, toMap(req), () -> methods.adminConversationsBulkArchive(req));
    }

    @Override
    public CompletableFuture adminConversationsBulkArchive(RequestConfigurator req) {
        return adminConversationsBulkArchive(req.configure(AdminConversationsBulkArchiveRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsBulkDelete(AdminConversationsBulkDeleteRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_BULK_DELETE, toMap(req), () -> methods.adminConversationsBulkDelete(req));
    }

    @Override
    public CompletableFuture adminConversationsBulkDelete(RequestConfigurator req) {
        return adminConversationsBulkDelete(req.configure(AdminConversationsBulkDeleteRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsBulkMove(AdminConversationsBulkMoveRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_BULK_MOVE, toMap(req), () -> methods.adminConversationsBulkMove(req));
    }

    @Override
    public CompletableFuture adminConversationsBulkMove(RequestConfigurator req) {
        return adminConversationsBulkMove(req.configure(AdminConversationsBulkMoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsEkmListOriginalConnectedChannelInfo(AdminConversationsEkmListOriginalConnectedChannelInfoRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_EKM_LIST_ORIGINAL_CONNECTED_CHANNEL_INFO, toMap(req), () -> methods.adminConversationsEkmListOriginalConnectedChannelInfo(req));
    }

    @Override
    public CompletableFuture adminConversationsEkmListOriginalConnectedChannelInfo(RequestConfigurator req) {
        return adminConversationsEkmListOriginalConnectedChannelInfo(req.configure(AdminConversationsEkmListOriginalConnectedChannelInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsWhitelistAdd(AdminConversationsWhitelistAddRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_WHITELIST_ADD, toMap(req), () -> methods.adminConversationsWhitelistAdd(req));
    }

    @Override
    public CompletableFuture adminConversationsWhitelistAdd(RequestConfigurator req) {
        return adminConversationsWhitelistAdd(req.configure(AdminConversationsWhitelistAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsWhitelistRemove(AdminConversationsWhitelistRemoveRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_WHITELIST_REMOVE, toMap(req), () -> methods.adminConversationsWhitelistRemove(req));
    }

    @Override
    public CompletableFuture adminConversationsWhitelistRemove(RequestConfigurator req) {
        return adminConversationsWhitelistRemove(req.configure(AdminConversationsWhitelistRemoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminConversationsWhitelistListGroupsLinkedToChannel(AdminConversationsWhitelistListGroupsLinkedToChannelRequest req) {
        return executor.execute(ADMIN_CONVERSATIONS_WHITELIST_LIST_GROUPS_LINKED_TO_CHANNEL, toMap(req), () -> methods.adminConversationsWhitelistListGroupsLinkedToChannel(req));
    }

    @Override
    public CompletableFuture adminConversationsWhitelistListGroupsLinkedToChannel(RequestConfigurator req) {
        return adminConversationsWhitelistListGroupsLinkedToChannel(req.configure(AdminConversationsWhitelistListGroupsLinkedToChannelRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminEmojiAdd(AdminEmojiAddRequest req) {
        return executor.execute(ADMIN_EMOJI_ADD, toMap(req), () -> methods.adminEmojiAdd(req));
    }

    @Override
    public CompletableFuture adminEmojiAdd(RequestConfigurator req) {
        return adminEmojiAdd(req.configure(AdminEmojiAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminEmojiAddAlias(AdminEmojiAddAliasRequest req) {
        return executor.execute(ADMIN_EMOJI_ADD_ALIAS, toMap(req), () -> methods.adminEmojiAddAlias(req));
    }

    @Override
    public CompletableFuture adminEmojiAddAlias(RequestConfigurator req) {
        return adminEmojiAddAlias(req.configure(AdminEmojiAddAliasRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminEmojiList(AdminEmojiListRequest req) {
        return executor.execute(ADMIN_EMOJI_LIST, toMap(req), () -> methods.adminEmojiList(req));
    }

    @Override
    public CompletableFuture adminEmojiList(RequestConfigurator req) {
        return adminEmojiList(req.configure(AdminEmojiListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminEmojiRemove(AdminEmojiRemoveRequest req) {
        return executor.execute(ADMIN_EMOJI_REMOVE, toMap(req), () -> methods.adminEmojiRemove(req));
    }

    @Override
    public CompletableFuture adminEmojiRemove(RequestConfigurator req) {
        return adminEmojiRemove(req.configure(AdminEmojiRemoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminEmojiRename(AdminEmojiRenameRequest req) {
        return executor.execute(ADMIN_EMOJI_RENAME, toMap(req), () -> methods.adminEmojiRename(req));
    }

    @Override
    public CompletableFuture adminEmojiRename(RequestConfigurator req) {
        return adminEmojiRename(req.configure(AdminEmojiRenameRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminInviteRequestsApprove(AdminInviteRequestsApproveRequest req) {
        return executor.execute(ADMIN_INVITE_REQUESTS_APPROVE, toMap(req), () -> methods.adminInviteRequestsApprove(req));
    }

    @Override
    public CompletableFuture adminInviteRequestsApprove(RequestConfigurator req) {
        return adminInviteRequestsApprove(req.configure(AdminInviteRequestsApproveRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminInviteRequestsDeny(AdminInviteRequestsDenyRequest req) {
        return executor.execute(ADMIN_INVITE_REQUESTS_DENY, toMap(req), () -> methods.adminInviteRequestsDeny(req));
    }

    @Override
    public CompletableFuture adminInviteRequestsDeny(RequestConfigurator req) {
        return adminInviteRequestsDeny(req.configure(AdminInviteRequestsDenyRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminInviteRequestsList(AdminInviteRequestsListRequest req) {
        return executor.execute(ADMIN_INVITE_REQUESTS_LIST, toMap(req), () -> methods.adminInviteRequestsList(req));
    }

    @Override
    public CompletableFuture adminInviteRequestsList(RequestConfigurator req) {
        return adminInviteRequestsList(req.configure(AdminInviteRequestsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminInviteRequestsApprovedList(AdminInviteRequestsApprovedListRequest req) {
        return executor.execute(ADMIN_INVITE_REQUESTS_APPROVED_LIST, toMap(req), () -> methods.adminInviteRequestsApprovedList(req));
    }

    @Override
    public CompletableFuture adminInviteRequestsApprovedList(RequestConfigurator req) {
        return adminInviteRequestsApprovedList(req.configure(AdminInviteRequestsApprovedListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminInviteRequestsDeniedList(AdminInviteRequestsDeniedListRequest req) {
        return executor.execute(ADMIN_INVITE_REQUESTS_DENIED_LIST, toMap(req), () -> methods.adminInviteRequestsDeniedList(req));
    }

    @Override
    public CompletableFuture adminInviteRequestsDeniedList(RequestConfigurator req) {
        return adminInviteRequestsDeniedList(req.configure(AdminInviteRequestsDeniedListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminRolesListAssignments(AdminRolesListAssignmentsRequest req) {
        return executor.execute(ADMIN_ROLES_LIST_ASSIGNMENTS, toMap(req), () -> methods.adminRolesListAssignments(req));
    }

    @Override
    public CompletableFuture adminRolesListAssignments(RequestConfigurator req) {
        return adminRolesListAssignments(req.configure(AdminRolesListAssignmentsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminRolesAddAssignments(AdminRolesAddAssignmentsRequest req) {
        return executor.execute(ADMIN_ROLES_ADD_ASSIGNMENTS, toMap(req), () -> methods.adminRolesAddAssignments(req));
    }

    @Override
    public CompletableFuture adminRolesAddAssignments(RequestConfigurator req) {
        return adminRolesAddAssignments(req.configure(AdminRolesAddAssignmentsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminRolesRemoveAssignments(AdminRolesRemoveAssignmentsRequest req) {
        return executor.execute(ADMIN_ROLES_REMOVE_ASSIGNMENTS, toMap(req), () -> methods.adminRolesRemoveAssignments(req));
    }

    @Override
    public CompletableFuture adminRolesRemoveAssignments(RequestConfigurator req) {
        return adminRolesRemoveAssignments(req.configure(AdminRolesRemoveAssignmentsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsAdminsList(AdminTeamsAdminsListRequest req) {
        return executor.execute(ADMIN_TEAMS_ADMINS_LIST, toMap(req), () -> methods.adminTeamsAdminsList(req));
    }

    @Override
    public CompletableFuture adminTeamsAdminsList(RequestConfigurator req) {
        return adminTeamsAdminsList(req.configure(AdminTeamsAdminsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsCreate(AdminTeamsCreateRequest req) {
        return executor.execute(ADMIN_TEAMS_CREATE, toMap(req), () -> methods.adminTeamsCreate(req));
    }

    @Override
    public CompletableFuture adminTeamsCreate(RequestConfigurator req) {
        return adminTeamsCreate(req.configure(AdminTeamsCreateRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsList(AdminTeamsListRequest req) {
        return executor.execute(ADMIN_TEAMS_LIST, toMap(req), () -> methods.adminTeamsList(req));
    }

    @Override
    public CompletableFuture adminTeamsList(RequestConfigurator req) {
        return adminTeamsList(req.configure(AdminTeamsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsOwnersList(AdminTeamsOwnersListRequest req) {
        return executor.execute(ADMIN_TEAMS_OWNERS_LIST, toMap(req), () -> methods.adminTeamsOwnersList(req));
    }

    @Override
    public CompletableFuture adminTeamsOwnersList(RequestConfigurator req) {
        return adminTeamsOwnersList(req.configure(AdminTeamsOwnersListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsSettingsInfo(AdminTeamsSettingsInfoRequest req) {
        return executor.execute(ADMIN_TEAMS_SETTINGS_INFO, toMap(req), () -> methods.adminTeamsSettingsInfo(req));
    }

    @Override
    public CompletableFuture adminTeamsSettingsInfo(RequestConfigurator req) {
        return adminTeamsSettingsInfo(req.configure(AdminTeamsSettingsInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetDefaultChannels(AdminTeamsSettingsSetDefaultChannelsRequest req) {
        return executor.execute(ADMIN_TEAMS_SETTINGS_SET_DEFAULT_CHANNELS, toMap(req), () -> methods.adminTeamsSettingsSetDefaultChannels(req));
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetDefaultChannels(RequestConfigurator req) {
        return adminTeamsSettingsSetDefaultChannels(req.configure(AdminTeamsSettingsSetDefaultChannelsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetDescription(AdminTeamsSettingsSetDescriptionRequest req) {
        return executor.execute(ADMIN_TEAMS_SETTINGS_SET_DESCRIPTION, toMap(req), () -> methods.adminTeamsSettingsSetDescription(req));
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetDescription(RequestConfigurator req) {
        return adminTeamsSettingsSetDescription(req.configure(AdminTeamsSettingsSetDescriptionRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetDiscoverability(AdminTeamsSettingsSetDiscoverabilityRequest req) {
        return executor.execute(ADMIN_TEAMS_SETTINGS_SET_DISCOVERABILITY, toMap(req), () -> methods.adminTeamsSettingsSetDiscoverability(req));
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetDiscoverability(RequestConfigurator req) {
        return adminTeamsSettingsSetDiscoverability(req.configure(AdminTeamsSettingsSetDiscoverabilityRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetIcon(AdminTeamsSettingsSetIconRequest req) {
        return executor.execute(ADMIN_TEAMS_SETTINGS_SET_ICON, toMap(req), () -> methods.adminTeamsSettingsSetIcon(req));
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetIcon(RequestConfigurator req) {
        return adminTeamsSettingsSetIcon(req.configure(AdminTeamsSettingsSetIconRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetName(AdminTeamsSettingsSetNameRequest req) {
        return executor.execute(ADMIN_TEAMS_SETTINGS_SET_NAME, toMap(req), () -> methods.adminTeamsSettingsSetName(req));
    }

    @Override
    public CompletableFuture adminTeamsSettingsSetName(RequestConfigurator req) {
        return adminTeamsSettingsSetName(req.configure(AdminTeamsSettingsSetNameRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsergroupsAddChannels(AdminUsergroupsAddChannelsRequest req) {
        return executor.execute(ADMIN_USERGROUPS_ADD_CHANNELS, toMap(req), () -> methods.adminUsergroupsAddChannels(req));
    }

    @Override
    public CompletableFuture adminUsergroupsAddChannels(RequestConfigurator req) {
        return adminUsergroupsAddChannels(req.configure(AdminUsergroupsAddChannelsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsergroupsAddTeams(AdminUsergroupsAddTeamsRequest req) {
        return executor.execute(ADMIN_USERGROUPS_ADD_TEAMS, toMap(req), () -> methods.adminUsergroupsAddTeams(req));
    }

    @Override
    public CompletableFuture adminUsergroupsAddTeams(RequestConfigurator req) {
        return adminUsergroupsAddTeams(req.configure(AdminUsergroupsAddTeamsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsergroupsListChannels(AdminUsergroupsListChannelsRequest req) {
        return executor.execute(ADMIN_USERGROUPS_LIST_CHANNELS, toMap(req), () -> methods.adminUsergroupsListChannels(req));
    }

    @Override
    public CompletableFuture adminUsergroupsListChannels(RequestConfigurator req) {
        return adminUsergroupsListChannels(req.configure(AdminUsergroupsListChannelsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsergroupsRemoveChannels(AdminUsergroupsRemoveChannelsRequest req) {
        return executor.execute(ADMIN_USERGROUPS_REMOVE_CHANNELS, toMap(req), () -> methods.adminUsergroupsRemoveChannels(req));
    }

    @Override
    public CompletableFuture adminUsergroupsRemoveChannels(RequestConfigurator req) {
        return adminUsergroupsRemoveChannels(req.configure(AdminUsergroupsRemoveChannelsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersAssign(AdminUsersAssignRequest req) {
        return executor.execute(ADMIN_USERS_ASSIGN, toMap(req), () -> methods.adminUsersAssign(req));
    }

    @Override
    public CompletableFuture adminUsersAssign(RequestConfigurator req) {
        return adminUsersAssign(req.configure(AdminUsersAssignRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersInvite(AdminUsersInviteRequest req) {
        return executor.execute(ADMIN_USERS_INVITE, toMap(req), () -> methods.adminUsersInvite(req));
    }

    @Override
    public CompletableFuture adminUsersInvite(RequestConfigurator req) {
        return adminUsersInvite(req.configure(AdminUsersInviteRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersList(AdminUsersListRequest req) {
        return executor.execute(ADMIN_USERS_LIST, toMap(req), () -> methods.adminUsersList(req));
    }

    @Override
    public CompletableFuture adminUsersList(RequestConfigurator req) {
        return adminUsersList(req.configure(AdminUsersListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersRemove(AdminUsersRemoveRequest req) {
        return executor.execute(ADMIN_USERS_REMOVE, toMap(req), () -> methods.adminUsersRemove(req));
    }

    @Override
    public CompletableFuture adminUsersRemove(RequestConfigurator req) {
        return adminUsersRemove(req.configure(AdminUsersRemoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSetAdmin(AdminUsersSetAdminRequest req) {
        return executor.execute(ADMIN_USERS_SET_ADMIN, toMap(req), () -> methods.adminUsersSetAdmin(req));
    }

    @Override
    public CompletableFuture adminUsersSetAdmin(RequestConfigurator req) {
        return adminUsersSetAdmin(req.configure(AdminUsersSetAdminRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSetExpiration(AdminUsersSetExpirationRequest req) {
        return executor.execute(ADMIN_USERS_SET_EXPIRATION, toMap(req), () -> methods.adminUsersSetExpiration(req));
    }

    @Override
    public CompletableFuture adminUsersSetExpiration(RequestConfigurator req) {
        return adminUsersSetExpiration(req.configure(AdminUsersSetExpirationRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSetOwner(AdminUsersSetOwnerRequest req) {
        return executor.execute(ADMIN_USERS_SET_OWNER, toMap(req), () -> methods.adminUsersSetOwner(req));
    }

    @Override
    public CompletableFuture adminUsersSetOwner(RequestConfigurator req) {
        return adminUsersSetOwner(req.configure(AdminUsersSetOwnerRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSetRegular(AdminUsersSetRegularRequest req) {
        return executor.execute(ADMIN_USERS_SET_REGULAR, toMap(req), () -> methods.adminUsersSetRegular(req));
    }

    @Override
    public CompletableFuture adminUsersSetRegular(RequestConfigurator req) {
        return adminUsersSetRegular(req.configure(AdminUsersSetRegularRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSessionInvalidate(AdminUsersSessionInvalidateRequest req) {
        return executor.execute(ADMIN_USERS_SESSION_INVALIDATE, toMap(req), () -> methods.adminUsersSessionInvalidate(req));
    }

    @Override
    public CompletableFuture adminUsersSessionInvalidate(RequestConfigurator req) {
        return adminUsersSessionInvalidate(req.configure(AdminUsersSessionInvalidateRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSessionList(AdminUsersSessionListRequest req) {
        return executor.execute(ADMIN_USERS_SESSION_LIST, toMap(req), () -> methods.adminUsersSessionList(req));
    }

    @Override
    public CompletableFuture adminUsersSessionList(RequestConfigurator req) {
        return adminUsersSessionList(req.configure(AdminUsersSessionListRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSessionReset(AdminUsersSessionResetRequest req) {
        return executor.execute(ADMIN_USERS_SESSION_RESET, toMap(req), () -> methods.adminUsersSessionReset(req));
    }

    @Override
    public CompletableFuture adminUsersSessionReset(RequestConfigurator req) {
        return adminUsersSessionReset(req.configure(AdminUsersSessionResetRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSessionResetBulk(AdminUsersSessionResetBulkRequest req) {
        return executor.execute(ADMIN_USERS_SESSION_RESET_BULK, toMap(req), () -> methods.adminUsersSessionResetBulk(req));
    }

    @Override
    public CompletableFuture adminUsersSessionResetBulk(RequestConfigurator req) {
        return adminUsersSessionResetBulk(req.configure(AdminUsersSessionResetBulkRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSessionGetSettings(AdminUsersSessionGetSettingsRequest req) {
        return executor.execute(ADMIN_USERS_SESSION_GET_SETTINGS, toMap(req), () -> methods.adminUsersSessionGetSettings(req));
    }

    @Override
    public CompletableFuture adminUsersSessionGetSettings(RequestConfigurator req) {
        return adminUsersSessionGetSettings(req.configure(AdminUsersSessionGetSettingsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSessionSetSettings(AdminUsersSessionSetSettingsRequest req) {
        return executor.execute(ADMIN_USERS_SESSION_SET_SETTINGS, toMap(req), () -> methods.adminUsersSessionSetSettings(req));
    }

    @Override
    public CompletableFuture adminUsersSessionSetSettings(RequestConfigurator req) {
        return adminUsersSessionSetSettings(req.configure(AdminUsersSessionSetSettingsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersSessionClearSettings(AdminUsersSessionClearSettingsRequest req) {
        return executor.execute(ADMIN_USERS_SESSION_CLEAR_SETTINGS, toMap(req), () -> methods.adminUsersSessionClearSettings(req));
    }

    @Override
    public CompletableFuture adminUsersSessionClearSettings(RequestConfigurator req) {
        return adminUsersSessionClearSettings(req.configure(AdminUsersSessionClearSettingsRequest.builder()).build());
    }

    @Override
    public CompletableFuture adminUsersUnsupportedVersionsExport(AdminUsersUnsupportedVersionsExportRequest req) {
        return executor.execute(ADMIN_USERS_UNSUPPORTED_VERSIONS_EXPORT, toMap(req), () -> methods.adminUsersUnsupportedVersionsExport(req));
    }

    @Override
    public CompletableFuture adminUsersUnsupportedVersionsExport(RequestConfigurator req) {
        return adminUsersUnsupportedVersionsExport(req.configure(AdminUsersUnsupportedVersionsExportRequest.builder()).build());
    }

    @Override
    public CompletableFuture apiTest(ApiTestRequest req) {
        return executor.execute(API_TEST, toMap(req), () -> methods.apiTest(req));
    }

    @Override
    public CompletableFuture apiTest(RequestConfigurator req) {
        return apiTest(req.configure(ApiTestRequest.builder()).build());
    }

    @Override
    public CompletableFuture appsUninstall(AppsUninstallRequest req) {
        return executor.execute(APPS_UNINSTALL, toMap(req), () -> methods.appsUninstall(req));
    }

    @Override
    public CompletableFuture appsUninstall(RequestConfigurator req) {
        return appsUninstall(req.configure(AppsUninstallRequest.builder()).build());
    }

    @Override
    public CompletableFuture appsConnectionsOpen(AppsConnectionsOpenRequest req) {
        return executor.execute(APPS_CONNECTIONS_OPEN, toMap(req), () -> methods.appsConnectionsOpen(req));
    }

    @Override
    public CompletableFuture appsConnectionsOpen(RequestConfigurator req) {
        return appsConnectionsOpen(req.configure(AppsConnectionsOpenRequest.builder()).build());
    }

    @Override
    public CompletableFuture appsEventAuthorizationsList(AppsEventAuthorizationsListRequest req) {
        return executor.execute(APPS_EVENT_AUTHORIZATIONS_LIST, toMap(req), () -> methods.appsEventAuthorizationsList(req));
    }

    @Override
    public CompletableFuture appsEventAuthorizationsList(RequestConfigurator req) {
        return appsEventAuthorizationsList(req.configure(AppsEventAuthorizationsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture authRevoke(AuthRevokeRequest req) {
        return executor.execute(AUTH_REVOKE, toMap(req), () -> methods.authRevoke(req));
    }

    @Override
    public CompletableFuture authRevoke(RequestConfigurator req) {
        return authRevoke(req.configure(AuthRevokeRequest.builder()).build());
    }

    @Override
    public CompletableFuture authTest(AuthTestRequest req) {
        return executor.execute(AUTH_TEST, toMap(req), () -> methods.authTest(req));
    }

    @Override
    public CompletableFuture authTest(RequestConfigurator req) {
        return authTest(req.configure(AuthTestRequest.builder()).build());
    }

    @Override
    public CompletableFuture authTeamsList(AuthTeamsListRequest req) {
        return executor.execute(AUTH_TEAMS_LIST, toMap(req), () -> methods.authTeamsList(req));
    }

    @Override
    public CompletableFuture authTeamsList(RequestConfigurator req) {
        return authTeamsList(req.configure(AuthTeamsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture bookmarksAdd(BookmarksAddRequest req) {
        return executor.execute(BOOKMARKS_ADD, toMap(req), () -> methods.bookmarksAdd(req));
    }

    @Override
    public CompletableFuture bookmarksAdd(RequestConfigurator req) {
        return bookmarksAdd(req.configure(BookmarksAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture bookmarksEdit(BookmarksEditRequest req) {
        return executor.execute(BOOKMARKS_EDIT, toMap(req), () -> methods.bookmarksEdit(req));
    }

    @Override
    public CompletableFuture bookmarksEdit(RequestConfigurator req) {
        return bookmarksEdit(req.configure(BookmarksEditRequest.builder()).build());
    }

    @Override
    public CompletableFuture bookmarksList(BookmarksListRequest req) {
        return executor.execute(BOOKMARKS_LIST, toMap(req), () -> methods.bookmarksList(req));
    }

    @Override
    public CompletableFuture bookmarksList(RequestConfigurator req) {
        return bookmarksList(req.configure(BookmarksListRequest.builder()).build());
    }

    @Override
    public CompletableFuture bookmarksRemove(BookmarksRemoveRequest req) {
        return executor.execute(BOOKMARKS_REMOVE, toMap(req), () -> methods.bookmarksRemove(req));
    }

    @Override
    public CompletableFuture bookmarksRemove(RequestConfigurator req) {
        return bookmarksRemove(req.configure(BookmarksRemoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture botsInfo(BotsInfoRequest req) {
        return executor.execute(BOTS_INFO, toMap(req), () -> methods.botsInfo(req));
    }

    @Override
    public CompletableFuture botsInfo(RequestConfigurator req) {
        return botsInfo(req.configure(BotsInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture callsAdd(CallsAddRequest req) {
        return executor.execute(CALLS_ADD, toMap(req), () -> methods.callsAdd(req));
    }

    @Override
    public CompletableFuture callsAdd(RequestConfigurator req) {
        return callsAdd(req.configure(CallsAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture callsEnd(CallsEndRequest req) {
        return executor.execute(CALLS_END, toMap(req), () -> methods.callsEnd(req));
    }

    @Override
    public CompletableFuture callsEnd(RequestConfigurator req) {
        return callsEnd(req.configure(CallsEndRequest.builder()).build());
    }

    @Override
    public CompletableFuture callsInfo(CallsInfoRequest req) {
        return executor.execute(CALLS_INFO, toMap(req), () -> methods.callsInfo(req));
    }

    @Override
    public CompletableFuture callsInfo(RequestConfigurator req) {
        return callsInfo(req.configure(CallsInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture callsUpdate(CallsUpdateRequest req) {
        return executor.execute(CALLS_UPDATE, toMap(req), () -> methods.callsUpdate(req));
    }

    @Override
    public CompletableFuture callsUpdate(RequestConfigurator req) {
        return callsUpdate(req.configure(CallsUpdateRequest.builder()).build());
    }

    @Override
    public CompletableFuture callsParticipantsAdd(CallsParticipantsAddRequest req) {
        return executor.execute(CALLS_PARTICIPANTS_ADD, toMap(req), () -> methods.callsParticipantsAdd(req));
    }

    @Override
    public CompletableFuture callsParticipantsAdd(RequestConfigurator req) {
        return callsParticipantsAdd(req.configure(CallsParticipantsAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture callsParticipantsRemove(CallsParticipantsRemoveRequest req) {
        return executor.execute(CALLS_PARTICIPANTS_REMOVE, toMap(req), () -> methods.callsParticipantsRemove(req));
    }

    @Override
    public CompletableFuture callsParticipantsRemove(RequestConfigurator req) {
        return callsParticipantsRemove(req.configure(CallsParticipantsRemoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatGetPermalink(ChatGetPermalinkRequest req) {
        return executor.execute(CHAT_GET_PERMALINK, toMap(req), () -> methods.chatGetPermalink(req));
    }

    @Override
    public CompletableFuture chatGetPermalink(RequestConfigurator req) {
        return chatGetPermalink(req.configure(ChatGetPermalinkRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatDelete(ChatDeleteRequest req) {
        return executor.execute(CHAT_DELETE, toMap(req), () -> methods.chatDelete(req));
    }

    @Override
    public CompletableFuture chatDelete(RequestConfigurator req) {
        return chatDelete(req.configure(ChatDeleteRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatDeleteScheduledMessage(ChatDeleteScheduledMessageRequest req) {
        return executor.execute(CHAT_DELETE_SCHEDULED_MESSAGE, toMap(req), () -> methods.chatDeleteScheduledMessage(req));
    }

    @Override
    public CompletableFuture chatDeleteScheduledMessage(RequestConfigurator req) {
        return chatDeleteScheduledMessage(req.configure(ChatDeleteScheduledMessageRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatMeMessage(ChatMeMessageRequest req) {
        return executor.execute(CHAT_ME_MESSAGE, toMap(req), () -> methods.chatMeMessage(req));
    }

    @Override
    public CompletableFuture chatMeMessage(RequestConfigurator req) {
        return chatMeMessage(req.configure(ChatMeMessageRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatPostEphemeral(ChatPostEphemeralRequest req) {
        return executor.execute(CHAT_POST_EPHEMERAL, toMap(req), () -> methods.chatPostEphemeral(req));
    }

    @Override
    public CompletableFuture chatPostEphemeral(RequestConfigurator req) {
        return chatPostEphemeral(req.configure(ChatPostEphemeralRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatPostMessage(ChatPostMessageRequest req) {
        Map params = new HashMap<>();
        params.put("token", token(req));
        params.put("channel", req.getChannel()); // for rate limiting
        return executor.execute(CHAT_POST_MESSAGE, params, () -> methods.chatPostMessage(req));
    }

    @Override
    public CompletableFuture chatPostMessage(RequestConfigurator req) {
        return chatPostMessage(req.configure(ChatPostMessageRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatScheduleMessage(ChatScheduleMessageRequest req) {
        return executor.execute(CHAT_SCHEDULE_MESSAGE, toMap(req), () -> methods.chatScheduleMessage(req));
    }

    @Override
    public CompletableFuture chatScheduleMessage(RequestConfigurator req) {
        return chatScheduleMessage(req.configure(ChatScheduleMessageRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatUpdate(ChatUpdateRequest req) {
        return executor.execute(CHAT_UPDATE, toMap(req), () -> methods.chatUpdate(req));
    }

    @Override
    public CompletableFuture chatUpdate(RequestConfigurator req) {
        return chatUpdate(req.configure(ChatUpdateRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatUnfurl(ChatUnfurlRequest req) {
        return executor.execute(CHAT_UNFURL, toMap(req), () -> methods.chatUnfurl(req));
    }

    @Override
    public CompletableFuture chatUnfurl(RequestConfigurator req) {
        return chatUnfurl(req.configure(ChatUnfurlRequest.builder()).build());
    }

    @Override
    public CompletableFuture chatScheduledMessagesList(ChatScheduledMessagesListRequest req) {
        return executor.execute(CHAT_SCHEDULED_MESSAGES_LIST, toMap(req), () -> methods.chatScheduledMessagesList(req));
    }

    @Override
    public CompletableFuture chatScheduledMessagesList(RequestConfigurator req) {
        return chatScheduledMessagesList(req.configure(ChatScheduledMessagesListRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsArchive(ConversationsArchiveRequest req) {
        return executor.execute(CONVERSATIONS_ARCHIVE, toMap(req), () -> methods.conversationsArchive(req));
    }

    @Override
    public CompletableFuture conversationsArchive(RequestConfigurator req) {
        return conversationsArchive(req.configure(ConversationsArchiveRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsClose(ConversationsCloseRequest req) {
        return executor.execute(CONVERSATIONS_CLOSE, toMap(req), () -> methods.conversationsClose(req));
    }

    @Override
    public CompletableFuture conversationsClose(RequestConfigurator req) {
        return conversationsClose(req.configure(ConversationsCloseRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsCreate(ConversationsCreateRequest req) {
        return executor.execute(CONVERSATIONS_CREATE, toMap(req), () -> methods.conversationsCreate(req));
    }

    @Override
    public CompletableFuture conversationsCreate(RequestConfigurator req) {
        return conversationsCreate(req.configure(ConversationsCreateRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsHistory(ConversationsHistoryRequest req) {
        return executor.execute(CONVERSATIONS_HISTORY, toMap(req), () -> methods.conversationsHistory(req));
    }

    @Override
    public CompletableFuture conversationsHistory(RequestConfigurator req) {
        return conversationsHistory(req.configure(ConversationsHistoryRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsInfo(ConversationsInfoRequest req) {
        return executor.execute(CONVERSATIONS_INFO, toMap(req), () -> methods.conversationsInfo(req));
    }

    @Override
    public CompletableFuture conversationsInfo(RequestConfigurator req) {
        return conversationsInfo(req.configure(ConversationsInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsInvite(ConversationsInviteRequest req) {
        return executor.execute(CONVERSATIONS_INVITE, toMap(req), () -> methods.conversationsInvite(req));
    }

    @Override
    public CompletableFuture conversationsInvite(RequestConfigurator req) {
        return conversationsInvite(req.configure(ConversationsInviteRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsJoin(ConversationsJoinRequest req) {
        return executor.execute(CONVERSATIONS_JOIN, toMap(req), () -> methods.conversationsJoin(req));
    }

    @Override
    public CompletableFuture conversationsJoin(RequestConfigurator req) {
        return conversationsJoin(req.configure(ConversationsJoinRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsKick(ConversationsKickRequest req) {
        return executor.execute(CONVERSATIONS_KICK, toMap(req), () -> methods.conversationsKick(req));
    }

    @Override
    public CompletableFuture conversationsKick(RequestConfigurator req) {
        return conversationsKick(req.configure(ConversationsKickRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsLeave(ConversationsLeaveRequest req) {
        return executor.execute(CONVERSATIONS_LEAVE, toMap(req), () -> methods.conversationsLeave(req));
    }

    @Override
    public CompletableFuture conversationsLeave(RequestConfigurator req) {
        return conversationsLeave(req.configure(ConversationsLeaveRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsList(ConversationsListRequest req) {
        return executor.execute(CONVERSATIONS_LIST, toMap(req), () -> methods.conversationsList(req));
    }

    @Override
    public CompletableFuture conversationsList(RequestConfigurator req) {
        return conversationsList(req.configure(ConversationsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsMark(ConversationsMarkRequest req) {
        return executor.execute(CONVERSATIONS_MARK, toMap(req), () -> methods.conversationsMark(req));
    }

    @Override
    public CompletableFuture conversationsMark(RequestConfigurator req) {
        return conversationsMark(req.configure(ConversationsMarkRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsMembers(ConversationsMembersRequest req) {
        return executor.execute(CONVERSATIONS_MEMBERS, toMap(req), () -> methods.conversationsMembers(req));
    }

    @Override
    public CompletableFuture conversationsMembers(RequestConfigurator req) {
        return conversationsMembers(req.configure(ConversationsMembersRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsOpen(ConversationsOpenRequest req) {
        return executor.execute(CONVERSATIONS_OPEN, toMap(req), () -> methods.conversationsOpen(req));
    }

    @Override
    public CompletableFuture conversationsOpen(RequestConfigurator req) {
        return conversationsOpen(req.configure(ConversationsOpenRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsRename(ConversationsRenameRequest req) {
        return executor.execute(CONVERSATIONS_RENAME, toMap(req), () -> methods.conversationsRename(req));
    }

    @Override
    public CompletableFuture conversationsRename(RequestConfigurator req) {
        return conversationsRename(req.configure(ConversationsRenameRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsReplies(ConversationsRepliesRequest req) {
        return executor.execute(CONVERSATIONS_REPLIES, toMap(req), () -> methods.conversationsReplies(req));
    }

    @Override
    public CompletableFuture conversationsReplies(RequestConfigurator req) {
        return conversationsReplies(req.configure(ConversationsRepliesRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsSetPurpose(ConversationsSetPurposeRequest req) {
        return executor.execute(CONVERSATIONS_SET_PURPOSE, toMap(req), () -> methods.conversationsSetPurpose(req));
    }

    @Override
    public CompletableFuture conversationsSetPurpose(RequestConfigurator req) {
        return conversationsSetPurpose(req.configure(ConversationsSetPurposeRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsSetTopic(ConversationsSetTopicRequest req) {
        return executor.execute(CONVERSATIONS_SET_TOPIC, toMap(req), () -> methods.conversationsSetTopic(req));
    }

    @Override
    public CompletableFuture conversationsSetTopic(RequestConfigurator req) {
        return conversationsSetTopic(req.configure(ConversationsSetTopicRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsUnarchive(ConversationsUnarchiveRequest req) {
        return executor.execute(CONVERSATIONS_UNARCHIVE, toMap(req), () -> methods.conversationsUnarchive(req));
    }

    @Override
    public CompletableFuture conversationsUnarchive(RequestConfigurator req) {
        return conversationsUnarchive(req.configure(ConversationsUnarchiveRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsInviteShared(ConversationsInviteSharedRequest req) {
        return executor.execute(CONVERSATIONS_INVITE_SHARED, toMap(req), () -> methods.conversationsInviteShared(req));
    }

    @Override
    public CompletableFuture conversationsInviteShared(RequestConfigurator req) {
        return conversationsInviteShared(req.configure(ConversationsInviteSharedRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsAcceptSharedInvite(ConversationsAcceptSharedInviteRequest req) {
        return executor.execute(CONVERSATIONS_ACCEPT_SHARED_INVITE, toMap(req), () -> methods.conversationsAcceptSharedInvite(req));
    }

    @Override
    public CompletableFuture conversationsAcceptSharedInvite(RequestConfigurator req) {
        return conversationsAcceptSharedInvite(req.configure(ConversationsAcceptSharedInviteRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsApproveSharedInvite(ConversationsApproveSharedInviteRequest req) {
        return executor.execute(CONVERSATIONS_APPROVE_SHARED_INVITE, toMap(req), () -> methods.conversationsApproveSharedInvite(req));
    }

    @Override
    public CompletableFuture conversationsApproveSharedInvite(RequestConfigurator req) {
        return conversationsApproveSharedInvite(req.configure(ConversationsApproveSharedInviteRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsDeclineSharedInvite(ConversationsDeclineSharedInviteRequest req) {
        return executor.execute(CONVERSATIONS_DECLINE_SHARED_INVITE, toMap(req), () -> methods.conversationsDeclineSharedInvite(req));
    }

    @Override
    public CompletableFuture conversationsDeclineSharedInvite(RequestConfigurator req) {
        return conversationsDeclineSharedInvite(req.configure(ConversationsDeclineSharedInviteRequest.builder()).build());
    }

    @Override
    public CompletableFuture conversationsListConnectInvites(ConversationsListConnectInvitesRequest req) {
        return executor.execute(CONVERSATIONS_LIST_CONNECT_INVITES, toMap(req), () -> methods.conversationsListConnectInvites(req));
    }

    @Override
    public CompletableFuture conversationsListConnectInvites(RequestConfigurator req) {
        return conversationsListConnectInvites(req.configure(ConversationsListConnectInvitesRequest.builder()).build());
    }

    @Override
    public CompletableFuture dialogOpen(DialogOpenRequest req) {
        return executor.execute(DIALOG_OPEN, toMap(req), () -> methods.dialogOpen(req));
    }

    @Override
    public CompletableFuture dialogOpen(RequestConfigurator req) {
        return dialogOpen(req.configure(DialogOpenRequest.builder()).build());
    }

    @Override
    public CompletableFuture dndEndDnd(DndEndDndRequest req) {
        return executor.execute(DND_END_DND, toMap(req), () -> methods.dndEndDnd(req));
    }

    @Override
    public CompletableFuture dndEndDnd(RequestConfigurator req) {
        return dndEndDnd(req.configure(DndEndDndRequest.builder()).build());
    }

    @Override
    public CompletableFuture dndEndSnooze(DndEndSnoozeRequest req) {
        return executor.execute(DND_END_SNOOZE, toMap(req), () -> methods.dndEndSnooze(req));
    }

    @Override
    public CompletableFuture dndEndSnooze(RequestConfigurator req) {
        return dndEndSnooze(req.configure(DndEndSnoozeRequest.builder()).build());
    }

    @Override
    public CompletableFuture dndInfo(DndInfoRequest req) {
        return executor.execute(DND_INFO, toMap(req), () -> methods.dndInfo(req));
    }

    @Override
    public CompletableFuture dndInfo(RequestConfigurator req) {
        return dndInfo(req.configure(DndInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture dndSetSnooze(DndSetSnoozeRequest req) {
        return executor.execute(DND_SET_SNOOZE, toMap(req), () -> methods.dndSetSnooze(req));
    }

    @Override
    public CompletableFuture dndSetSnooze(RequestConfigurator req) {
        return dndSetSnooze(req.configure(DndSetSnoozeRequest.builder()).build());
    }

    @Override
    public CompletableFuture dndTeamInfo(DndTeamInfoRequest req) {
        return executor.execute(DND_TEAM_INFO, toMap(req), () -> methods.dndTeamInfo(req));
    }

    @Override
    public CompletableFuture dndTeamInfo(RequestConfigurator req) {
        return dndTeamInfo(req.configure(DndTeamInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture emojiList(EmojiListRequest req) {
        return executor.execute(EMOJI_LIST, toMap(req), () -> methods.emojiList(req));
    }

    @Override
    public CompletableFuture emojiList(RequestConfigurator req) {
        return emojiList(req.configure(EmojiListRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesDelete(FilesDeleteRequest req) {
        return executor.execute(FILES_DELETE, toMap(req), () -> methods.filesDelete(req));
    }

    @Override
    public CompletableFuture filesDelete(RequestConfigurator req) {
        return filesDelete(req.configure(FilesDeleteRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesInfo(FilesInfoRequest req) {
        return executor.execute(FILES_INFO, toMap(req), () -> methods.filesInfo(req));
    }

    @Override
    public CompletableFuture filesInfo(RequestConfigurator req) {
        return filesInfo(req.configure(FilesInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesList(FilesListRequest req) {
        return executor.execute(FILES_LIST, toMap(req), () -> methods.filesList(req));
    }

    @Override
    public CompletableFuture filesList(RequestConfigurator req) {
        return filesList(req.configure(FilesListRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesRevokePublicURL(FilesRevokePublicURLRequest req) {
        return executor.execute(FILES_REVOKE_PUBLIC_URL, toMap(req), () -> methods.filesRevokePublicURL(req));
    }

    @Override
    public CompletableFuture filesRevokePublicURL(RequestConfigurator req) {
        return filesRevokePublicURL(req.configure(FilesRevokePublicURLRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesSharedPublicURL(FilesSharedPublicURLRequest req) {
        return executor.execute(FILES_SHARED_PUBLIC_URL, toMap(req), () -> methods.filesSharedPublicURL(req));
    }

    @Override
    public CompletableFuture filesSharedPublicURL(RequestConfigurator req) {
        return filesSharedPublicURL(req.configure(FilesSharedPublicURLRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesUpload(FilesUploadRequest req) {
        return executor.execute(FILES_UPLOAD, toMap(req), () -> methods.filesUpload(req));
    }

    @Override
    public CompletableFuture filesUpload(RequestConfigurator req) {
        return filesUpload(req.configure(FilesUploadRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesGetUploadURLExternal(FilesGetUploadURLExternalRequest req) {
        return executor.execute(FILES_GET_UPLOAD_URL_EXTERNAL, toMap(req), () -> methods.filesGetUploadURLExternal(req));
    }

    @Override
    public CompletableFuture filesGetUploadURLExternal(RequestConfigurator req) {
        return filesGetUploadURLExternal(req.configure(FilesGetUploadURLExternalRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesCompleteUploadExternal(FilesCompleteUploadExternalRequest req) {
        return executor.execute(FILES_COMPLETE_UPLOAD_EXTERNAL, toMap(req), () -> methods.filesCompleteUploadExternal(req));
    }

    @Override
    public CompletableFuture filesCompleteUploadExternal(RequestConfigurator req) {
        return filesCompleteUploadExternal(req.configure(FilesCompleteUploadExternalRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesUploadV2(FilesUploadV2Request req) {
        // This wrapper method performs both FILES_GET_UPLOAD_URL_EXTERNAL and FILES_COMPLETE_UPLOAD_EXTERNAL.
        // Both are Tier 4 endpoints, so we treat this call as a single call for FILES_GET_UPLOAD_URL_EXTERNAL.
        // We know that this is not accurate when uploading many files at a time.
        // If we receive feedback from many users, we may improve the accuracy of smart rate limiter feature for this.
        return executor.execute(FILES_GET_UPLOAD_URL_EXTERNAL, toMap(req), () -> methods.filesUploadV2(req));
    }

    @Override
    public CompletableFuture filesUploadV2(RequestConfigurator req) {
        return filesUploadV2(req.configure(FilesUploadV2Request.builder()).build());
    }

    @Override
    public CompletableFuture filesRemoteAdd(FilesRemoteAddRequest req) {
        return executor.execute(FILES_REMOTE_ADD, toMap(req), () -> methods.filesRemoteAdd(req));
    }

    @Override
    public CompletableFuture filesRemoteAdd(RequestConfigurator req) {
        return filesRemoteAdd(req.configure(FilesRemoteAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesRemoteInfo(FilesRemoteInfoRequest req) {
        return executor.execute(FILES_REMOTE_INFO, toMap(req), () -> methods.filesRemoteInfo(req));
    }

    @Override
    public CompletableFuture filesRemoteInfo(RequestConfigurator req) {
        return filesRemoteInfo(req.configure(FilesRemoteInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesRemoteList(FilesRemoteListRequest req) {
        return executor.execute(FILES_REMOTE_LIST, toMap(req), () -> methods.filesRemoteList(req));
    }

    @Override
    public CompletableFuture filesRemoteList(RequestConfigurator req) {
        return filesRemoteList(req.configure(FilesRemoteListRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesRemoteRemove(FilesRemoteRemoveRequest req) {
        return executor.execute(FILES_REMOTE_REMOVE, toMap(req), () -> methods.filesRemoteRemove(req));
    }

    @Override
    public CompletableFuture filesRemoteRemove(RequestConfigurator req) {
        return filesRemoteRemove(req.configure(FilesRemoteRemoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesRemoteShare(FilesRemoteShareRequest req) {
        return executor.execute(FILES_REMOTE_SHARE, toMap(req), () -> methods.filesRemoteShare(req));
    }

    @Override
    public CompletableFuture filesRemoteShare(RequestConfigurator req) {
        return filesRemoteShare(req.configure(FilesRemoteShareRequest.builder()).build());
    }

    @Override
    public CompletableFuture filesRemoteUpdate(FilesRemoteUpdateRequest req) {
        return executor.execute(FILES_REMOTE_UPDATE, toMap(req), () -> methods.filesRemoteUpdate(req));
    }

    @Override
    public CompletableFuture filesRemoteUpdate(RequestConfigurator req) {
        return filesRemoteUpdate(req.configure(FilesRemoteUpdateRequest.builder()).build());
    }

    @Override
    public CompletableFuture migrationExchange(MigrationExchangeRequest req) {
        return executor.execute(MIGRATION_EXCHANGE, toMap(req), () -> methods.migrationExchange(req));
    }

    @Override
    public CompletableFuture migrationExchange(RequestConfigurator req) {
        return migrationExchange(req.configure(MigrationExchangeRequest.builder()).build());
    }

    @Override
    public CompletableFuture oauthAccess(OAuthAccessRequest req) {
        return executor.execute(OAUTH_ACCESS, toMap(req), () -> methods.oauthAccess(req));
    }

    @Override
    public CompletableFuture oauthAccess(RequestConfigurator req) {
        return oauthAccess(req.configure(OAuthAccessRequest.builder()).build());
    }

    @Override
    public CompletableFuture oauthV2Access(OAuthV2AccessRequest req) {
        return executor.execute(OAUTH_V2_ACCESS, toMap(req), () -> methods.oauthV2Access(req));
    }

    @Override
    public CompletableFuture oauthV2Access(RequestConfigurator req) {
        return oauthV2Access(req.configure(OAuthV2AccessRequest.builder()).build());
    }

    @Override
    public CompletableFuture oauthV2Exchange(OAuthV2ExchangeRequest req) {
        return executor.execute(OAUTH_V2_EXCHANGE, toMap(req), () -> methods.oauthV2Exchange(req));
    }

    @Override
    public CompletableFuture oauthV2Exchange(RequestConfigurator req) {
        return oauthV2Exchange(req.configure(OAuthV2ExchangeRequest.builder()).build());
    }

    @Override
    public CompletableFuture oauthToken(OAuthTokenRequest req) {
        return executor.execute(OAUTH_TOKEN, toMap(req), () -> methods.oauthToken(req));
    }

    @Override
    public CompletableFuture oauthToken(RequestConfigurator req) {
        return oauthToken(req.configure(OAuthTokenRequest.builder()).build());
    }

    @Override
    public CompletableFuture openIDConnectToken(OpenIDConnectTokenRequest req) {
        return executor.execute(OPENID_CONNECT_TOKEN, toMap(req), () -> methods.openIDConnectToken(req));
    }

    @Override
    public CompletableFuture openIDConnectToken(RequestConfigurator req) {
        return openIDConnectToken(req.configure(OpenIDConnectTokenRequest.builder()).build());
    }

    @Override
    public CompletableFuture openIDConnectUserInfo(OpenIDConnectUserInfoRequest req) {
        return executor.execute(OPENID_CONNECT_USER_INFO, toMap(req), () -> methods.openIDConnectUserInfo(req));
    }

    @Override
    public CompletableFuture openIDConnectUserInfo(RequestConfigurator req) {
        return openIDConnectUserInfo(req.configure(OpenIDConnectUserInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture pinsAdd(PinsAddRequest req) {
        return executor.execute(PINS_ADD, toMap(req), () -> methods.pinsAdd(req));
    }

    @Override
    public CompletableFuture pinsAdd(RequestConfigurator req) {
        return pinsAdd(req.configure(PinsAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture pinsList(PinsListRequest req) {
        return executor.execute(PINS_LIST, toMap(req), () -> methods.pinsList(req));
    }

    @Override
    public CompletableFuture pinsList(RequestConfigurator req) {
        return pinsList(req.configure(PinsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture pinsRemove(PinsRemoveRequest req) {
        return executor.execute(PINS_REMOVE, toMap(req), () -> methods.pinsRemove(req));
    }

    @Override
    public CompletableFuture pinsRemove(RequestConfigurator req) {
        return pinsRemove(req.configure(PinsRemoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture reactionsAdd(ReactionsAddRequest req) {
        return executor.execute(REACTIONS_ADD, toMap(req), () -> methods.reactionsAdd(req));
    }

    @Override
    public CompletableFuture reactionsAdd(RequestConfigurator req) {
        return reactionsAdd(req.configure(ReactionsAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture reactionsGet(ReactionsGetRequest req) {
        return executor.execute(REACTIONS_GET, toMap(req), () -> methods.reactionsGet(req));
    }

    @Override
    public CompletableFuture reactionsGet(RequestConfigurator req) {
        return reactionsGet(req.configure(ReactionsGetRequest.builder()).build());
    }

    @Override
    public CompletableFuture reactionsList(ReactionsListRequest req) {
        return executor.execute(REACTIONS_LIST, toMap(req), () -> methods.reactionsList(req));
    }

    @Override
    public CompletableFuture reactionsList(RequestConfigurator req) {
        return reactionsList(req.configure(ReactionsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture reactionsRemove(ReactionsRemoveRequest req) {
        return executor.execute(REACTIONS_REMOVE, toMap(req), () -> methods.reactionsRemove(req));
    }

    @Override
    public CompletableFuture reactionsRemove(RequestConfigurator req) {
        return reactionsRemove(req.configure(ReactionsRemoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture remindersAdd(RemindersAddRequest req) {
        return executor.execute(REMINDERS_ADD, toMap(req), () -> methods.remindersAdd(req));
    }

    @Override
    public CompletableFuture remindersAdd(RequestConfigurator req) {
        return remindersAdd(req.configure(RemindersAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture remindersComplete(RemindersCompleteRequest req) {
        return executor.execute(REMINDERS_COMPLETE, toMap(req), () -> methods.remindersComplete(req));
    }

    @Override
    public CompletableFuture remindersComplete(RequestConfigurator req) {
        return remindersComplete(req.configure(RemindersCompleteRequest.builder()).build());
    }

    @Override
    public CompletableFuture remindersDelete(RemindersDeleteRequest req) {
        return executor.execute(REMINDERS_DELETE, toMap(req), () -> methods.remindersDelete(req));
    }

    @Override
    public CompletableFuture remindersDelete(RequestConfigurator req) {
        return remindersDelete(req.configure(RemindersDeleteRequest.builder()).build());
    }

    @Override
    public CompletableFuture remindersInfo(RemindersInfoRequest req) {
        return executor.execute(REMINDERS_INFO, toMap(req), () -> methods.remindersInfo(req));
    }

    @Override
    public CompletableFuture remindersInfo(RequestConfigurator req) {
        return remindersInfo(req.configure(RemindersInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture remindersList(RemindersListRequest req) {
        return executor.execute(REMINDERS_LIST, toMap(req), () -> methods.remindersList(req));
    }

    @Override
    public CompletableFuture remindersList(RequestConfigurator req) {
        return remindersList(req.configure(RemindersListRequest.builder()).build());
    }

    @Override
    public CompletableFuture rtmConnect(RTMConnectRequest req) {
        return executor.execute(RTM_CONNECT, toMap(req), () -> methods.rtmConnect(req));
    }

    @Override
    public CompletableFuture rtmConnect(RequestConfigurator req) {
        return rtmConnect(req.configure(RTMConnectRequest.builder()).build());
    }

    @Override
    @Deprecated
    public CompletableFuture rtmStart(RTMStartRequest req) {
        return executor.execute(RTM_START, toMap(req), () -> methods.rtmStart(req));
    }

    @Override
    @Deprecated
    public CompletableFuture rtmStart(RequestConfigurator req) {
        return rtmStart(req.configure(RTMStartRequest.builder()).build());
    }

    @Override
    public CompletableFuture searchAll(SearchAllRequest req) {
        return executor.execute(SEARCH_ALL, toMap(req), () -> methods.searchAll(req));
    }

    @Override
    public CompletableFuture searchAll(RequestConfigurator req) {
        return searchAll(req.configure(SearchAllRequest.builder()).build());
    }

    @Override
    public CompletableFuture searchMessages(SearchMessagesRequest req) {
        return executor.execute(SEARCH_MESSAGES, toMap(req), () -> methods.searchMessages(req));
    }

    @Override
    public CompletableFuture searchMessages(RequestConfigurator req) {
        return searchMessages(req.configure(SearchMessagesRequest.builder()).build());
    }

    @Override
    public CompletableFuture searchFiles(SearchFilesRequest req) {
        return executor.execute(SEARCH_FILES, toMap(req), () -> methods.searchFiles(req));
    }

    @Override
    public CompletableFuture searchFiles(RequestConfigurator req) {
        return searchFiles(req.configure(SearchFilesRequest.builder()).build());
    }

    @Override
    public CompletableFuture starsAdd(StarsAddRequest req) {
        return executor.execute(STARS_ADD, toMap(req), () -> methods.starsAdd(req));
    }

    @Override
    public CompletableFuture starsAdd(RequestConfigurator req) {
        return starsAdd(req.configure(StarsAddRequest.builder()).build());
    }

    @Override
    public CompletableFuture starsList(StarsListRequest req) {
        return executor.execute(STARS_LIST, toMap(req), () -> methods.starsList(req));
    }

    @Override
    public CompletableFuture starsList(RequestConfigurator req) {
        return starsList(req.configure(StarsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture starsRemove(StarsRemoveRequest req) {
        return executor.execute(STARS_REMOVE, toMap(req), () -> methods.starsRemove(req));
    }

    @Override
    public CompletableFuture starsRemove(RequestConfigurator req) {
        return starsRemove(req.configure(StarsRemoveRequest.builder()).build());
    }

    @Override
    public CompletableFuture teamAccessLogs(TeamAccessLogsRequest req) {
        return executor.execute(TEAM_ACCESS_LOGS, toMap(req), () -> methods.teamAccessLogs(req));
    }

    @Override
    public CompletableFuture teamAccessLogs(RequestConfigurator req) {
        return teamAccessLogs(req.configure(TeamAccessLogsRequest.builder()).build());
    }

    @Override
    public CompletableFuture teamBillableInfo(TeamBillableInfoRequest req) {
        return executor.execute(TEAM_BILLABLE_INFO, toMap(req), () -> methods.teamBillableInfo(req));
    }

    @Override
    public CompletableFuture teamBillableInfo(RequestConfigurator req) {
        return teamBillableInfo(req.configure(TeamBillableInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture teamInfo(TeamInfoRequest req) {
        return executor.execute(TEAM_INFO, toMap(req), () -> methods.teamInfo(req));
    }

    @Override
    public CompletableFuture teamInfo(RequestConfigurator req) {
        return teamInfo(req.configure(TeamInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture teamIntegrationLogs(TeamIntegrationLogsRequest req) {
        return executor.execute(TEAM_INTEGRATION_LOGS, toMap(req), () -> methods.teamIntegrationLogs(req));
    }

    @Override
    public CompletableFuture teamIntegrationLogs(RequestConfigurator req) {
        return teamIntegrationLogs(req.configure(TeamIntegrationLogsRequest.builder()).build());
    }

    @Override
    public CompletableFuture teamProfileGet(TeamProfileGetRequest req) {
        return executor.execute(TEAM_PROFILE_GET, toMap(req), () -> methods.teamProfileGet(req));
    }

    @Override
    public CompletableFuture teamProfileGet(RequestConfigurator req) {
        return teamProfileGet(req.configure(TeamProfileGetRequest.builder()).build());
    }

    @Override
    public CompletableFuture teamBillingInfo(TeamBillingInfoRequest req) {
        return executor.execute(TEAM_BILLING_INFO, toMap(req), () -> methods.teamBillingInfo(req));
    }

    @Override
    public CompletableFuture teamBillingInfo(RequestConfigurator req) {
        return teamBillingInfo(req.configure(TeamBillingInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture teamPreferencesList(TeamPreferencesListRequest req) {
        return executor.execute(TEAM_PREFERENCES_LIST, toMap(req), () -> methods.teamPreferencesList(req));
    }

    @Override
    public CompletableFuture teamPreferencesList(RequestConfigurator req) {
        return teamPreferencesList(req.configure(TeamPreferencesListRequest.builder()).build());
    }

    @Override
    public CompletableFuture usergroupsCreate(UsergroupsCreateRequest req) {
        return executor.execute(USERGROUPS_CREATE, toMap(req), () -> methods.usergroupsCreate(req));
    }

    @Override
    public CompletableFuture usergroupsCreate(RequestConfigurator req) {
        return usergroupsCreate(req.configure(UsergroupsCreateRequest.builder()).build());
    }

    @Override
    public CompletableFuture usergroupsDisable(UsergroupsDisableRequest req) {
        return executor.execute(USERGROUPS_DISABLE, toMap(req), () -> methods.usergroupsDisable(req));
    }

    @Override
    public CompletableFuture usergroupsDisable(RequestConfigurator req) {
        return usergroupsDisable(req.configure(UsergroupsDisableRequest.builder()).build());
    }

    @Override
    public CompletableFuture usergroupsEnable(UsergroupsEnableRequest req) {
        return executor.execute(USERGROUPS_ENABLE, toMap(req), () -> methods.usergroupsEnable(req));
    }

    @Override
    public CompletableFuture usergroupsEnable(RequestConfigurator req) {
        return usergroupsEnable(req.configure(UsergroupsEnableRequest.builder()).build());
    }

    @Override
    public CompletableFuture usergroupsList(UsergroupsListRequest req) {
        return executor.execute(USERGROUPS_LIST, toMap(req), () -> methods.usergroupsList(req));
    }

    @Override
    public CompletableFuture usergroupsList(RequestConfigurator req) {
        return usergroupsList(req.configure(UsergroupsListRequest.builder()).build());
    }

    @Override
    public CompletableFuture usergroupsUpdate(UsergroupsUpdateRequest req) {
        return executor.execute(USERGROUPS_UPDATE, toMap(req), () -> methods.usergroupsUpdate(req));
    }

    @Override
    public CompletableFuture usergroupsUpdate(RequestConfigurator req) {
        return usergroupsUpdate(req.configure(UsergroupsUpdateRequest.builder()).build());
    }

    @Override
    public CompletableFuture usergroupsUsersList(UsergroupsUsersListRequest req) {
        return executor.execute(USERGROUPS_USERS_LIST, toMap(req), () -> methods.usergroupsUsersList(req));
    }

    @Override
    public CompletableFuture usergroupsUsersList(RequestConfigurator req) {
        return usergroupsUsersList(req.configure(UsergroupsUsersListRequest.builder()).build());
    }

    @Override
    public CompletableFuture usergroupsUsersUpdate(UsergroupsUsersUpdateRequest req) {
        return executor.execute(USERGROUPS_USERS_UPDATE, toMap(req), () -> methods.usergroupsUsersUpdate(req));
    }

    @Override
    public CompletableFuture usergroupsUsersUpdate(RequestConfigurator req) {
        return usergroupsUsersUpdate(req.configure(UsergroupsUsersUpdateRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersConversations(UsersConversationsRequest req) {
        return executor.execute(USERS_CONVERSATIONS, toMap(req), () -> methods.usersConversations(req));
    }

    @Override
    public CompletableFuture usersConversations(RequestConfigurator req) {
        return usersConversations(req.configure(UsersConversationsRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersDeletePhoto(UsersDeletePhotoRequest req) {
        return executor.execute(USERS_DELETE_PHOTO, toMap(req), () -> methods.usersDeletePhoto(req));
    }

    @Override
    public CompletableFuture usersDeletePhoto(RequestConfigurator req) {
        return usersDeletePhoto(req.configure(UsersDeletePhotoRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersGetPresence(UsersGetPresenceRequest req) {
        return executor.execute(USERS_GET_PRESENCE, toMap(req), () -> methods.usersGetPresence(req));
    }

    @Override
    public CompletableFuture usersGetPresence(RequestConfigurator req) {
        return usersGetPresence(req.configure(UsersGetPresenceRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersIdentity(UsersIdentityRequest req) {
        return executor.execute(USERS_IDENTITY, toMap(req), () -> methods.usersIdentity(req));
    }

    @Override
    public CompletableFuture usersIdentity(RequestConfigurator req) {
        return usersIdentity(req.configure(UsersIdentityRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersInfo(UsersInfoRequest req) {
        return executor.execute(USERS_INFO, toMap(req), () -> methods.usersInfo(req));
    }

    @Override
    public CompletableFuture usersInfo(RequestConfigurator req) {
        return usersInfo(req.configure(UsersInfoRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersList(UsersListRequest req) {
        return executor.execute(USERS_LIST, toMap(req), () -> methods.usersList(req));
    }

    @Override
    public CompletableFuture usersList(RequestConfigurator req) {
        return usersList(req.configure(UsersListRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersLookupByEmail(UsersLookupByEmailRequest req) {
        return executor.execute(USERS_LOOKUP_BY_EMAIL, toMap(req), () -> methods.usersLookupByEmail(req));
    }

    @Override
    public CompletableFuture usersLookupByEmail(RequestConfigurator req) {
        return usersLookupByEmail(req.configure(UsersLookupByEmailRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersSetActive(UsersSetActiveRequest req) {
        return executor.execute(USERS_SET_ACTIVE, toMap(req), () -> methods.usersSetActive(req));
    }

    @Override
    public CompletableFuture usersSetActive(RequestConfigurator req) {
        return usersSetActive(req.configure(UsersSetActiveRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersSetPhoto(UsersSetPhotoRequest req) {
        return executor.execute(USERS_SET_PHOTO, toMap(req), () -> methods.usersSetPhoto(req));
    }

    @Override
    public CompletableFuture usersSetPhoto(RequestConfigurator req) {
        return usersSetPhoto(req.configure(UsersSetPhotoRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersSetPresence(UsersSetPresenceRequest req) {
        return executor.execute(USERS_SET_PRESENCE, toMap(req), () -> methods.usersSetPresence(req));
    }

    @Override
    public CompletableFuture usersSetPresence(RequestConfigurator req) {
        return usersSetPresence(req.configure(UsersSetPresenceRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersProfileGet(UsersProfileGetRequest req) {
        return executor.execute(USERS_PROFILE_GET, toMap(req), () -> methods.usersProfileGet(req));
    }

    @Override
    public CompletableFuture usersProfileGet(RequestConfigurator req) {
        return usersProfileGet(req.configure(UsersProfileGetRequest.builder()).build());
    }

    @Override
    public CompletableFuture usersProfileSet(UsersProfileSetRequest req) {
        return executor.execute(USERS_PROFILE_SET, toMap(req), () -> methods.usersProfileSet(req));
    }

    @Override
    public CompletableFuture usersProfileSet(RequestConfigurator req) {
        return usersProfileSet(req.configure(UsersProfileSetRequest.builder()).build());
    }

    @Override
    public CompletableFuture viewsOpen(ViewsOpenRequest req) {
        return executor.execute(VIEWS_OPEN, toMap(req), () -> methods.viewsOpen(req));
    }

    @Override
    public CompletableFuture viewsOpen(RequestConfigurator req) {
        return viewsOpen(req.configure(ViewsOpenRequest.builder()).build());
    }

    @Override
    public CompletableFuture viewsPush(ViewsPushRequest req) {
        return executor.execute(VIEWS_PUSH, toMap(req), () -> methods.viewsPush(req));
    }

    @Override
    public CompletableFuture viewsPush(RequestConfigurator req) {
        return viewsPush(req.configure(ViewsPushRequest.builder()).build());
    }

    @Override
    public CompletableFuture viewsUpdate(ViewsUpdateRequest req) {
        return executor.execute(VIEWS_UPDATE, toMap(req), () -> methods.viewsUpdate(req));
    }

    @Override
    public CompletableFuture viewsUpdate(RequestConfigurator req) {
        return viewsUpdate(req.configure(ViewsUpdateRequest.builder()).build());
    }

    @Override
    public CompletableFuture viewsPublish(ViewsPublishRequest req) {
        return executor.execute(VIEWS_PUBLISH, toMap(req), () -> methods.viewsPublish(req));
    }

    @Override
    public CompletableFuture viewsPublish(RequestConfigurator req) {
        return viewsPublish(req.configure(ViewsPublishRequest.builder()).build());
    }

    @Override
    public CompletableFuture workflowsStepCompleted(WorkflowsStepCompletedRequest req) {
        return executor.execute(WORKFLOWS_STEP_COMPLETED, toMap(req), () -> methods.workflowsStepCompleted(req));
    }

    @Override
    public CompletableFuture workflowsStepCompleted(RequestConfigurator req) {
        return workflowsStepCompleted(req.configure(WorkflowsStepCompletedRequest.builder()).build());
    }

    @Override
    public CompletableFuture workflowsStepFailed(WorkflowsStepFailedRequest req) {
        return executor.execute(WORKFLOWS_STEP_FAILED, toMap(req), () -> methods.workflowsStepFailed(req));
    }

    @Override
    public CompletableFuture workflowsStepFailed(RequestConfigurator req) {
        return workflowsStepFailed(req.configure(WorkflowsStepFailedRequest.builder()).build());
    }

    @Override
    public CompletableFuture workflowsUpdateStep(WorkflowsUpdateStepRequest req) {
        return executor.execute(WORKFLOWS_UPDATE_STEP, toMap(req), () -> methods.workflowsUpdateStep(req));
    }

    @Override
    public CompletableFuture workflowsUpdateStep(RequestConfigurator req) {
        return workflowsUpdateStep(req.configure(WorkflowsUpdateStepRequest.builder()).build());
    }

}