Channels

import type { Channel } from 'chapterjs';

async function announce(channel: Channel, text: string) {
  if (!channel.isTextBased()) return; // a category or a forum: no messages there
  await channel.send(text);

  if (channel.isThread() && channel.archived) await channel.unarchive();
}

isTextBased(): this is TextBasedChannel

isGuildChannel(): this is GuildChannel

isText(): this is TextChannel

isVoice(): this is VoiceChannel

isCategory(): this is CategoryChannel

isForum(): this is ForumChannel

isThread(): this is ThreadChannel

isDM(): this is DMChannel

toString(): string

toJSON(): object

fetch(): Promise<Channel>

delete(reason?: string): Promise<void>

import type { TextChannel } from 'chapterjs';

async function lock(channel: TextChannel) {
  const everyone = channel.guild.everyoneRole;
  // Nobody can write any more, but everyone still reads.
  await channel.setPermissions(everyone, { deny: ['SendMessages'] }, 'Channel locked');
}

permissionsFor(member: GuildMember): Permissions

fetchInvites(): Promise<Invite[]>

fetchWebhooks(): Promise<Webhook[]>

edit(options: GuildChannelEditOptions, reason?: string): Promise<this>

setPermissions(
  target: Role | GuildMember | User,
  permissions: { allow?: PermissionResolvable; deny?: PermissionResolvable },
  reason?: string
): Promise<void>

deletePermissions(target: Snowflake | { id: Snowflake }, reason?: string): Promise<void>

createInvite(options?: InviteCreateOptions, reason?: string): Promise<Invite>

createWebhook(options: { name: string; avatar?: string | null }, reason?: string): Promise<Webhook>

import type { TextChannel } from 'chapterjs';

async function clean(channel: TextChannel) {
  const messages = await channel.fetchMessages({ limit: 100 });
  const fromBots = messages.filter(message => message.author.bot);
  const deleted = await channel.bulkDelete(fromBots, 'Cleaning bot messages');
  await channel.send(`Deleted ${deleted} messages.`);
}

fetchMessage(id: Snowflake, options?: { force?: boolean }): Promise<Message>

fetchMessages(options?: FetchMessagesOptions): Promise<Message[]>

fetchPins(): Promise<Message[]>

send(message: MessageInput): Promise<Message>

bulkDelete(messages: readonly (Snowflake | { id: Snowflake })[], reason?: string): Promise<number>

sendTyping(): Promise<void>

waitForMessage(options?: WaitForMessageOptions): Promise<Message | null>

collectMessages(options?: CollectMessagesOptions): Promise<Message[]>

type TextBasedChannel = GuildTextBasedChannel | DMChannel

type GuildTextBasedChannel = TextChannel | VoiceChannel | ThreadChannel

type PersonInput = User | GuildMember | Snowflake