()

()

()

(url: string)

( text: string, callbackUrl: string, callbackFn: (callbackUrl: string) => void = defaultCallback )

(community: string)

(event: React.DragEvent)

()

(event: KeyboardEvent)

(mode: SignInMode)

(target: { id: string; value: string })

(communityId: string, redirectTo: string)

( response: LLMPredictionResponse, { account, communityName }: { account: accounts; communityName: string

(channel: TextChannel)

(data: any)

( message: Pick<Message, 'content' | 'attachments' | 'id'> )

( channel: channels, message: DiscordMessage, users: users[], threadId?: string )

(text: string)

( searchSettings: SerializedSearchSettings, accountId: string )

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

(value, language)

(message, allUsers)

(body: SlackEvent)

( event: SlackMessageReactionAddedEvent | SlackMessageReactionRemovedEvent, teamId: string, logger: Logg

({ messagesChunk, channel, logger, }: { channel: channels; messagesChunk: DiscordMessage[]; logger

( userId: string, logger: Logger, searchSettings: SerializedSearchSettings, account: accounts, query

( m: ConversationHistoryMessage, message: messages )

({ thread, onboardingTimestamp, channel, token, logger, }: { thread: DiscordThread; onboardingTi

(communityId: string)

({ channelId, threadId, messageId, imitationId, isThread, isReply, message, thread, }: PushTyp

({ channelId, threadId, messageId, imitationId, isThread, isReply, message, thread, userId,

({ userId, threadId, channelId, mentionType, }: { userId: string; threadId: string; channelId: s

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

(site: string)

()

({ account, communityName, settings, channelName, channel, }: { account: SerializedAccount; comm

(req: any, res: any)

()

( channels: SerializedChannel[], from: string, to: string | null )

({ channel, userId, event, communityId, }: { channel: { id: string; memberships: { arc

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

()

({ channel, token, usersInDb, fetchReplies, logger, }: { channel: channels; token: string; use

(threadId: string)

(threadId: string, scroll: boolean = true)

({ to, text, html, ...props }: Options & TemplateType & { text: Function; html: Function })

(m: integrationMatrix)

(status: any)

({ accountId }: { accountId: string })

( event: React.MouseEvent<HTMLAnchorElement>, flow: 'signin' | 'signup' )

( email: string, password: string, csrfToken: string, sso?: string )

( email: string, csrfToken: string, options: { callbackUrl?: string; displayName?: string; s

(tokens, pattern)

(store: storeType)

(store: storeType)

(store: storeType)

(store: storeType)

(store: storeType)

({ account, token, accountId, channelId, getSlackChannels, joinChannel, shouldJoinChannel, ful

({ account, decodeBotToken, fullSync, logger, }: { account: accounts & { discordAuthorizations:

({ accountId, token, account, fullSync, listUsers, logger, }: { accountId: string; token: stri

({ account, domain, accountId, channelId, fullSync, fetchTeamInfo, joinChannel, getSlackChanne

({ accountId }: { accountId: string })

(name: string)

(input)

( context: GetServerSidePropsContext, isSubdomainbasedRouting: boolean )

({ channelId }: { channelId: string })

( array1: { [key: string]: any }[], array2: { [key: string]: any }[], param: string )

({ collection, filter_by, document, }: { collection: string; filter_by: string; document: object;

({ inviteId, role, accountId, }: { inviteId: string; role: Roles; accountId: string; })

(id: string, title: string)

( threadId: string, lastMessage: { sentAt: Date; author: users | null }, field: 'firstManagerReplyAt' |

( account: accounts, document: object )

({ attach, accountId, channelId, name, ext, }: { attach: DiscordAttachments; accountId: string |

(files: File[])

(files: File[])

( message: { body: string; sentAt: string; externalMessageId: string; threadId?: string;

({ isAdmin = false, isBot = false, anonymousAlias = generateRandomWordSlug(), ...user }: {

( fn: T, deps: DependencyList = [], initialState: StateFromFunctionReturningPromise<T> = { loading: fals

()

()

(id = v4(), userId = v4())

(name = 'linen.message')

({ githubSignIn, loginPassport, magicLink, magicLinkStrategy, prefix, onCredentialsLogin, onMagi

({ status }: WrapperProps)

({ threads, setThreads, currentCommunity, api, currentChannel, allUsers, }: { threads: Serialize

({ authorize, getOrCreateAuthWithEmail, secret, sendEmail, authServerUrl, githubClientID, github

({ Row }: { Row: (...args: any) => JSX.Element })

( community: accounts | null, account: accounts | null )

( community: accounts | null, user: users | null )

(community: accounts | null, user: users | null)

(community: accounts | null, user: users | null)

( community: accounts | null, account: accounts | null, user: users | null )

(channelName: string)

( community: accounts | null, account: accounts | null, user: users | null )

(community: accounts | null, user: users | null)

(invite: Invite)

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

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

( thread: SerializedThread, { threadId, messageId, currentUser, type, active, }: {