@slack/web-api - npm Package Compare versions

Comparing version 5.10.0 to 5.11.0

dist/errors.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rateLimitedErrorWithDelay = exports.platformErrorFromResult = exports.httpErrorFromResponse = exports.requestErrorWithOriginal = exports.ErrorCode = void 0;
 /**
@@ -4,0 +5,0 @@ * A dictionary of codes for errors produced by this package

dist/helpers.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
 /**
@@ -4,0 +5,0 @@ * Build a Promise that will resolve after the specified number of milliseconds.

dist/index.js

 "use strict";
 /// <reference lib="es2017" />
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var WebClient_1 = require("./WebClient");
-exports.WebClient = WebClient_1.WebClient;
-exports.WebClientEvent = WebClient_1.WebClientEvent;
+Object.defineProperty(exports, "WebClient", { enumerable: true, get: function () { return WebClient_1.WebClient; } });
+Object.defineProperty(exports, "WebClientEvent", { enumerable: true, get: function () { return WebClient_1.WebClientEvent; } });
 var logger_1 = require("./logger");
-exports.LogLevel = logger_1.LogLevel;
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_1.LogLevel; } });
 var errors_1 = require("./errors");
-exports.ErrorCode = errors_1.ErrorCode;
+Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return errors_1.ErrorCode; } });
 var retry_policies_1 = require("./retry-policies");
-exports.retryPolicies = retry_policies_1.default;
+Object.defineProperty(exports, "retryPolicies", { enumerable: true, get: function () { return retry_policies_1.default; } });
 var instrument_1 = require("./instrument");
-exports.addAppMetadata = instrument_1.addAppMetadata;
-__export(require("./methods"));
+Object.defineProperty(exports, "addAppMetadata", { enumerable: true, get: function () { return instrument_1.addAppMetadata; } });
+__exportStar(require("./methods"), exports);
 //# sourceMappingURL=index.js.map

dist/instrument.js

 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserAgent = exports.addAppMetadata = void 0;
 const os = __importStar(require("os"));
@@ -11,0 +24,0 @@ const packageJson = require('../package.json'); // tslint:disable-line:no-require-imports no-var-requires

dist/logger.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = void 0;
 const logger_1 = require("@slack/logger");
 var logger_2 = require("@slack/logger");
-exports.LogLevel = logger_2.LogLevel;
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_2.LogLevel; } });
 let instanceCount = 0;
@@ -7,0 +8,0 @@ /**

dist/methods.d.ts

 /// <reference types="node" />
 import { Stream } from 'stream';
 import { Dialog, View, KnownBlock, Block, MessageAttachment, LinkUnfurls, CallUser } from '@slack/types';
-import { WebAPICallOptions, WebAPICallResult } from './WebClient';
+import { WebAPICallOptions, WebAPICallResult, WebClientEvent } from './WebClient';
+import { EventEmitter } from 'eventemitter3';
 /**
+ * A class that defines all Web API methods, their arguments type, their response type, and binds those methods to the
+ * `apiCall` class method.
+ */
+export declare abstract class Methods extends EventEmitter<WebClientEvent> {
+    protected constructor();
+    abstract apiCall(method: string, options?: WebAPICallOptions): Promise<WebAPICallResult>;
+    readonly admin: {
+        apps: {
+            approve: Method<AdminAppsApproveArguments, WebAPICallResult>;
+            approved: {
+                list: Method<AdminAppsApprovedListArguments, WebAPICallResult>;
+            };
+            requests: {
+                list: Method<AdminAppsRequestsListArguments, WebAPICallResult>;
+            };
+            restrict: Method<AdminAppsRestrictArguments, WebAPICallResult>;
+            restricted: {
+                list: Method<AdminAppsRestrictedListArguments, WebAPICallResult>;
+            };
+        };
+        conversations: {
+            setTeams: Method<AdminConversationsSetTeamsArguments, WebAPICallResult>;
+            restrictAccess: {
+                addGroup: Method<AdminConversationsRestrictAccessAddGroupArguments, WebAPICallResult>;
+                listGroups: Method<AdminConversationsRestrictAccessListGroupsArguments, WebAPICallResult>;
+                removeGroup: Method<AdminConversationsRestrictAccessRemoveGroupArguments, WebAPICallResult>;
+            };
+        };
+        inviteRequests: {
+            approve: Method<AdminInviteRequestsApproveArguments, WebAPICallResult>;
+            deny: Method<AdminInviteRequestsDenyArguments, WebAPICallResult>;
+            list: Method<AdminInviteRequestsListArguments, WebAPICallResult>;
+            approved: {
+                list: Method<AdminInviteRequestsApprovedListArguments, WebAPICallResult>;
+            };
+            denied: {
+                list: Method<AdminInviteRequestsDeniedListArguments, WebAPICallResult>;
+            };
+        };
+        teams: {
+            admins: {
+                list: Method<AdminTeamsAdminsListArguments, WebAPICallResult>;
+            };
+            create: Method<AdminTeamsCreateArguments, WebAPICallResult>;
+            list: Method<AdminTeamsListArguments, WebAPICallResult>;
+            owners: {
+                list: Method<AdminTeamsOwnersListArguments, WebAPICallResult>;
+            };
+            settings: {
+                info: Method<AdminTeamsSettingsInfoArguments, WebAPICallResult>;
+                setDefaultChannels: Method<AdminTeamsSettingsSetDefaultChannelsArguments, WebAPICallResult>;
+                setDescription: Method<AdminTeamsSettingsSetDescriptionArguments, WebAPICallResult>;
+                setDiscoverability: Method<AdminTeamsSettingsSetDiscoverabilityArguments, WebAPICallResult>;
+                setIcon: Method<AdminTeamsSettingseSetIconArguments, WebAPICallResult>;
+                setName: Method<AdminTeamsSettingsSetNameArguments, WebAPICallResult>;
+            };
+        };
+        usergroups: {
+            addChannels: Method<AdminUsergroupsAddChannelsArguments, WebAPICallResult>;
+            addTeams: Method<AdminUsergroupsAddTeamsArguments, WebAPICallResult>;
+            listChannels: Method<AdminUsergroupsListChannelsArguments, WebAPICallResult>;
+            removeChannels: Method<AdminUsergroupsRemoveChannelsArguments, WebAPICallResult>;
+        };
+        users: {
+            session: {
+                reset: Method<AdminUsersSessionResetArguments, WebAPICallResult>;
+            };
+            assign: Method<AdminUsersAssignArguments, WebAPICallResult>;
+            invite: Method<AdminUsersInviteArguments, WebAPICallResult>;
+            list: Method<AdminUsersListArguments, WebAPICallResult>;
+            remove: Method<AdminUsersRemoveArguments, WebAPICallResult>;
+            setAdmin: Method<AdminUsersSetAdminArguments, WebAPICallResult>;
+            setExpiration: Method<AdminUsersSetExpirationArguments, WebAPICallResult>;
+            setOwner: Method<AdminUsersSetOwnerArguments, WebAPICallResult>;
+            setRegular: Method<AdminUsersSetRegularArguments, WebAPICallResult>;
+        };
+    };
+    readonly api: {
+        test: Method<APITestArguments, WebAPICallResult>;
+    };
+    readonly auth: {
+        revoke: Method<AuthRevokeArguments, WebAPICallResult>;
+        test: Method<AuthTestArguments, WebAPICallResult>;
+    };
+    readonly bots: {
+        info: Method<BotsInfoArguments, WebAPICallResult>;
+    };
+    readonly calls: {
+        add: Method<CallsAddArguments, WebAPICallResult>;
+        end: Method<CallsEndArguments, WebAPICallResult>;
+        info: Method<CallsInfoArguments, WebAPICallResult>;
+        update: Method<CallsUpdateArguments, WebAPICallResult>;
+        participants: {
+            add: Method<CallsParticipantsAddArguments, WebAPICallResult>;
+            remove: Method<CallsParticipantsRemoveArguments, WebAPICallResult>;
+        };
+    };
+    readonly channels: {
+        archive: Method<ChannelsArchiveArguments, WebAPICallResult>;
+        create: Method<ChannelsCreateArguments, WebAPICallResult>;
+        history: Method<ChannelsHistoryArguments, WebAPICallResult>;
+        info: Method<ChannelsInfoArguments, WebAPICallResult>;
+        invite: Method<ChannelsInviteArguments, WebAPICallResult>;
+        join: Method<ChannelsJoinArguments, WebAPICallResult>;
+        kick: Method<ChannelsKickArguments, WebAPICallResult>;
+        leave: Method<ChannelsLeaveArguments, WebAPICallResult>;
+        list: Method<ChannelsListArguments, WebAPICallResult>;
+        mark: Method<ChannelsMarkArguments, WebAPICallResult>;
+        rename: Method<ChannelsRenameArguments, WebAPICallResult>;
+        replies: Method<ChannelsRepliesArguments, WebAPICallResult>;
+        setPurpose: Method<ChannelsSetPurposeArguments, WebAPICallResult>;
+        setTopic: Method<ChannelsSetTopicArguments, WebAPICallResult>;
+        unarchive: Method<ChannelsUnarchiveArguments, WebAPICallResult>;
+    };
+    readonly chat: {
+        delete: Method<ChatDeleteArguments, WebAPICallResult>;
+        deleteScheduledMessage: Method<ChatDeleteScheduledMessageArguments, WebAPICallResult>;
+        getPermalink: Method<ChatGetPermalinkArguments, WebAPICallResult>;
+        meMessage: Method<ChatMeMessageArguments, WebAPICallResult>;
+        postEphemeral: Method<ChatPostEphemeralArguments, WebAPICallResult>;
+        postMessage: Method<ChatPostMessageArguments, WebAPICallResult>;
+        scheduleMessage: Method<ChatScheduleMessageArguments, WebAPICallResult>;
+        scheduledMessages: {
+            list: Method<ChatScheduledMessagesListArguments, WebAPICallResult>;
+        };
+        unfurl: Method<ChatUnfurlArguments, WebAPICallResult>;
+        update: Method<ChatUpdateArguments, WebAPICallResult>;
+    };
+    readonly conversations: {
+        archive: Method<ConversationsArchiveArguments, WebAPICallResult>;
+        close: Method<ConversationsCloseArguments, WebAPICallResult>;
+        create: Method<ConversationsCreateArguments, WebAPICallResult>;
+        history: Method<ConversationsHistoryArguments, WebAPICallResult>;
+        info: Method<ConversationsInfoArguments, WebAPICallResult>;
+        invite: Method<ConversationsInviteArguments, WebAPICallResult>;
+        join: Method<ConversationsJoinArguments, WebAPICallResult>;
+        kick: Method<ConversationsKickArguments, WebAPICallResult>;
+        leave: Method<ConversationsLeaveArguments, WebAPICallResult>;
+        list: Method<ConversationsListArguments, WebAPICallResult>;
+        mark: Method<ConversationsMarkArguments, WebAPICallResult>;
+        members: Method<ConversationsMembersArguments, WebAPICallResult>;
+        open: Method<ConversationsOpenArguments, WebAPICallResult>;
+        rename: Method<ConversationsRenameArguments, WebAPICallResult>;
+        replies: Method<ConversationsRepliesArguments, WebAPICallResult>;
+        setPurpose: Method<ConversationsSetPurposeArguments, WebAPICallResult>;
+        setTopic: Method<ConversationsSetTopicArguments, WebAPICallResult>;
+        unarchive: Method<ConversationsUnarchiveArguments, WebAPICallResult>;
+    };
+    readonly views: {
+        open: Method<ViewsOpenArguments, WebAPICallResult>;
+        publish: Method<ViewsPublishArguments, WebAPICallResult>;
+        push: Method<ViewsPushArguments, WebAPICallResult>;
+        update: Method<ViewsUpdateArguments, WebAPICallResult>;
+    };
+    readonly dialog: {
+        open: Method<DialogOpenArguments, WebAPICallResult>;
+    };
+    readonly dnd: {
+        endDnd: Method<DndEndDndArguments, WebAPICallResult>;
+        endSnooze: Method<DndEndSnoozeArguments, WebAPICallResult>;
+        info: Method<DndInfoArguments, WebAPICallResult>;
+        setSnooze: Method<DndSetSnoozeArguments, WebAPICallResult>;
+        teamInfo: Method<DndTeamInfoArguments, WebAPICallResult>;
+    };
+    readonly emoji: {
+        list: Method<EmojiListArguments, WebAPICallResult>;
+    };
+    readonly files: {
+        delete: Method<FilesDeleteArguments, WebAPICallResult>;
+        info: Method<FilesInfoArguments, WebAPICallResult>;
+        list: Method<FilesListArguments, WebAPICallResult>;
+        revokePublicURL: Method<FilesRevokePublicURLArguments, WebAPICallResult>;
+        sharedPublicURL: Method<FilesSharedPublicURLArguments, WebAPICallResult>;
+        upload: Method<FilesUploadArguments, WebAPICallResult>;
+        comments: {
+            delete: Method<FilesCommentsDeleteArguments, WebAPICallResult>;
+        };
+        remote: {
+            info: Method<FilesRemoteInfoArguments, WebAPICallResult>;
+            list: Method<FilesRemoteListArguments, WebAPICallResult>;
+            add: Method<FilesRemoteAddArguments, WebAPICallResult>;
+            update: Method<FilesRemoteUpdateArguments, WebAPICallResult>;
+            remove: Method<FilesRemoteRemoveArguments, WebAPICallResult>;
+            share: Method<FilesRemoteShareArguments, WebAPICallResult>;
+        };
+    };
+    readonly groups: {
+        archive: Method<GroupsArchiveArguments, WebAPICallResult>;
+        create: Method<GroupsCreateArguments, WebAPICallResult>;
+        createChild: Method<GroupsCreateChildArguments, WebAPICallResult>;
+        history: Method<GroupsHistoryArguments, WebAPICallResult>;
+        info: Method<GroupsInfoArguments, WebAPICallResult>;
+        invite: Method<GroupsInviteArguments, WebAPICallResult>;
+        kick: Method<GroupsKickArguments, WebAPICallResult>;
+        leave: Method<GroupsLeaveArguments, WebAPICallResult>;
+        list: Method<GroupsListArguments, WebAPICallResult>;
+        mark: Method<GroupsMarkArguments, WebAPICallResult>;
+        open: Method<GroupsOpenArguments, WebAPICallResult>;
+        rename: Method<GroupsRenameArguments, WebAPICallResult>;
+        replies: Method<GroupsRepliesArguments, WebAPICallResult>;
+        setPurpose: Method<GroupsSetPurposeArguments, WebAPICallResult>;
+        setTopic: Method<GroupsSetTopicArguments, WebAPICallResult>;
+        unarchive: Method<GroupsUnarchiveArguments, WebAPICallResult>;
+    };
+    readonly im: {
+        close: Method<IMCloseArguments, WebAPICallResult>;
+        history: Method<IMHistoryArguments, WebAPICallResult>;
+        list: Method<IMListArguments, WebAPICallResult>;
+        mark: Method<IMMarkArguments, WebAPICallResult>;
+        open: Method<IMOpenArguments, WebAPICallResult>;
+        replies: Method<IMRepliesArguments, WebAPICallResult>;
+    };
+    readonly migration: {
+        exchange: Method<MigrationExchangeArguments, WebAPICallResult>;
+    };
+    readonly mpim: {
+        close: Method<MPIMCloseArguments, WebAPICallResult>;
+        history: Method<MPIMHistoryArguments, WebAPICallResult>;
+        list: Method<MPIMListArguments, WebAPICallResult>;
+        mark: Method<MPIMMarkArguments, WebAPICallResult>;
+        open: Method<MPIMOpenArguments, WebAPICallResult>;
+        replies: Method<MPIMRepliesArguments, WebAPICallResult>;
+    };
+    readonly oauth: {
+        access: Method<OAuthAccessArguments, WebAPICallResult>;
+        v2: {
+            access: Method<OAuthV2AccessArguments, WebAPICallResult>;
+        };
+    };
+    readonly pins: {
+        add: Method<PinsAddArguments, WebAPICallResult>;
+        list: Method<PinsListArguments, WebAPICallResult>;
+        remove: Method<PinsRemoveArguments, WebAPICallResult>;
+    };
+    readonly reactions: {
+        add: Method<ReactionsAddArguments, WebAPICallResult>;
+        get: Method<ReactionsGetArguments, WebAPICallResult>;
+        list: Method<ReactionsListArguments, WebAPICallResult>;
+        remove: Method<ReactionsRemoveArguments, WebAPICallResult>;
+    };
+    readonly reminders: {
+        add: Method<RemindersAddArguments, WebAPICallResult>;
+        complete: Method<RemindersCompleteArguments, WebAPICallResult>;
+        delete: Method<RemindersDeleteArguments, WebAPICallResult>;
+        info: Method<RemindersInfoArguments, WebAPICallResult>;
+        list: Method<RemindersListArguments, WebAPICallResult>;
+    };
+    readonly rtm: {
+        connect: Method<RTMConnectArguments, WebAPICallResult>;
+        start: Method<RTMStartArguments, WebAPICallResult>;
+    };
+    readonly search: {
+        all: Method<SearchAllArguments, WebAPICallResult>;
+        files: Method<SearchFilesArguments, WebAPICallResult>;
+        messages: Method<SearchMessagesArguments, WebAPICallResult>;
+    };
+    readonly stars: {
+        add: Method<StarsAddArguments, WebAPICallResult>;
+        list: Method<StarsListArguments, WebAPICallResult>;
+        remove: Method<StarsRemoveArguments, WebAPICallResult>;
+    };
+    readonly team: {
+        accessLogs: Method<TeamAccessLogsArguments, WebAPICallResult>;
+        billableInfo: Method<TeamBillableInfoArguments, WebAPICallResult>;
+        info: Method<TeamInfoArguments, WebAPICallResult>;
+        integrationLogs: Method<TeamIntegrationLogsArguments, WebAPICallResult>;
+        profile: {
+            get: Method<TeamProfileGetArguments, WebAPICallResult>;
+        };
+    };
+    readonly usergroups: {
+        create: Method<UsergroupsCreateArguments, WebAPICallResult>;
+        disable: Method<UsergroupsDisableArguments, WebAPICallResult>;
+        enable: Method<UsergroupsEnableArguments, WebAPICallResult>;
+        list: Method<UsergroupsListArguments, WebAPICallResult>;
+        update: Method<UsergroupsUpdateArguments, WebAPICallResult>;
+        users: {
+            list: Method<UsergroupsUsersListArguments, WebAPICallResult>;
+            update: Method<UsergroupsUsersUpdateArguments, WebAPICallResult>;
+        };
+    };
+    readonly users: {
+        conversations: Method<UsersConversationsArguments, WebAPICallResult>;
+        deletePhoto: Method<UsersDeletePhotoArguments, WebAPICallResult>;
+        getPresence: Method<UsersGetPresenceArguments, WebAPICallResult>;
+        identity: Method<UsersIdentityArguments, WebAPICallResult>;
+        info: Method<UsersInfoArguments, WebAPICallResult>;
+        list: Method<UsersListArguments, WebAPICallResult>;
+        lookupByEmail: Method<UsersLookupByEmailArguments, WebAPICallResult>;
+        setPhoto: Method<UsersSetPhotoArguments, WebAPICallResult>;
+        setPresence: Method<UsersSetPresenceArguments, WebAPICallResult>;
+        profile: {
+            get: Method<UsersProfileGetArguments, WebAPICallResult>;
+            set: Method<UsersProfileSetArguments, WebAPICallResult>;
+        };
+    };
+}
+/**
  * Generic method definition
  */
