class BaseGuildTextChannel

extends

TextBasedChannelMixin(GuildChannel, true)
export class BaseGuildTextChannel extends TextBasedChannelMixin(GuildChannel, true)

Represents a text-based guild channel on Discord.

Constructors

constructor(
guild: Guild
data?: RawGuildChannelData
client?: Client<true>
immediatePatch?: boolean
)

Constructs a new instance of the BaseGuildTextChannel class

optional
defaultAutoArchiveDuration? : ThreadAutoArchiveDuration

The default auto archive duration for newly created threads in this channel

defaultThreadRateLimitPerUser : number | null

The initial rate limit per user (slowmode) to set on newly created threads in a channel.

readonlyoptional
lastMessage? : Message

The Message object of the last message in the channel, if one was sent

optional
lastMessageId? : Snowflake

The last message id sent in the channel, if one was sent

readonlyoptional
lastPinAt? : Date

The date when the last pinned message was pinned, if there was one

optional
lastPinTimestamp? : number

The timestamp when the last pinned message was pinned, if there was one

messages : GuildMessageManager

A manager of the messages sent to this channel

nsfw : boolean

If the guild considers this channel NSFW

rateLimitPerUser : number | null

threads : GuildTextThreadManager<AllowedThreadTypeForTextChannel | AllowedThreadTypeForNewsChannel>

A manager of the threads belonging to this channel

topic : string | null

The topic of the text channel

awaitMessageComponent(
options?: AwaitMessageComponentOptions
) : Promise<MessageComponentInteraction>

Collects a single component interaction that passes the filter. The Promise will reject if the time expires.

Examples:
// Collect a message component interaction
const filter = (interaction) => interaction.customId === 'button' && interaction.user.id === 'someId';
channel.awaitMessageComponent({ filter, time: 15_000 })
  .then(interaction => console.log(`${interaction.customId} was clicked!`))
  .catch(console.error);

awaitMessages(
options?: AwaitMessagesOptions
) : Promise<Collection<Snowflake, Message>>

Similar to createMessageCollector but in promise form. Resolves with a collection of messages that pass the specified filter.

Examples:
// Await !vote messages
const filter = m => m.content.startsWith('!vote');
// Errors: ['time'] treats ending because of the time limit as an error
channel.awaitMessages({ filter, max: 4, time: 60_000, errors: ['time'] })
  .then(collected => console.log(collected.size))
  .catch(collected => console.log(`After a minute, only ${collected.size} out of 4 voted.`));

bulkDelete(
messages: Collection<Snowflake, Message> | Array<MessageResolvable> | number
filterOld?: boolean
) : Promise<Collection<Snowflake, (Message|undefined)>>

Bulk deletes given messages that are newer than two weeks.

Examples:
// Bulk delete messages
channel.bulkDelete(5)
  .then(messages => console.log(`Bulk deleted ${messages.size} messages`))
  .catch(console.error);

Returns: Returns the deleted messages *

createInvite(
options?: InviteCreateOptions
) : Promise<Invite>

Creates an invite to this guild channel.

Examples:
// Create an invite to a channel
channel.createInvite()
  .then(invite => console.log(`Created an invite with a code of ${invite.code}`))
  .catch(console.error);

createMessageCollector(
options?: MessageCollectorOptions
) : MessageCollector

Creates a Message Collector.

Examples:
// Create a message collector
const filter = message => message.content.includes('discord');
const collector = channel.createMessageCollector({ filter, time: 15_000 });
collector.on('collect', message => console.log(`Collected ${message.content}`));
collector.on('end', collected => console.log(`Collected ${collected.size} items`));

createMessageComponentCollector(
options?: MessageComponentCollectorOptions
) : InteractionCollector

Creates a component interaction collector.

Examples:
// Create a button interaction collector
const filter = (interaction) => interaction.customId === 'button' && interaction.user.id === 'someId';
const collector = channel.createMessageComponentCollector({ filter, time: 15_000 });
collector.on('collect', interaction => console.log(`Collected ${interaction.customId}`));
collector.on('end', collected => console.log(`Collected ${collected.size} items`));

createWebhook(
options?: ChannelWebhookCreateOptions
) : Promise<Webhook>

Creates a webhook for the channel.

Examples:
// Create a webhook for the current channel
channel.createWebhook({
  name: 'Snek',
  avatar: 'https://i.imgur.com/mI8XcpG.jpg',
  reason: 'Needed a cool new Webhook'
})
  .then(console.log)
  .catch(console.error)

Returns: Returns the created Webhook *

fetchInvites(
cache?: boolean
) : Promise<Collection<string, Invite>>

Fetches a collection of invites to this guild channel. Resolves with a collection mapping invites by their codes.

fetchWebhooks() : Promise<Collection<Snowflake, Webhook>>

Fetches all webhooks for the channel.

Examples:
// Fetch webhooks
channel.fetchWebhooks()
  .then(hooks => console.log(`This channel has ${hooks.size} hooks`))
  .catch(console.error);

send(
options: string | MessagePayload | MessageCreateOptions
) : Promise<Message>

Sends a message to this channel.

Examples:
// Send a basic message
channel.send('hello!')
  .then(message => console.log(`Sent message: ${message.content}`))
  .catch(console.error);
// Send a remote file
channel.send({
  files: ['https://cdn.discordapp.com/icons/222078108977594368/6e1019b3179d71046e463a75915e7244.png?size=2048']
})
  .then(console.log)
  .catch(console.error);
// Send a local file
channel.send({
  files: [{
    attachment: 'entire/path/to/file.jpg',
    name: 'file.jpg',
    description: 'A description of the file'
  }]
})
  .then(console.log)
  .catch(console.error);

sendTyping() : Promise<void>

Sends a typing indicator in the channel.

Examples:
// Start typing in a channel
channel.sendTyping();

Returns: Resolves upon the typing status being sent *

setDefaultAutoArchiveDuration(
defaultAutoArchiveDuration: ThreadAutoArchiveDuration
reason?: string
) : Promise<this>

Sets the default auto archive duration for all newly created threads in this channel.

setNSFW(
nsfw?: boolean
reason?: string
) : Promise<this>

Sets whether this channel is flagged as NSFW.

setRateLimitPerUser(
rateLimitPerUser: number
reason?: string
) : Promise<this>

Sets the rate limit per user (slowmode) for this channel.

setTopic(
topic: string | null
reason?: string
) : Promise<this>

Sets a new topic for the guild channel.

Examples:
// Set a new channel topic
channel.setTopic('needs more rate limiting')
  .then(newChannel => console.log(`Channel's new topic is ${newChannel.topic}`))
  .catch(console.error);

setType(
type: ChannelType.GuildText
reason?: string
) : Promise<TextChannel>

Sets the type of this channel. Only conversion between TextChannel and NewsChannel is supported.