Client

import { Client } from '@cloak-software/bot-sdk';

const client = new Client({
  token: process.env.CLOAK_TOKEN!,
  keystorePath: './bot.cloak-keystore.json',
  requiredPermissions: ['message_send', 'reaction_add'],
});

client.on('messageCreate', async (msg) => {
  if (msg.authorId === client.user?.id) return;
  if (msg.isDM || !msg.serverId) return;
  if (msg.content.trim() === '!ping') await msg.channel.send('pong');
});

await client.login();

login(): Promise<void>

watch(serverId: string, channelId: string, groupId?: string): Promise<void>

destroy(): Promise<void>

send(serverId: string, channelId: string, text: string, opts?: SendOptions): Promise<void>
send(serverId: string, channelId: string, text: string, opts: SendOptions & { ack: true }): Promise<Message>

import { userMention } from '@cloak-software/bot-sdk';

await client.send(serverId, channelId, `${userMention(msg.authorId)} on it`, {
  mentions: [{ userId: msg.authorId }],
  replyTo: msg,
});

sendDM(userId: string, text: string, opts?: SendOptions): Promise<void>
sendDM(userId: string, text: string, opts: SendOptions & { ack: true }): Promise<Message>

sendCardDM(userId: string, card: CardMessage): Promise<void>
sendCardDM(userId: string, card: CardMessage & { ack: true }): Promise<Message>

sendCard(serverId: string, channelId: string, card: CardMessage): Promise<void>
sendCard(serverId: string, channelId: string, card: CardMessage & { ack: true }): Promise<Message>

editCard(
  serverId: string | null,
  channelId: string,
  messageId: string,
  card: CardEdit,
  opts: { createdAt: Date; pinned?: boolean; groupId?: string; threadId?: string; postId?: string },
): Promise<void>

sendEmbed(serverId: string, channelId: string, post: UnencryptedWebhookPost): Promise<void>

sendCommand(
  serverId: string,
  channelId: string,
  name: string,
  args?: CommandArgs,
  opts?: { botId: string; decl?: CommandDeclaration; groupId?: string; ack?: boolean; ackTimeoutMs?: number },
): Promise<void | Message>

sendTyping(serverId: string, channelId: string, isTyping?: boolean, target?: string | TypingTarget): Promise<void>

fetchMessage(serverId: string | null, channelId: string, messageId: string, opts?: { signal?: AbortSignal }): Promise<Message>

resolveContainer(serverId: string, childId: string, opts?: { signal?: AbortSignal }): Promise<{ kind: 'thread' | 'post'; parentChannelId: string } | null>

capabilities(): BotCapabilities | null

readonly resumedLastLogin: boolean

sendTypingDM(userId: string, isTyping?: boolean): Promise<void>

setStatus(status: BotStatus): Promise<void>

setAvatar(iconUrl: string | null, miniIconUrl?: string | null): Promise<void>

fetchMessages(
  serverId: string | null,
  channelId: string,
  opts?: {
    before?: Date | Message;
    after?: Date | Message;
    around?: Date | Message;
    limit?: number;
    groupId?: string;
    threadId?: string;
    postId?: string;
    signal?: AbortSignal;
  },
): Promise<Message[]>

// Recover a thread's backlog after a restart.
const backlog = await client.fetchMessages(serverId, parentChannelId, {
  threadId,
  limit: 200,
});

fetchDmMessages(
  userId: string,
  opts?: {
    before?: Date | Message;
    after?: Date | Message;
    around?: Date | Message;
    limit?: number;
    signal?: AbortSignal;
  },
): Promise<Message[]>

messageLocation(messageId: string): MessageLocation | undefined

fetchEmojis(): Promise<{ emojis: unknown; category: unknown }>

fetchRoles(serverId: string): Promise<Role[]>

fetchBans(serverId: string): Promise<BanInfo[]>

fetchMembers(serverId: string): Promise<Member[]>

searchMembers(
  serverId: string,
  query: string,
  opts?: { channelId?: string; limit?: number; signal?: AbortSignal },
): Promise<MemberSearchResult[]>

sendFile(serverId: string, channelId: string, file: FileInput, opts?: SendFileOptions): Promise<void>
sendFile(serverId: string, channelId: string, file: FileInput, opts: SendFileOptions & { ack: true }): Promise<Message>

sendFiles(serverId: string, channelId: string, files: FileInput[], opts?: SendFileOptions): Promise<void>
sendFiles(serverId: string, channelId: string, files: FileInput[], opts: SendFileOptions & { ack: true }): Promise<Message>

sendFileDM(userId: string, file: FileInput, opts?: SendFileOptions): Promise<void>
sendFileDM(userId: string, file: FileInput, opts: SendFileOptions & { ack: true }): Promise<Message>

sendFilesDM(userId: string, files: FileInput[], opts?: SendFileOptions): Promise<void>
sendFilesDM(userId: string, files: FileInput[], opts: SendFileOptions & { ack: true }): Promise<Message>

downloadAttachment(fileId: string, serverId?: string | null, opts?: { signal?: AbortSignal }): Promise<{ bytes: Buffer }>

createThread(
  serverId: string,
  channelId: string,
  opts: {
    title: string;
    starter?: Pick<Message, 'messageId' | 'authorId' | 'createdAt'>;
    isPrivate?: boolean;
    autoArchiveMinutes?: number;
  },
): Promise<{ threadId: string }>