-export default interface Method<MethodArguments extends WebAPICallOptions> {
-    (options?: MethodArguments): Promise<WebAPICallResult>;
+export default interface Method<MethodArguments extends WebAPICallOptions, MethodResult extends WebAPICallResult = WebAPICallResult> {
+    (options?: MethodArguments): Promise<MethodResult>;
 }
@@ -58,2 +357,16 @@ export interface TokenOverridable {
 }
+export interface AdminConversationsRestrictAccessAddGroupArguments extends WebAPICallOptions, TokenOverridable {
+    channel_id: string;
+    group_id: string;
+    team_id?: string;
+}
+export interface AdminConversationsRestrictAccessListGroupsArguments extends WebAPICallOptions, TokenOverridable {
+    channel_id: string;
+    team_id?: string;
+}
+export interface AdminConversationsRestrictAccessRemoveGroupArguments extends WebAPICallOptions, TokenOverridable {
+    channel_id: string;
+    group_id: string;
+    team_id: string;
+}
 export interface AdminConversationsSetTeamsArguments extends WebAPICallOptions, TokenOverridable {
@@ -121,5 +434,10 @@ channel_id: string;
     usergroup_id: string;
-    team_id: string;
+    team_id?: string;
     channel_ids: string | string[];
 }
+export interface AdminUsergroupsAddTeamsArguments extends WebAPICallOptions, TokenOverridable {
+    usergroup_id: string;
+    team_ids: string | string[];
+    auto_provision?: boolean;
+}
 export interface AdminUsergroupsListChannelsArguments extends WebAPICallOptions, TokenOverridable {
@@ -217,2 +535,6 @@ usergroup_id: string;
 }
+export interface CallsParticipantsRemoveArguments extends WebAPICallOptions, TokenOverridable {
+    id: string;
+    users: CallUser[];
+}
 export interface ChannelsArchiveArguments extends WebAPICallOptions, TokenOverridable {
@@ -392,2 +714,6 @@ channel: string;
 }
+export interface ConversationsMarkArguments extends WebAPICallOptions, TokenOverridable {
+    channel: string;
+    ts: string;
+}
 export interface ConversationsMembersArguments extends WebAPICallOptions, TokenOverridable, CursorPaginationEnabled {
@@ -394,0 +720,0 @@ channel: string;

dist/methods.js

 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cursorPaginationEnabledMethods = exports.Methods = void 0;
+const WebClient_1 = require("./WebClient");
+const eventemitter3_1 = require("eventemitter3");
+// NOTE: could create a named type alias like data types like `SlackUserID: string`
+/**
+ * Binds a certain `method` and its arguments and result types to the `apiCall` method in `WebClient`.
+ */
+function bindApiCall(self, method) {
+    // We have to "assert" that the bound method does indeed return the more specific `Result` type instead of just
+    // `WebAPICallResult`
+    return self.apiCall.bind(self, method);
+}
+/**
+ * A class that defines all Web API methods, their arguments type, their response type, and binds those methods to the
+ * `apiCall` class method.
+ */
+class Methods extends eventemitter3_1.EventEmitter {
+    // TODO: As of writing, `WebClient` already extends EventEmitter...
+    // and I want WebClient to extend this class...
+    // and multiple inheritance in JS is cursed...
+    // so I'm just making this class extend EventEmitter.
+    //
+    // It shouldn't be here, indeed. Nothing here uses it, indeed. But it must be here for the sake of sanity.
+    constructor() {
+        super();
+        this.admin = {
+            apps: {
+                approve: bindApiCall(this, 'admin.apps.approve'),
+                approved: {
+                    list: bindApiCall(this, 'admin.apps.approved.list'),
+                },
+                requests: {
+                    list: bindApiCall(this, 'admin.apps.requests.list'),
+                },
+                restrict: bindApiCall(this, 'admin.apps.restrict'),
+                restricted: {
+                    list: bindApiCall(this, 'admin.apps.restricted.list'),
+                },
+            },
+            conversations: {
+                setTeams: bindApiCall(this, 'admin.conversations.setTeams'),
+                restrictAccess: {
+                    addGroup: bindApiCall(this, 'admin.conversations.restrictAccess.addGroup'),
+                    listGroups: bindApiCall(this, 'admin.conversations.restrictAccess.listGroups'),
+                    removeGroup: bindApiCall(this, 'admin.conversations.restrictAccess.removeGroup'),
+                },
+            },
+            inviteRequests: {
+                approve: bindApiCall(this, 'admin.inviteRequests.approve'),
+                deny: bindApiCall(this, 'admin.inviteRequests.deny'),
+                list: bindApiCall(this, 'admin.inviteRequests.list'),
+                approved: {
+                    list: bindApiCall(this, 'admin.inviteRequests.approved.list'),
+                },
+                denied: {
+                    list: bindApiCall(this, 'admin.inviteRequests.denied.list'),
+                },
+            },
+            teams: {
+                admins: {
+                    list: bindApiCall(this, 'admin.teams.admins.list'),
+                },
+                create: bindApiCall(this, 'admin.teams.create'),
+                list: bindApiCall(this, 'admin.teams.list'),
+                owners: {
+                    list: bindApiCall(this, 'admin.teams.owners.list'),
+                },
+                settings: {
+                    info: bindApiCall(this, 'admin.teams.settings.info'),
+                    setDefaultChannels: bindApiCall(this, 'admin.teams.settings.setDefaultChannels'),
+                    setDescription: bindApiCall(this, 'admin.teams.settings.setDescription'),
+                    setDiscoverability: bindApiCall(this, 'admin.teams.settings.setDiscoverability'),
+                    setIcon: bindApiCall(this, 'admin.teams.settings.setIcon'),
+                    setName: bindApiCall(this, 'admin.teams.settings.setName'),
+                },
+            },
+            usergroups: {
+                addChannels: bindApiCall(this, 'admin.usergroups.addChannels'),
+                addTeams: bindApiCall(this, 'admin.usergroups.addTeams'),
+                listChannels: bindApiCall(this, 'admin.usergroups.listChannels'),
+                removeChannels: bindApiCall(this, 'admin.usergroups.removeChannels'),
+            },
+            users: {
+                session: {
+                    reset: bindApiCall(this, 'admin.users.session.reset'),
+                },
+                assign: bindApiCall(this, 'admin.users.assign'),
+                invite: bindApiCall(this, 'admin.users.invite'),
+                list: bindApiCall(this, 'admin.users.list'),
+                remove: bindApiCall(this, 'admin.users.remove'),
+                setAdmin: bindApiCall(this, 'admin.users.setAdmin'),
+                setExpiration: bindApiCall(this, 'admin.users.setExpiration'),
+                setOwner: bindApiCall(this, 'admin.users.setOwner'),
+                setRegular: bindApiCall(this, 'admin.users.setRegular'),
+            },
+        };
+        this.api = {
+            test: bindApiCall(this, 'api.test'),
+        };
+        this.auth = {
+            revoke: bindApiCall(this, 'auth.revoke'),
+            test: bindApiCall(this, 'auth.test'),
+        };
+        this.bots = {
+            info: bindApiCall(this, 'bots.info'),
+        };
+        this.calls = {
+            add: bindApiCall(this, 'calls.add'),
+            end: bindApiCall(this, 'calls.end'),
+            info: bindApiCall(this, 'calls.info'),
+            update: bindApiCall(this, 'calls.update'),
+            participants: {
+                add: bindApiCall(this, 'calls.participants.add'),
+                remove: bindApiCall(this, 'calls.participants.remove'),
+            },
+        };
+        this.channels = {
+            archive: bindApiCall(this, 'channels.archive'),
+            create: bindApiCall(this, 'channels.create'),
+            history: bindApiCall(this, 'channels.history'),
+            info: bindApiCall(this, 'channels.info'),
+            invite: bindApiCall(this, 'channels.invite'),
+            join: bindApiCall(this, 'channels.join'),
+            kick: bindApiCall(this, 'channels.kick'),
+            leave: bindApiCall(this, 'channels.leave'),
+            list: bindApiCall(this, 'channels.list'),
+            mark: bindApiCall(this, 'channels.mark'),
+            rename: bindApiCall(this, 'channels.rename'),
+            replies: bindApiCall(this, 'channels.replies'),
+            setPurpose: bindApiCall(this, 'channels.setPurpose'),
+            setTopic: bindApiCall(this, 'channels.setTopic'),
+            unarchive: bindApiCall(this, 'channels.unarchive'),
+        };
+        this.chat = {
+            delete: bindApiCall(this, 'chat.delete'),
+            deleteScheduledMessage: bindApiCall(this, 'chat.deleteScheduledMessage'),
+            getPermalink: bindApiCall(this, 'chat.getPermalink'),
+            meMessage: bindApiCall(this, 'chat.meMessage'),
+            postEphemeral: bindApiCall(this, 'chat.postEphemeral'),
+            postMessage: bindApiCall(this, 'chat.postMessage'),
+            scheduleMessage: bindApiCall(this, 'chat.scheduleMessage'),
+            scheduledMessages: {
+                list: bindApiCall(this, 'chat.scheduledMessages.list'),
+            },
+            unfurl: bindApiCall(this, 'chat.unfurl'),
+            update: bindApiCall(this, 'chat.update'),
+        };
+        this.conversations = {
+            archive: bindApiCall(this, 'conversations.archive'),
+            close: bindApiCall(this, 'conversations.close'),
+            create: bindApiCall(this, 'conversations.create'),
+            history: bindApiCall(this, 'conversations.history'),
+            info: bindApiCall(this, 'conversations.info'),
+            invite: bindApiCall(this, 'conversations.invite'),
+            join: bindApiCall(this, 'conversations.join'),
+            kick: bindApiCall(this, 'conversations.kick'),
+            leave: bindApiCall(this, 'conversations.leave'),
+            list: bindApiCall(this, 'conversations.list'),
+            mark: bindApiCall(this, 'conversations.mark'),
+            members: bindApiCall(this, 'conversations.members'),
+            open: bindApiCall(this, 'conversations.open'),
+            rename: bindApiCall(this, 'conversations.rename'),
+            replies: bindApiCall(this, 'conversations.replies'),
+            setPurpose: bindApiCall(this, 'conversations.setPurpose'),
+            setTopic: bindApiCall(this, 'conversations.setTopic'),
+            unarchive: bindApiCall(this, 'conversations.unarchive'),
+        };
+        this.views = {
+            open: bindApiCall(this, 'views.open'),
+            publish: bindApiCall(this, 'views.publish'),
+            push: bindApiCall(this, 'views.push'),
+            update: bindApiCall(this, 'views.update'),
+        };
+        this.dialog = {
+            open: bindApiCall(this, 'dialog.open'),
+        };
+        this.dnd = {
+            endDnd: bindApiCall(this, 'dnd.endDnd'),
+            endSnooze: bindApiCall(this, 'dnd.endSnooze'),
+            info: bindApiCall(this, 'dnd.info'),
+            setSnooze: bindApiCall(this, 'dnd.setSnooze'),
+            teamInfo: bindApiCall(this, 'dnd.teamInfo'),
+        };
+        this.emoji = {
+            list: bindApiCall(this, 'emoji.list'),
+        };
+        this.files = {
+            delete: bindApiCall(this, 'files.delete'),
+            info: bindApiCall(this, 'files.info'),
+            list: bindApiCall(this, 'files.list'),
+            revokePublicURL: bindApiCall(this, 'files.revokePublicURL'),
+            sharedPublicURL: bindApiCall(this, 'files.sharedPublicURL'),
+            upload: bindApiCall(this, 'files.upload'),
+            comments: {
+                delete: bindApiCall(this, 'files.comments.delete'),
+            },
+            remote: {
+                info: bindApiCall(this, 'files.remote.info'),
+                list: bindApiCall(this, 'files.remote.list'),
+                add: bindApiCall(this, 'files.remote.add'),
+                update: bindApiCall(this, 'files.remote.update'),
+                remove: bindApiCall(this, 'files.remote.remove'),
+                share: bindApiCall(this, 'files.remote.share'),
+            },
+        };
+        this.groups = {
+            archive: bindApiCall(this, 'groups.archive'),
+            create: bindApiCall(this, 'groups.create'),
+            createChild: bindApiCall(this, 'groups.createChild'),
+            history: bindApiCall(this, 'groups.history'),
+            info: bindApiCall(this, 'groups.info'),
+            invite: bindApiCall(this, 'groups.invite'),
+            kick: bindApiCall(this, 'groups.kick'),
+            leave: bindApiCall(this, 'groups.leave'),
+            list: bindApiCall(this, 'groups.list'),
+            mark: bindApiCall(this, 'groups.mark'),
+            open: bindApiCall(this, 'groups.open'),
+            rename: bindApiCall(this, 'groups.rename'),
+            replies: bindApiCall(this, 'groups.replies'),
+            setPurpose: bindApiCall(this, 'groups.setPurpose'),
+            setTopic: bindApiCall(this, 'groups.setTopic'),
+            unarchive: bindApiCall(this, 'groups.unarchive'),
+        };
+        this.im = {
+            close: bindApiCall(this, 'im.close'),
+            history: bindApiCall(this, 'im.history'),
+            list: bindApiCall(this, 'im.list'),
+            mark: bindApiCall(this, 'im.mark'),
+            open: bindApiCall(this, 'im.open'),
+            replies: bindApiCall(this, 'im.replies'),
+        };
+        this.migration = {
+            exchange: bindApiCall(this, 'migration.exchange'),
+        };
+        this.mpim = {
+            close: bindApiCall(this, 'mpim.close'),
+            history: bindApiCall(this, 'mpim.history'),
+            list: bindApiCall(this, 'mpim.list'),
+            mark: bindApiCall(this, 'mpim.mark'),
+            open: bindApiCall(this, 'mpim.open'),
+            replies: bindApiCall(this, 'mpim.replies'),
+        };
+        this.oauth = {
+            access: bindApiCall(this, 'oauth.access'),
+            v2: {
+                access: bindApiCall(this, 'oauth.v2.access'),
+            },
+        };
+        this.pins = {
+            add: bindApiCall(this, 'pins.add'),
+            list: bindApiCall(this, 'pins.list'),
+            remove: bindApiCall(this, 'pins.remove'),
+        };
+        this.reactions = {
+            add: bindApiCall(this, 'reactions.add'),
+            get: bindApiCall(this, 'reactions.get'),
+            list: bindApiCall(this, 'reactions.list'),
+            remove: bindApiCall(this, 'reactions.remove'),
+        };
+        this.reminders = {
+            add: bindApiCall(this, 'reminders.add'),
+            complete: bindApiCall(this, 'reminders.complete'),
+            delete: bindApiCall(this, 'reminders.delete'),
+            info: bindApiCall(this, 'reminders.info'),
+            list: bindApiCall(this, 'reminders.list'),
+        };
+        this.rtm = {
+            connect: bindApiCall(this, 'rtm.connect'),
+            start: bindApiCall(this, 'rtm.start'),
+        };
+        this.search = {
+            all: bindApiCall(this, 'search.all'),
+            files: bindApiCall(this, 'search.files'),
+            messages: bindApiCall(this, 'search.messages'),
+        };
+        this.stars = {
+            add: bindApiCall(this, 'stars.add'),
+            list: bindApiCall(this, 'stars.list'),
+            remove: bindApiCall(this, 'stars.remove'),
+        };
+        this.team = {
+            accessLogs: bindApiCall(this, 'team.accessLogs'),
+            billableInfo: bindApiCall(this, 'team.billableInfo'),
+            info: bindApiCall(this, 'team.info'),
+            integrationLogs: bindApiCall(this, 'team.integrationLogs'),
+            profile: {
+                get: bindApiCall(this, 'team.profile.get'),
+            },
+        };
+        this.usergroups = {
+            create: bindApiCall(this, 'usergroups.create'),
+            disable: bindApiCall(this, 'usergroups.disable'),
+            enable: bindApiCall(this, 'usergroups.enable'),
+            list: bindApiCall(this, 'usergroups.list'),
+            update: bindApiCall(this, 'usergroups.update'),
+            users: {
+                list: bindApiCall(this, 'usergroups.users.list'),
+                update: bindApiCall(this, 'usergroups.users.update'),
+            },
+        };
+        this.users = {
+            conversations: bindApiCall(this, 'users.conversations'),
+            deletePhoto: bindApiCall(this, 'users.deletePhoto'),
+            getPresence: bindApiCall(this, 'users.getPresence'),
+            identity: bindApiCall(this, 'users.identity'),
+            info: bindApiCall(this, 'users.info'),
+            list: bindApiCall(this, 'users.list'),
+            lookupByEmail: bindApiCall(this, 'users.lookupByEmail'),
+            setPhoto: bindApiCall(this, 'users.setPhoto'),
+            setPresence: bindApiCall(this, 'users.setPresence'),
+            profile: {
+                get: bindApiCall(this, 'users.profile.get'),
+                set: bindApiCall(this, 'users.profile.set'),
+            },
+        };
+        // Check that the class being created extends from `WebClient` rather than this class
+        if (new.target !== WebClient_1.WebClient && !(new.target.prototype instanceof WebClient_1.WebClient)) {
+            throw new Error('Attempt to inherit from WebClient methods without inheriting from WebClient');
+        }
+    }
+}
+exports.Methods = Methods;
 // A set of method names is initialized here and added to each time an argument type extends the CursorPaginationEnabled
@@ -32,2 +364,3 @@ // interface, so that methods are checked against this set when using the pagination helper. If the method name is not
 exports.cursorPaginationEnabledMethods.add('users.list');
+__exportStar(require("@slack/types"), exports);
 //# sourceMappingURL=methods.js.map

dist/retry-policies.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rapidRetryPolicy = exports.fiveRetriesInFiveMinutes = exports.tenRetriesInAboutThirtyMinutes = void 0;
 /**
@@ -4,0 +5,0 @@ * The default retry policy. Retry up to 10 times, over the span of about 30 minutes. It's not exact because

dist/WebClient.d.ts

@@ -5,4 +5,3 @@ /// <reference types="node" />
 import { SecureContextOptions } from 'tls';
-import { EventEmitter } from 'eventemitter3';
-import Method, * as methods from './methods';
+import { Methods } from './methods';
 import { LogLevel, Logger } from './logger';
@@ -16,3 +15,3 @@ import { RetryOptions } from './retry-policies';
  */
-export declare class WebClient extends EventEmitter<WebClientEvent> {
+export declare class WebClient extends Methods {
     /**
@@ -86,369 +85,6 @@ * The base URL for reaching Slack's Web API. Consider changing this value for testing purposes.
      */
-    paginate(method: string, options?: WebAPICallOptions): AsyncIterator<WebAPICallResult>;
+    paginate(method: string, options?: WebAPICallOptions): AsyncIterable<WebAPICallResult>;
     paginate(method: string, options: WebAPICallOptions, shouldStop: PaginatePredicate): Promise<void>;
     paginate<R extends PageReducer, A extends PageAccumulator<R>>(method: string, options: WebAPICallOptions, shouldStop: PaginatePredicate, reduce?: PageReducer<A>): Promise<A>;
     /**
-     * admin method family
-     */
-    readonly admin: {
-        apps: {
-            approve: Method<methods.AdminAppsApproveArguments>;
-            approved: {
-                list: Method<methods.AdminAppsApprovedListArguments>;
-            };
-            requests: {
-                list: Method<methods.AdminAppsRequestsListArguments>;
-            };
-            restrict: Method<methods.AdminAppsRestrictArguments>;
-            restricted: {
-                list: Method<methods.AdminAppsRestrictedListArguments>;
-            };
-        };
-        conversations: {
-            setTeams: Method<methods.AdminConversationsSetTeamsArguments>;
-        };
-        inviteRequests: {
-            approve: Method<methods.AdminInviteRequestsApproveArguments>;
-            deny: Method<methods.AdminInviteRequestsDenyArguments>;
-            list: Method<methods.AdminInviteRequestsListArguments>;
-            approved: {
-                list: Method<methods.AdminInviteRequestsApprovedListArguments>;
-            };
-            denied: {
-                list: Method<methods.AdminInviteRequestsDeniedListArguments>;
-            };
-        };
-        teams: {
-            admins: {
-                list: Method<methods.AdminTeamsAdminsListArguments>;
-            };
-            create: Method<methods.AdminTeamsCreateArguments>;
-            list: Method<methods.AdminTeamsListArguments>;
-            owners: {
-                list: Method<methods.AdminTeamsOwnersListArguments>;
-            };
-            settings: {
-                info: Method<methods.AdminTeamsSettingsInfoArguments>;
-                setDefaultChannels: Method<methods.AdminTeamsSettingsSetDefaultChannelsArguments>;
-                setDescription: Method<methods.AdminTeamsSettingsSetDescriptionArguments>;
-                setDiscoverability: Method<methods.AdminTeamsSettingsSetDiscoverabilityArguments>;
-                setIcon: Method<methods.AdminTeamsSettingseSetIconArguments>;
-                setName: Method<methods.AdminTeamsSettingsSetNameArguments>;
-            };
-        };
-        usergroups: {
-            addChannels: Method<methods.AdminUsergroupsAddChannelsArguments>;
-            listChannels: Method<methods.AdminUsergroupsListChannelsArguments>;
-            removeChannels: Method<methods.AdminUsergroupsRemoveChannelsArguments>;
-        };
-        users: {
-            session: {
-                reset: Method<methods.AdminUsersSessionResetArguments>;
-            };
-            assign: Method<methods.AdminUsersAssignArguments>;
-            invite: Method<methods.AdminUsersInviteArguments>;
-            list: Method<methods.AdminUsersListArguments>;
-            remove: Method<methods.AdminUsersRemoveArguments>;
-            setAdmin: Method<methods.AdminUsersSetAdminArguments>;
-            setExpiration: Method<methods.AdminUsersSetExpirationArguments>;
-            setOwner: Method<methods.AdminUsersSetOwnerArguments>;
-            setRegular: Method<methods.AdminUsersSetRegularArguments>;
-        };
-    };
-    /**
-     * api method family
-     */
-    readonly api: {
-        test: Method<methods.APITestArguments>;
-    };
-    /**
-     * auth method family
-     */
-    readonly auth: {
-        revoke: Method<methods.AuthRevokeArguments>;
-        test: Method<methods.AuthTestArguments>;
-    };
-    /**
-     * bots method family
-     */
-    readonly bots: {
-        info: Method<methods.BotsInfoArguments>;
-    };
-    /**
-     * calls method family
-     */
-    readonly calls: {
-        add: Method<methods.CallsAddArguments>;
-        end: Method<methods.CallsEndArguments>;
-        info: Method<methods.CallsInfoArguments>;
-        update: Method<methods.CallsUpdateArguments>;
-        participants: {
-            add: Method<methods.CallsParticipantsAddArguments>;
-        };
-    };
-    /**
-     * channels method family
-     */
-    readonly channels: {
-        archive: Method<methods.ChannelsArchiveArguments>;
-        create: Method<methods.ChannelsCreateArguments>;
-        history: Method<methods.ChannelsHistoryArguments>;
-        info: Method<methods.ChannelsInfoArguments>;
-        invite: Method<methods.ChannelsInviteArguments>;
-        join: Method<methods.ChannelsJoinArguments>;
-        kick: Method<methods.ChannelsKickArguments>;
-        leave: Method<methods.ChannelsLeaveArguments>;
-        list: Method<methods.ChannelsListArguments>;
-        mark: Method<methods.ChannelsMarkArguments>;
-        rename: Method<methods.ChannelsRenameArguments>;
-        replies: Method<methods.ChannelsRepliesArguments>;
-        setPurpose: Method<methods.ChannelsSetPurposeArguments>;
-        setTopic: Method<methods.ChannelsSetTopicArguments>;
-        unarchive: Method<methods.ChannelsUnarchiveArguments>;
-    };
-    /**
-     * chat method family
-     */
-    readonly chat: {
-        delete: Method<methods.ChatDeleteArguments>;
-        deleteScheduledMessage: Method<methods.ChatDeleteScheduledMessageArguments>;
-        getPermalink: Method<methods.ChatGetPermalinkArguments>;
-        meMessage: Method<methods.ChatMeMessageArguments>;
-        postEphemeral: Method<methods.ChatPostEphemeralArguments>;
-        postMessage: Method<methods.ChatPostMessageArguments>;
-        scheduleMessage: Method<methods.ChatScheduleMessageArguments>;
-        scheduledMessages: {
-            list: Method<methods.ChatScheduledMessagesListArguments>;
-        };
-        unfurl: Method<methods.ChatUnfurlArguments>;
-        update: Method<methods.ChatUpdateArguments>;
-    };
-    /**
-     * conversations method family
-     */
-    readonly conversations: {
-        archive: Method<methods.ConversationsArchiveArguments>;
-        close: Method<methods.ConversationsCloseArguments>;
-        create: Method<methods.ConversationsCreateArguments>;
-        history: Method<methods.ConversationsHistoryArguments>;
-        info: Method<methods.ConversationsInfoArguments>;
-        invite: Method<methods.ConversationsInviteArguments>;
-        join: Method<methods.ConversationsJoinArguments>;
-        kick: Method<methods.ConversationsKickArguments>;
-        leave: Method<methods.ConversationsLeaveArguments>;
-        list: Method<methods.ConversationsListArguments>;
-        members: Method<methods.ConversationsMembersArguments>;
-        open: Method<methods.ConversationsOpenArguments>;
-        rename: Method<methods.ConversationsRenameArguments>;
-        replies: Method<methods.ConversationsRepliesArguments>;
-        setPurpose: Method<methods.ConversationsSetPurposeArguments>;
-        setTopic: Method<methods.ConversationsSetTopicArguments>;
-        unarchive: Method<methods.ConversationsUnarchiveArguments>;
-    };
-    /**
-     * view method family
-     */
-    readonly views: {
-        open: Method<methods.ViewsOpenArguments>;
-        publish: Method<methods.ViewsPublishArguments>;
-        push: Method<methods.ViewsPushArguments>;
-        update: Method<methods.ViewsUpdateArguments>;
-    };
-    /**
-     * dialog method family
-     */
-    readonly dialog: {
-        open: Method<methods.DialogOpenArguments>;
-    };
-    /**
-     * dnd method family
-     */
-    readonly dnd: {
-        endDnd: Method<methods.DndEndDndArguments>;
-        endSnooze: Method<methods.DndEndSnoozeArguments>;
-        info: Method<methods.DndInfoArguments>;
-        setSnooze: Method<methods.DndSetSnoozeArguments>;
-        teamInfo: Method<methods.DndTeamInfoArguments>;
-    };
-    /**
-     * emoji method family
-     */
-    readonly emoji: {
-        list: Method<methods.EmojiListArguments>;
-    };
-    /**
-     * files method family
-     */
-    readonly files: {
-        delete: Method<methods.FilesDeleteArguments>;
-        info: Method<methods.FilesInfoArguments>;
-        list: Method<methods.FilesListArguments>;
-        revokePublicURL: Method<methods.FilesRevokePublicURLArguments>;
-        sharedPublicURL: Method<methods.FilesSharedPublicURLArguments>;
-        upload: Method<methods.FilesUploadArguments>;
-        comments: {
-            delete: Method<methods.FilesCommentsDeleteArguments>;
-        };
-        remote: {
-            info: Method<methods.FilesRemoteInfoArguments>;
-            list: Method<methods.FilesRemoteListArguments>;
-            add: Method<methods.FilesRemoteAddArguments>;
-            update: Method<methods.FilesRemoteUpdateArguments>;
-            remove: Method<methods.FilesRemoteRemoveArguments>;
-            share: Method<methods.FilesRemoteShareArguments>;
-        };
-    };
-    /**
-     * groups method family
-     */
-    readonly groups: {
-        archive: Method<methods.GroupsArchiveArguments>;
-        create: Method<methods.GroupsCreateArguments>;
-        createChild: Method<methods.GroupsCreateChildArguments>;
-        history: Method<methods.GroupsHistoryArguments>;
-        info: Method<methods.GroupsInfoArguments>;
-        invite: Method<methods.GroupsInviteArguments>;
-        kick: Method<methods.GroupsKickArguments>;
-        leave: Method<methods.GroupsLeaveArguments>;
-        list: Method<methods.GroupsListArguments>;
-        mark: Method<methods.GroupsMarkArguments>;
-        open: Method<methods.GroupsOpenArguments>;
-        rename: Method<methods.GroupsRenameArguments>;
-        replies: Method<methods.GroupsRepliesArguments>;
-        setPurpose: Method<methods.GroupsSetPurposeArguments>;
-        setTopic: Method<methods.GroupsSetTopicArguments>;
-        unarchive: Method<methods.GroupsUnarchiveArguments>;
-    };
-    /**
-     * im method family
-     */
-    readonly im: {
-        close: Method<methods.IMCloseArguments>;
-        history: Method<methods.IMHistoryArguments>;
-        list: Method<methods.IMListArguments>;
-        mark: Method<methods.IMMarkArguments>;
-        open: Method<methods.IMOpenArguments>;
-        replies: Method<methods.IMRepliesArguments>;
-    };
-    /**
-     * migration method family
-     */
-    readonly migration: {
-        exchange: Method<methods.MigrationExchangeArguments>;
-    };
-    /**
-     * mpim method family
-     */
-    readonly mpim: {
-        close: Method<methods.MPIMCloseArguments>;
-        history: Method<methods.MPIMHistoryArguments>;
-        list: Method<methods.MPIMListArguments>;
-        mark: Method<methods.MPIMMarkArguments>;
-        open: Method<methods.MPIMOpenArguments>;
-        replies: Method<methods.MPIMRepliesArguments>;
-    };
-    /**
-     * oauth method family
-     */
-    readonly oauth: {
-        access: Method<methods.OAuthAccessArguments>;
-        v2: {
-            access: Method<methods.OAuthV2AccessArguments>;
-        };
-    };
-    /**
-     * pins method family
-     */
-    readonly pins: {
-        add: Method<methods.PinsAddArguments>;
-        list: Method<methods.PinsListArguments>;
-        remove: Method<methods.PinsRemoveArguments>;
-    };
-    /**
-     * reactions method family
-     */
-    readonly reactions: {
-        add: Method<methods.ReactionsAddArguments>;
-        get: Method<methods.ReactionsGetArguments>;
-        list: Method<methods.ReactionsListArguments>;
-        remove: Method<methods.ReactionsRemoveArguments>;
-    };
-    /**
-     * reminders method family
-     */
-    readonly reminders: {
-        add: Method<methods.RemindersAddArguments>;
-        complete: Method<methods.RemindersCompleteArguments>;
-        delete: Method<methods.RemindersDeleteArguments>;
-        info: Method<methods.RemindersInfoArguments>;
-        list: Method<methods.RemindersListArguments>;
-    };
-    /**
-     * rtm method family
-     */
-    readonly rtm: {
-        connect: Method<methods.RTMConnectArguments>;
-        start: Method<methods.RTMStartArguments>;
-    };
-    /**
-     * search method family
-     */
-    readonly search: {
-        all: Method<methods.SearchAllArguments>;
-        files: Method<methods.SearchFilesArguments>;
-        messages: Method<methods.SearchMessagesArguments>;
-    };
-    /**
-     * stars method family
-     */
-    readonly stars: {
-        add: Method<methods.StarsAddArguments>;
-        list: Method<methods.StarsListArguments>;
-        remove: Method<methods.StarsRemoveArguments>;
-    };
-    /**
-     * team method family
-     */
-    readonly team: {
-        accessLogs: Method<methods.TeamAccessLogsArguments>;
-        billableInfo: Method<methods.TeamBillableInfoArguments>;
-        info: Method<methods.TeamInfoArguments>;
-        integrationLogs: Method<methods.TeamIntegrationLogsArguments>;
-        profile: {
-            get: Method<methods.TeamProfileGetArguments>;
-        };
-    };
-    /**
-     * usergroups method family
-     */
-    readonly usergroups: {
-        create: Method<methods.UsergroupsCreateArguments>;
-        disable: Method<methods.UsergroupsDisableArguments>;
-        enable: Method<methods.UsergroupsEnableArguments>;
-        list: Method<methods.UsergroupsListArguments>;
-        update: Method<methods.UsergroupsUpdateArguments>;
-        users: {
-            list: Method<methods.UsergroupsUsersListArguments>;
-            update: Method<methods.UsergroupsUsersUpdateArguments>;
-        };
-    };
-    /**
-     * users method family
-     */
-    readonly users: {
-        conversations: Method<methods.UsersConversationsArguments>;
-        deletePhoto: Method<methods.UsersDeletePhotoArguments>;
-        getPresence: Method<methods.UsersGetPresenceArguments>;
-        identity: Method<methods.UsersIdentityArguments>;
-        info: Method<methods.UsersInfoArguments>;
-        list: Method<methods.UsersListArguments>;
-        lookupByEmail: Method<methods.UsersLookupByEmailArguments>;
-        setPhoto: Method<methods.UsersSetPhotoArguments>;
-        setPresence: Method<methods.UsersSetPresenceArguments>;
-        profile: {
-            get: Method<methods.UsersProfileGetArguments>;
-            set: Method<methods.UsersProfileSetArguments>;
-        };
-    };
-    /**
      * Low-level function to make a single API request. handles queuing, retries, and http-level errors
@@ -455,0 +91,0 @@ */

dist/WebClient.js

 "use strict";
 /// <reference lib="esnext.asynciterable" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
@@ -25,10 +44,4 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebClientEvent = exports.WebClient = void 0;
 // polyfill for async iterable. see: https://stackoverflow.com/a/43694282/305340
@@ -42,3 +55,2 @@ // can be removed once node v10 is the minimum target (node v8 and v9 require --harmony_async_iteration flag)
 const is_stream_1 = __importDefault(require("is-stream"));
-const eventemitter3_1 = require("eventemitter3");
 const p_queue_1 = __importDefault(require("p-queue")); // tslint:disable-line:import-name
@@ -48,3 +60,3 @@ const p_retry_1 = __importStar(require("p-retry"));
 const form_data_1 = __importDefault(require("form-data")); // tslint:disable-line:import-name
-const methods = __importStar(require("./methods")); // tslint:disable-line:import-name
+const methods_1 = require("./methods");
 const instrument_1 = require("./instrument");
@@ -61,3 +73,3 @@ const errors_1 = require("./errors");
  */
-class WebClient extends eventemitter3_1.EventEmitter {
+class WebClient extends methods_1.Methods {
     /**
@@ -68,365 +80,2 @@ * @param token - An API token to authenticate/authorize with Slack (usually start with `xoxp`, `xoxb`)
         super();
-        /**
-         * admin method family
-         */
-        this.admin = {
-            apps: {
-                approve: (this.apiCall.bind(this, 'admin.apps.approve')),
-                approved: {
-                    list: (this.apiCall.bind(this, 'admin.apps.approved.list')),
-                },
-                requests: {
-                    list: (this.apiCall.bind(this, 'admin.apps.requests.list')),
-                },
-                restrict: (this.apiCall.bind(this, 'admin.apps.restrict')),
-                restricted: {
-                    list: (this.apiCall.bind(this, 'admin.apps.restricted.list')),
-                },
-            },
-            conversations: {
-                setTeams: (this.apiCall.bind(this, 'admin.conversations.setTeams')),
-            },
-            inviteRequests: {
-                approve: (this.apiCall.bind(this, 'admin.inviteRequests.approve')),
-                deny: (this.apiCall.bind(this, 'admin.inviteRequests.deny')),
-                list: (this.apiCall.bind(this, 'admin.inviteRequests.list')),
-                approved: {
-                    list: (this.apiCall.bind(this, 'admin.inviteRequests.approved.list')),
-                },
-                denied: {
-                    list: (this.apiCall.bind(this, 'admin.inviteRequests.denied.list')),
-                },
-            },
-            teams: {
-                admins: {
-                    list: (this.apiCall.bind(this, 'admin.teams.admins.list')),
-                },
-                create: (this.apiCall.bind(this, 'admin.teams.create')),
-                list: (this.apiCall.bind(this, 'admin.teams.list')),
-                owners: {
-                    list: (this.apiCall.bind(this, 'admin.teams.owners.list')),
-                },
-                settings: {
-                    info: (this.apiCall.bind(this, 'admin.teams.settings.info')),
-                    setDefaultChannels: (this.apiCall.bind(this, 'admin.teams.settings.setDefaultChannels')),
-                    setDescription: (this.apiCall.bind(this, 'admin.teams.settings.setDescription')),
-                    setDiscoverability: (this.apiCall.bind(this, 'admin.teams.settings.setDiscoverability')),
-                    setIcon: (this.apiCall.bind(this, 'admin.teams.settings.setIcon')),
-                    setName: (this.apiCall.bind(this, 'admin.teams.settings.setName')),
-                },
-            },
-            usergroups: {
-                addChannels: (this.apiCall.bind(this, 'admin.usergroups.addChannels')),
-                listChannels: (this.apiCall.bind(this, 'admin.usergroups.listChannels')),
-                removeChannels: (this.apiCall.bind(this, 'admin.usergroups.removeChannels')),
-            },
-            users: {
-                session: {
-                    reset: (this.apiCall.bind(this, 'admin.users.session.reset')),
-                },
-                assign: (this.apiCall.bind(this, 'admin.users.assign')),
-                invite: (this.apiCall.bind(this, 'admin.users.invite')),
-                list: (this.apiCall.bind(this, 'admin.users.list')),
-                remove: (this.apiCall.bind(this, 'admin.users.remove')),
-                setAdmin: (this.apiCall.bind(this, 'admin.users.setAdmin')),
-                setExpiration: (this.apiCall.bind(this, 'admin.users.setExpiration')),
-                setOwner: (this.apiCall.bind(this, 'admin.users.setOwner')),
-                setRegular: (this.apiCall.bind(this, 'admin.users.setRegular')),
-            },
-        };
-        /**
-         * api method family
-         */
-        this.api = {
-            test: (this.apiCall.bind(this, 'api.test')),
-        };
-        /**
-         * auth method family
-         */
-        this.auth = {
-            revoke: (this.apiCall.bind(this, 'auth.revoke')),
-            test: (this.apiCall.bind(this, 'auth.test')),
-        };
-        /**
-         * bots method family
-         */
-        this.bots = {
-            info: (this.apiCall.bind(this, 'bots.info')),
-        };
-        /**
-         * calls method family
-         */
-        this.calls = {
-            add: (this.apiCall.bind(this, 'calls.add')),
-            end: (this.apiCall.bind(this, 'calls.end')),
-            info: (this.apiCall.bind(this, 'calls.info')),
-            update: (this.apiCall.bind(this, 'calls.update')),
-            participants: {
-                add: (this.apiCall.bind(this, 'calls.participants.add')),
-            },
-        };
-        /**
-         * channels method family
-         */
-        this.channels = {
-            archive: (this.apiCall.bind(this, 'channels.archive')),
-            create: (this.apiCall.bind(this, 'channels.create')),
-            history: (this.apiCall.bind(this, 'channels.history')),
-            info: (this.apiCall.bind(this, 'channels.info')),
-            invite: (this.apiCall.bind(this, 'channels.invite')),
-            join: (this.apiCall.bind(this, 'channels.join')),
-            kick: (this.apiCall.bind(this, 'channels.kick')),
-            leave: (this.apiCall.bind(this, 'channels.leave')),
-            list: (this.apiCall.bind(this, 'channels.list')),
-            mark: (this.apiCall.bind(this, 'channels.mark')),
-            rename: (this.apiCall.bind(this, 'channels.rename')),
-            replies: (this.apiCall.bind(this, 'channels.replies')),
-            setPurpose: (this.apiCall.bind(this, 'channels.setPurpose')),
-            setTopic: (this.apiCall.bind(this, 'channels.setTopic')),
-            unarchive: (this.apiCall.bind(this, 'channels.unarchive')),
-        };
-        /**
-         * chat method family
-         */
-        this.chat = {
-            delete: (this.apiCall.bind(this, 'chat.delete')),
-            deleteScheduledMessage: (this.apiCall.bind(this, 'chat.deleteScheduledMessage')),
-            getPermalink: (this.apiCall.bind(this, 'chat.getPermalink')),
-            meMessage: (this.apiCall.bind(this, 'chat.meMessage')),
-            postEphemeral: (this.apiCall.bind(this, 'chat.postEphemeral')),
-            postMessage: (this.apiCall.bind(this, 'chat.postMessage')),
-            scheduleMessage: (this.apiCall.bind(this, 'chat.scheduleMessage')),
-            scheduledMessages: {
-                list: (this.apiCall.bind(this, 'chat.scheduledMessages.list')),
-            },
-            unfurl: (this.apiCall.bind(this, 'chat.unfurl')),
-            update: (this.apiCall.bind(this, 'chat.update')),
-        };
-        /**
-         * conversations method family
-         */
-        this.conversations = {
-            archive: (this.apiCall.bind(this, 'conversations.archive')),
-            close: (this.apiCall.bind(this, 'conversations.close')),
-            create: (this.apiCall.bind(this, 'conversations.create')),
-            history: (this.apiCall.bind(this, 'conversations.history')),
-            info: (this.apiCall.bind(this, 'conversations.info')),
-            invite: (this.apiCall.bind(this, 'conversations.invite')),
-            join: (this.apiCall.bind(this, 'conversations.join')),
-            kick: (this.apiCall.bind(this, 'conversations.kick')),
-            leave: (this.apiCall.bind(this, 'conversations.leave')),
-            list: (this.apiCall.bind(this, 'conversations.list')),
-            members: (this.apiCall.bind(this, 'conversations.members')),
-            open: (this.apiCall.bind(this, 'conversations.open')),
-            rename: (this.apiCall.bind(this, 'conversations.rename')),
-            replies: (this.apiCall.bind(this, 'conversations.replies')),
-            setPurpose: (this.apiCall.bind(this, 'conversations.setPurpose')),
-            setTopic: (this.apiCall.bind(this, 'conversations.setTopic')),
-            unarchive: (this.apiCall.bind(this, 'conversations.unarchive')),
-        };
-        /**
-         * view method family
-         */
-        this.views = {
-            open: (this.apiCall.bind(this, 'views.open')),
-            publish: (this.apiCall.bind(this, 'views.publish')),
-            push: (this.apiCall.bind(this, 'views.push')),
-            update: (this.apiCall.bind(this, 'views.update')),
-        };
-        /**
-         * dialog method family
-         */
-        this.dialog = {
-            open: (this.apiCall.bind(this, 'dialog.open')),
-        };
-        /**
-         * dnd method family
-         */
-        this.dnd = {
-            endDnd: (this.apiCall.bind(this, 'dnd.endDnd')),
-            endSnooze: (this.apiCall.bind(this, 'dnd.endSnooze')),
-            info: (this.apiCall.bind(this, 'dnd.info')),
-            setSnooze: (this.apiCall.bind(this, 'dnd.setSnooze')),
-            teamInfo: (this.apiCall.bind(this, 'dnd.teamInfo')),
-        };
-        /**
-         * emoji method family
-         */
-        this.emoji = {
-            list: (this.apiCall.bind(this, 'emoji.list')),
-        };
-        /**
-         * files method family
-         */
-        this.files = {
-            delete: (this.apiCall.bind(this, 'files.delete')),
-            info: (this.apiCall.bind(this, 'files.info')),
-            list: (this.apiCall.bind(this, 'files.list')),
-            revokePublicURL: (this.apiCall.bind(this, 'files.revokePublicURL')),
-            sharedPublicURL: (this.apiCall.bind(this, 'files.sharedPublicURL')),
-            upload: (this.apiCall.bind(this, 'files.upload')),
-            comments: {
-                delete: (this.apiCall.bind(this, 'files.comments.delete')),
-            },
-            remote: {
-                info: (this.apiCall.bind(this, 'files.remote.info')),
-                list: (this.apiCall.bind(this, 'files.remote.list')),
-                add: (this.apiCall.bind(this, 'files.remote.add')),
-                update: (this.apiCall.bind(this, 'files.remote.update')),
-                remove: (this.apiCall.bind(this, 'files.remote.remove')),
-                share: (this.apiCall.bind(this, 'files.remote.share')),
-            },
-        };
-        /**
-         * groups method family
-         */
-        this.groups = {
-            archive: (this.apiCall.bind(this, 'groups.archive')),
-            create: (this.apiCall.bind(this, 'groups.create')),
-            createChild: (this.apiCall.bind(this, 'groups.createChild')),
-            history: (this.apiCall.bind(this, 'groups.history')),
-            info: (this.apiCall.bind(this, 'groups.info')),
-            invite: (this.apiCall.bind(this, 'groups.invite')),
-            kick: (this.apiCall.bind(this, 'groups.kick')),
-            leave: (this.apiCall.bind(this, 'groups.leave')),
-            list: (this.apiCall.bind(this, 'groups.list')),
-            mark: (this.apiCall.bind(this, 'groups.mark')),
-            open: (this.apiCall.bind(this, 'groups.open')),
-            rename: (this.apiCall.bind(this, 'groups.rename')),
-            replies: (this.apiCall.bind(this, 'groups.replies')),
-            setPurpose: (this.apiCall.bind(this, 'groups.setPurpose')),
-            setTopic: (this.apiCall.bind(this, 'groups.setTopic')),
-            unarchive: (this.apiCall.bind(this, 'groups.unarchive')),
-        };
-        /**
-         * im method family
-         */
-        this.im = {
-            close: (this.apiCall.bind(this, 'im.close')),
-            history: (this.apiCall.bind(this, 'im.history')),
-            list: (this.apiCall.bind(this, 'im.list')),
-            mark: (this.apiCall.bind(this, 'im.mark')),
-            open: (this.apiCall.bind(this, 'im.open')),
-            replies: (this.apiCall.bind(this, 'im.replies')),
-        };
-        /**
-         * migration method family
-         */
-        this.migration = {
-            exchange: (this.apiCall.bind(this, 'migration.exchange')),
-        };
-        /**
-         * mpim method family
-         */
-        this.mpim = {
-            close: (this.apiCall.bind(this, 'mpim.close')),
-            history: (this.apiCall.bind(this, 'mpim.history')),
-            list: (this.apiCall.bind(this, 'mpim.list')),
-            mark: (this.apiCall.bind(this, 'mpim.mark')),
-            open: (this.apiCall.bind(this, 'mpim.open')),
-            replies: (this.apiCall.bind(this, 'mpim.replies')),
-        };
-        /**
-         * oauth method family
-         */
-        this.oauth = {
-            access: (this.apiCall.bind(this, 'oauth.access')),
-            v2: {
-                access: (this.apiCall.bind(this, 'oauth.v2.access')),
-            },
-        };
-        /**
-         * pins method family
-         */
-        this.pins = {
-            add: (this.apiCall.bind(this, 'pins.add')),
-            list: (this.apiCall.bind(this, 'pins.list')),
-            remove: (this.apiCall.bind(this, 'pins.remove')),
-        };
-        /**
-         * reactions method family
-         */
-        this.reactions = {
-            add: (this.apiCall.bind(this, 'reactions.add')),
-            get: (this.apiCall.bind(this, 'reactions.get')),
-            list: (this.apiCall.bind(this, 'reactions.list')),
-            remove: (this.apiCall.bind(this, 'reactions.remove')),
-        };
-        /**
-         * reminders method family
-         */
-        this.reminders = {
-            add: (this.apiCall.bind(this, 'reminders.add')),
-            complete: (this.apiCall.bind(this, 'reminders.complete')),
-            delete: (this.apiCall.bind(this, 'reminders.delete')),
-            info: (this.apiCall.bind(this, 'reminders.info')),
-            list: (this.apiCall.bind(this, 'reminders.list')),
-        };
-        /**
-         * rtm method family
-         */
-        this.rtm = {
-            connect: (this.apiCall.bind(this, 'rtm.connect')),
-            start: (this.apiCall.bind(this, 'rtm.start')),
-        };
-        /**
-         * search method family
-         */
-        this.search = {
-            all: (this.apiCall.bind(this, 'search.all')),
-            files: (this.apiCall.bind(this, 'search.files')),
-            messages: (this.apiCall.bind(this, 'search.messages')),
-        };
-        /**
-         * stars method family
-         */
-        this.stars = {
-            add: (this.apiCall.bind(this, 'stars.add')),
-            list: (this.apiCall.bind(this, 'stars.list')),
-            remove: (this.apiCall.bind(this, 'stars.remove')),
-        };
-        /**
-         * team method family
-         */
-        this.team = {
-            accessLogs: (this.apiCall.bind(this, 'team.accessLogs')),
-            billableInfo: (this.apiCall.bind(this, 'team.billableInfo')),
-            info: (this.apiCall.bind(this, 'team.info')),
-            integrationLogs: (this.apiCall.bind(this, 'team.integrationLogs')),
-            profile: {
-                get: (this.apiCall.bind(this, 'team.profile.get')),
-            },
-        };
-        /**
-         * usergroups method family
-         */
-        this.usergroups = {
-            create: (this.apiCall.bind(this, 'usergroups.create')),
-            disable: (this.apiCall.bind(this, 'usergroups.disable')),
-            enable: (this.apiCall.bind(this, 'usergroups.enable')),
-            list: (this.apiCall.bind(this, 'usergroups.list')),
-            update: (this.apiCall.bind(this, 'usergroups.update')),
-            users: {
-                list: (this.apiCall.bind(this, 'usergroups.users.list')),
-                update: (this.apiCall.bind(this, 'usergroups.users.update')),
-            },
-        };
-        /**
-         * users method family
-         */
-        this.users = {
-            conversations: (this.apiCall.bind(this, 'users.conversations')),
-            deletePhoto: (this.apiCall.bind(this, 'users.deletePhoto')),
-            getPresence: (this.apiCall.bind(this, 'users.getPresence')),
-            identity: (this.apiCall.bind(this, 'users.identity')),
-            info: (this.apiCall.bind(this, 'users.info')),
-            list: (this.apiCall.bind(this, 'users.list')),
-            lookupByEmail: (this.apiCall.bind(this, 'users.lookupByEmail')),
-            setPhoto: (this.apiCall.bind(this, 'users.setPhoto')),
-            setPresence: (this.apiCall.bind(this, 'users.setPresence')),
-            profile: {
-                get: (this.apiCall.bind(this, 'users.profile.get')),
-                set: (this.apiCall.bind(this, 'users.profile.set')),
-            },
-        };
         this.token = token;
@@ -513,3 +162,3 @@ this.slackApiUrl = slackApiUrl;
     paginate(method, options, shouldStop, reduce) {
-        if (!methods.cursorPaginationEnabledMethods.has(method)) {
+        if (!methods_1.cursorPaginationEnabledMethods.has(method)) {
             this.logger.warn(`paginate() called with method ${method}, which is not known to be cursor pagination enabled.`);
@@ -792,3 +441,8 @@ }
 function warnDeprecations(method, logger) {
-    const deprecatedMethods = ['channels.', 'groups.', 'im.', 'mpim.'];
+    const deprecatedConversationsMethods = ['channels.', 'groups.', 'im.', 'mpim.'];
+    const deprecatedMethods = ['admin.conversations.whitelist.'];
+    const isDeprecatedConversations = deprecatedConversationsMethods.some((depMethod) => {
+        const re = new RegExp(`^${depMethod}`);
+        return re.test(method);
+    });
     const isDeprecated = deprecatedMethods.some((depMethod) => {
@@ -798,6 +452,9 @@ const re = new RegExp(`^${depMethod}`);
     });
-    if (isDeprecated) {
+    if (isDeprecatedConversations) {
         logger.warn(`${method} is deprecated. Please use the Conversations API instead. For more info, go to https://api.slack.com/changelog/2020-01-deprecating-antecedents-to-the-conversations-api`);
     }
+    else if (isDeprecated) {
+        logger.warn(`${method} is deprecated. Please check on https://api.slack.com/methods for an alternative.`);
+    }
 }
 //# sourceMappingURL=WebClient.js.map

package.json

 {
   "name": "@slack/web-api",
-  "version": "5.10.0",
+  "version": "5.11.0",
   "description": "Official library for using the Slack Platform's Web API",
@@ -5,0 +5,0 @@ "author": "Slack Technologies, Inc.",

New alerts

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

185242

increased by0.63%

Worsened metrics

Lines of code

2455

decreased by-0.97%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes