@slack/web-api
Advanced tools
Comparing version 5.9.0 to 5.10.0-workflow-steps-beta.1
/// <reference types="node" /> | ||
import { Stream } from 'stream'; | ||
import { Dialog, View, KnownBlock, Block, MessageAttachment, LinkUnfurls } from '@slack/types'; | ||
import { WebAPICallOptions, WebAPICallResult } from './WebClient'; | ||
import { Dialog, View, KnownBlock, Block, MessageAttachment, LinkUnfurls, CallUser } from '@slack/types'; | ||
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>; | ||
}; | ||
}; | ||
readonly workflows: { | ||
stepCompleted: Method<WorkflowsStepCompletedArguments, WebAPICallResult>; | ||
stepFailed: Method<WorkflowsStepFailedArguments, WebAPICallResult>; | ||
updateStep: Method<WorkflowsUpdateStepArguments, 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 +362,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 +439,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 { | ||
@@ -190,2 +513,33 @@ usergroup_id: string; | ||
} | ||
export interface CallsAddArguments extends WebAPICallOptions, TokenOverridable { | ||
external_unique_id: string; | ||
join_url: string; | ||
created_by?: string; | ||
date_start?: number; | ||
desktop_app_join_url?: string; | ||
external_display_id?: string; | ||
title?: string; | ||
users?: CallUser[]; | ||
} | ||
export interface CallsEndArguments extends WebAPICallOptions, TokenOverridable { | ||
id: string; | ||
duration?: number; | ||
} | ||
export interface CallsInfoArguments extends WebAPICallOptions, TokenOverridable { | ||
id: string; | ||
} | ||
export interface CallsUpdateArguments extends WebAPICallOptions, TokenOverridable { | ||
id: string; | ||
join_url?: string; | ||
desktop_app_join_url?: string; | ||
title?: string; | ||
} | ||
export interface CallsParticipantsAddArguments extends WebAPICallOptions, TokenOverridable { | ||
id: string; | ||
users: CallUser[]; | ||
} | ||
export interface CallsParticipantsRemoveArguments extends WebAPICallOptions, TokenOverridable { | ||
id: string; | ||
users: CallUser[]; | ||
} | ||
export interface ChannelsArchiveArguments extends WebAPICallOptions, TokenOverridable { | ||
@@ -365,2 +719,6 @@ channel: string; | ||
} | ||
export interface ConversationsMarkArguments extends WebAPICallOptions, TokenOverridable { | ||
channel: string; | ||
ts: string; | ||
} | ||
export interface ConversationsMembersArguments extends WebAPICallOptions, TokenOverridable, CursorPaginationEnabled { | ||
@@ -807,3 +1165,22 @@ channel: string; | ||
} | ||
export interface WorkflowsStepCompletedArguments extends WebAPICallOptions, TokenOverridable { | ||
workflow_step_execute_id: string; | ||
outputs?: object; | ||
} | ||
export interface WorkflowsStepFailedArguments extends WebAPICallOptions, TokenOverridable { | ||
workflow_step_execute_id: string; | ||
error: { | ||
message: string; | ||
}; | ||
} | ||
export interface WorkflowsUpdateStepArguments extends WebAPICallOptions, TokenOverridable { | ||
workflow_step_edit_id: string; | ||
inputs?: object; | ||
outputs?: { | ||
type: string; | ||
name: string; | ||
label: string; | ||
}[]; | ||
} | ||
export * from '@slack/types'; | ||
//# sourceMappingURL=methods.d.ts.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
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'), | ||
}, | ||
}; | ||
this.workflows = { | ||
stepCompleted: bindApiCall(this, 'workflows.stepCompleted'), | ||
stepFailed: bindApiCall(this, 'workflows.stepFailed'), | ||
updateStep: bindApiCall(this, 'workflows.updateStep'), | ||
}; | ||
// 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 | ||
@@ -4,0 +330,0 @@ // interface, so that methods are checked against this set when using the pagination helper. If the method name is not |
@@ -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,357 +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>; | ||
}; | ||
/** | ||
* 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 | ||
@@ -443,0 +91,0 @@ */ |
@@ -41,3 +41,2 @@ "use strict"; | ||
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 | ||
@@ -47,3 +46,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"); | ||
@@ -60,3 +59,3 @@ const errors_1 = require("./errors"); | ||
*/ | ||
class WebClient extends eventemitter3_1.EventEmitter { | ||
class WebClient extends methods_1.Methods { | ||
/** | ||
@@ -67,353 +66,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')), | ||
}; | ||
/** | ||
* 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; | ||
@@ -500,3 +148,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.`); | ||
@@ -779,3 +427,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) => { | ||
@@ -785,6 +438,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 |
{ | ||
"name": "@slack/web-api", | ||
"version": "5.9.0", | ||
"version": "5.10.0-workflow-steps-beta.1", | ||
"description": "Official library for using the Slack Platform's Web API", | ||
@@ -45,3 +45,3 @@ "author": "Slack Technologies, Inc.", | ||
"@slack/logger": ">=1.0.0 <3.0.0", | ||
"@slack/types": "^1.2.1", | ||
"@slack/types": "^1.7.0", | ||
"@types/is-stream": "^1.1.0", | ||
@@ -48,0 +48,0 @@ "@types/node": ">=8.9.0", |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Deprecated
MaintenanceThe maintainer of the package marked it as deprecated. This could indicate that a single version should not be used, or that the package is no longer maintained and any new vulnerabilities will not be fixed.
Found 1 instance in 1 package
No v1
QualityPackage is not semver >=1. This means it is not stable and does not support ^ ranges.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
183839
2435
1
1
Updated@slack/types@^1.7.0