fetchThreads(
  serverId: string,
  channelId: string,
  opts?: {
    sort?: 'activity' | 'created';
    includeArchived?: boolean;
    onlyMine?: boolean;
    onlyJoined?: boolean;
    before?: Date | number;
    limit?: number;
  },
): Promise<{ threads: ThreadInfo[]; hasMore: boolean }>

joinThread(serverId: string, channelId: string, threadId: string): Promise<void>

leaveThread(serverId: string, channelId: string, threadId: string): Promise<void>

fetchThreadMembers(serverId: string, channelId: string, threadId: string): Promise<ThreadMember[]>

threadParent(threadId: string): string | undefined

createForumPost(
  serverId: string,
  forumChannelId: string,
  opts: {
    title: string;
    content: string;
    tagIds?: number[];
    embed?: BotEmbed;
    components?: ActionRow[];
    mentions?: MentionTarget[];
  },
): Promise<ForumPost>

fetchForumPosts(
  serverId: string,
  forumChannelId: string,
  opts?: {
    sort?: 'activity' | 'created';
    tag?: number;
    includeArchived?: boolean;
    solved?: boolean;
    onlyMine?: boolean;
    onlyFollowing?: boolean;
    before?: Date | number;
    limit?: number;
    signal?: AbortSignal;
  },
): Promise<{ posts: ForumPost[]; hasMore: boolean }>

fetchForumMeta(serverId: string, forumChannelId: string): Promise<ForumMeta>

editForumPost(
  serverId: string,
  forumChannelId: string,
  postId: string,
  changes: { title?: string; tagIds?: number[] },
): Promise<void>

setForumPostState(
  serverId: string,
  forumChannelId: string,
  postId: string,
  field: 'archived' | 'locked' | 'pinned' | 'answered' | 'move',
  value: boolean | string | Pick<Message, 'messageId' | 'authorId' | 'createdAt'> | null,
): Promise<void>

followForumPost(serverId: string, forumChannelId: string, postId: string, on: boolean): Promise<void>

reactToStarter(
  serverId: string,
  forumChannelId: string,
  postId: string,
  reactionId: string,
  add?: boolean,
): Promise<void>

postParent(postId: string): string | undefined

closePoll(
  serverId: string,
  channelId: string,
  messageId: string,
  opts?: { groupId?: string; threadId?: string; postId?: string },
): Promise<void>

fetchPollState(
  serverId: string,
  channelId: string,
  messageId: string,
  opts?: { groupId?: string; threadId?: string; postId?: string },
): Promise<PollStateSnapshot>

fetchPollVoters(
  serverId: string,
  channelId: string,
  messageId: string,
  optionIndex: number,
  opts?: { groupId?: string; threadId?: string; postId?: string },
): Promise<string[]>

kick(serverId: string, userId: string): Promise<void>

ban(serverId: string, userId: string, reason?: string): Promise<void>

unban(serverId: string, userId: string): Promise<void>

timeout(serverId: string, userId: string, durationSeconds: number): Promise<void>

removeTimeout(serverId: string, userId: string): Promise<void>

fetchChannels(serverId: string): Promise<ChannelInfo[]>

import { ChannelType } from '@cloak-software/bot-sdk';

const channels = await client.fetchChannels(serverId);
const voice = channels.filter((c) => c.type === ChannelType.VOICE);
const general = channels.find((c) => c.name === 'general');

getChannel(serverId: string, channelId: string): ChannelInfo | undefined

createChannel(serverId: string, name: string, groupId: string, channelType?: number): Promise<string>

editChannel(serverId: string, channelId: string, groupId: string, newName: string): Promise<void>

deleteChannel(serverId: string, channelId: string, groupId: string): Promise<void>

moveChannel(
  serverId: string,
  channelId: string,
  fromGroupId: string,
  toGroupId: string,
  newOrder: number,
): Promise<void>

createGroup(serverId: string, name: string): Promise<string | undefined>

editGroup(serverId: string, groupId: string, newName: string): Promise<void>

deleteGroup(serverId: string, groupId: string): Promise<void>

joinVoice(
  serverId: string,
  channelId: string,
  opts?: { groupId?: string; muted?: boolean; deafened?: boolean },
): Promise<VoiceConnection>

leaveVoice(): Promise<void>

voiceConnection(): VoiceConnection | null

voiceConnectionReporter(): (state: 0 | 1) => void

setVoiceSelfState(state: { muted?: boolean; deafened?: boolean }): Promise<void>

voiceRoster(channelId: string): VoiceParticipant[]

refreshVoiceRoster(serverId: string): Promise<void>

can(permission: PermissionName, serverId: string): boolean

permissions(serverId: string): PermissionSet | undefined

visibleChannelIds(serverId: string): string[]

encryptFor(serverId: string, text: string): string

decryptFrom(serverId: string, wire: string): string

client.on('messageCreate', (msg) => {
  // msg is typed as Message
});

guild(serverId: string)

if (msg.isDM || !msg.serverId) return; // serverId is null in a DM

const g = client.guild(msg.serverId);
await g.timeout(msg.authorId, 300);
const roles = await g.fetchRoles();
const history = await g.fetchMessages(msg.channelId, { limit: 100 });