({ keyWithSearchPermissions, accountId, userId, }: { keyWithSearchPermissions: string; accountId: st

(payload: SlackEvent)

()

({ token }: { token: string })

( req: AuthedRequestWithBody<messageDeleteType>, res: Response, next: NextFunction )

( Objects: { Key: string; }[] )

({ channelId, externalMessageId, accountId, }: { channelId: string; externalMessageId: string; acc

( channel: channels & { account: (accounts & { slackAuthorizations: slackAuthorizations[] }) | null; }

({ team_id, ts = generateRandomDate(), channel_id, }: { team_id: string; ts: string; channel_id: s

(chat: ChatType)

(type: AccountType)

(communityId: string)

({ id, body }: { id: string; body: string })

({ url }: { url: string })

(message: any, options?: Options)

()

({ channelId, accountId, channelName, }: { channelId: string; accountId: string; channelName: stri

({ messageId, threadId, attachments, accountId, }: { messageId: string; threadId: string | null;

({ email, id, slackDomain, }: { email: string; id: string; slackDomain?: string; })

(event: any)

(event: NewMessageEvent)

({ channelId, threadId, accountId, }: ThreadClosedEvent)

({ channelId, threadId, accountId, }: ThreadReopenedEvent)

({ channelId, messageId, threadId, imitationId, thread, }: ThreadUpdatedEvent)

(tokens)

()

({ price }: { price: string })

(bot: Client<boolean>)

( channel: string, token: string, cursor: string | null = null, // Example "dXNlcjpVMDYxTkZUVDI=" olde

(fileUrl: string, token: string)

( file: File )

( threadTs: string, channel: string, token: string )

()

(token: string)

({ linearClient, accessToken, }: { linearClient?: LinearClient; accessToken?: string; })

({ accessToken, userId, }: { accessToken: string; userId: string; })

(message: DiscordMessage)

(message: Message)

(message: T)

(channel: Channel)

({ channelId, externalMessageId, threadId, mustHave, orderBy, sortBy, }: messageFind

(id: string)

(slackTeamId: string)

(email: string)

()

(request: Request, response: Response)

(externalChannelId: string)

(externalId: string)

(id: string)

(emails: string[])

({ externalId, accountId, }: { externalId: string; accountId: string; })

(id: string)

(params: any)

(channels: SerializedChannel[])

(accountId: string)

({ accountId, userId, }: { accountId: string; userId: string; })

(tree)

({ channelId, externalMessageId, }: { channelId: string; externalMessageId: string; })

({ channelId, ts, }: { channelId: string; ts: string; })

(communityId: string, email: string)

({ accountId, userId, dmWithUserId, }: { accountId: string; userId: string; dmWithUs

()

()

(accountId: string)

(id: string)

(threadId: string)

({ channelId, cursor, limit = 10, }: { channelId: string; cursor?: number; limit?: number; })

( req: AuthedRequestWithTenantAndBody<findTopicsSchema>, res: Response, next: NextFunction )

( auth: | (auths & { users: (users & { account: accounts; })[]; }) |

(search: LinenTypes.userGetType)

(id: string)

( accountId: string )

( communityId: string )

(brandColor: string)

(date: string)

(code: string)

(t, e)

(password: string, salt: string)

()

(req: NextApiRequest, res: NextApiResponse)

(request: NextApiRequest, response: NextApiResponse)

(account: accounts)

(logger: Logger)

({ serverId, token, onboardingTimestamp, logger, }: { serverId: string; token: string; onboardin

({ token, serverId, }: { serverId: string; token: string; })

()

({ authId }: { authId: string })

(req: any)

({ externalChannelId, before, token, limit, }: { externalChannelId: string; token: s

({ channel, token, onboardingTimestamp, logger, }: { channel: channels; token: string; onboardin

( context: GetServerSidePropsContext, isSubDomainRouting: boolean )

( search: LinenTypes.channelGetIntegrationType )

({ channelId, type, }: { channelId: string; type: channelsIntegrationType; })

( context: GetServerSidePropsContext, isSubDomainRouting: boolean )

(delay: FadeDelay)

(direction: FadeDirection)

()

()

( account: Pick< accounts, | 'premium' | 'redirectDomain' | 'slackTeamId' | 'slackDomain

(community: SerializedAccount)