chapterjs 0.1.2 → 0.1.4

package/dist/structures/message.js

@@ -0,0 +1,268 @@
+import { CreateMessage, CreateReaction, CrosspostMessage, DeleteAllReactions, DeleteAllReactionsForEmoji, DeleteMessage, DeleteOwnReaction, DeleteUserReaction, EditMessage, GetChannelMessage, GetReactions, PinMessage, StartThreadFromMessage, UnpinMessage, } from '../discord/endpoints.js';
+import { reactionEmoji } from '../discord/formatting.js';
+import { MessageFlags, MessageType, } from '../discord/types/message.js';
+import { toCamelCase, toSnakeCase } from '../util/case.js';
+import { ctxOf, dataOf, idOf, IdStructure, toDate } from './base.js';
+import { findGuild, knownChannel, knownMember } from './known.js';
+import { buildMessage, } from './payload.js';
+import { translatorOf } from '../messages/translate.js';
+function emojiPath(emoji) {
+    if (typeof emoji !== 'string')
+        return reactionEmoji(emoji);
+    // Accepts what users copy from Discord: `<:name:id>` and `<a:name:id>`.
+    const custom = /^<a?:(\w+):(\d+)>$/.exec(emoji.trim());
+    if (custom)
+        return `${custom[1]}:${custom[2]}`;
+    if (emoji.trim() === '') {
+        throw new TypeError('The emoji is empty: pass one like "👍".');
+    }
+    return emoji.trim();
+}
+/**
+ * A message sent in a channel.
+ * @see https://docs.discord.com/developers/resources/message#message-object
+ */
+export class Message extends IdStructure {
+    /** Who wrote the message. */
+    author;
+    /** The users mentioned in the message. */
+    mentions;
+    constructor(ctx, data, author, mentions) {
+        super(ctx, data);
+        this.author = author;
+        this.mentions = mentions;
+    }
+    /** The id of the channel of the message. */
+    get channelId() {
+        return dataOf(this).channel_id;
+    }
+    /** The id of the server; `null` for a private message. */
+    get guildId() {
+        return (dataOf(this).guild_id ??
+            ctxOf(this).cache.channels.get(this.channelId)?.guildId ??
+            null);
+    }
+    /** The channel of the message, when it is known. */
+    get channel() {
+        const channel = ctxOf(this).cache.channels.get(this.channelId) ?? knownChannel(this);
+        return channel?.isTextBased() ? channel : null;
+    }
+    /** The server of the message; `null` for a private message. */
+    get guild() {
+        return findGuild(this, this.guildId);
+    }
+    /** The author as a member of the server, when it is known. */
+    get member() {
+        return this.guild?.members.get(this.author.id) ?? knownMember(this) ?? null;
+    }
+    /**
+     * The text of the message. Empty when the bot is not allowed to read it:
+     * reading the messages of others needs the Message Content intent.
+     */
+    get content() {
+        return dataOf(this).content ?? '';
+    }
+    /** The kind of message, as a value of `MessageType` (a regular one, a reply, a join notice...). */
+    get type() {
+        return dataOf(this).type;
+    }
+    /** When the message was last edited; `null` when it never was. */
+    get editedAt() {
+        return toDate(dataOf(this).edited_timestamp);
+    }
+    /** Whether the message is pinned. */
+    get pinned() {
+        return dataOf(this).pinned ?? false;
+    }
+    /** Whether the message was read aloud. */
+    get tts() {
+        return dataOf(this).tts ?? false;
+    }
+    /** The embeds of the message. */
+    get embeds() {
+        return toCamelCase(dataOf(this).embeds ?? []);
+    }
+    /** The files attached to the message. */
+    get attachments() {
+        return toCamelCase(dataOf(this).attachments ?? []);
+    }
+    /** The reactions on the message, one entry per emoji. */
+    get reactions() {
+        return toCamelCase(dataOf(this).reactions ?? []);
+    }
+    /** Whether the message mentions @everyone or @here. */
+    get mentionsEveryone() {
+        return dataOf(this).mention_everyone ?? false;
+    }
+    /** The ids of the roles mentioned in the message. */
+    get mentionedRoleIds() {
+        return dataOf(this).mention_roles ?? [];
+    }
+    /** The flags of the message, by name (`Ephemeral`, `SuppressEmbeds`...). */
+    get flags() {
+        const bits = dataOf(this).flags ?? 0;
+        return Object.keys(MessageFlags).filter(name => (bits & MessageFlags[name]) !== 0);
+    }
+    /** The id of the webhook that sent the message, when one did. */
+    get webhookId() {
+        return dataOf(this).webhook_id ?? null;
+    }
+    /** The id of the message this one replies to, when it is a reply. */
+    get repliedMessageId() {
+        return dataOf(this).message_reference?.message_id ?? null;
+    }
+    /** Whether a person wrote it: not a bot, a webhook or Discord itself. */
+    get isFromUser() {
+        return (!this.author.bot &&
+            !this.author.system &&
+            this.webhookId === null &&
+            (this.type === MessageType.Default || this.type === MessageType.Reply));
+    }
+    /** The link that opens the message in Discord. */
+    get url() {
+        return `https://discord.com/channels/${this.guildId ?? '@me'}/${this.channelId}/${this.id}`;
+    }
+    /** Asks Discord for the latest version of the message. */
+    async fetch() {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(GetChannelMessage, [
+            this.channelId,
+            this.id,
+        ]);
+        return entities.message(raw, this.guildId ?? undefined);
+    }
+    /**
+     * Answers the message, in the same channel.
+     * @see https://docs.discord.com/developers/resources/message#create-message
+     */
+    async reply(message) {
+        const options = typeof message === 'string' ? { content: message } : message;
+        return sendMessage(ctxOf(this), this.channelId, { ...options, replyTo: this.id }, this.guildId ?? undefined);
+    }
+    /**
+     * Changes the message. Only the content, embeds, components and files of
+     * a message the bot wrote can change.
+     * @see https://docs.discord.com/developers/resources/message#edit-message
+     */
+    async edit(message) {
+        const { rest, entities } = ctxOf(this);
+        const { body, files } = buildMessage(message, {
+            edit: true,
+            t: translatorOf(ctxOf(this), { guild: this.guild }),
+        });
+        const raw = await rest.request(EditMessage, [this.channelId, this.id], {
+            body,
+            files,
+        });
+        return entities.message(raw, this.guildId ?? undefined);
+    }
+    /**
+     * Deletes the message.
+     * @see https://docs.discord.com/developers/resources/message#delete-message
+     */
+    async delete(reason) {
+        await ctxOf(this).rest.request(DeleteMessage, [this.channelId, this.id], {
+            reason,
+        });
+    }
+    /**
+     * Adds a reaction of the bot to the message.
+     * @see https://docs.discord.com/developers/resources/message#create-reaction
+     */
+    async react(emoji) {
+        await ctxOf(this).rest.request(CreateReaction, [
+            this.channelId,
+            this.id,
+            emojiPath(emoji),
+        ]);
+    }
+    /**
+     * Removes a reaction: of the bot, or of the given user.
+     * @see https://docs.discord.com/developers/resources/message#delete-user-reaction
+     */
+    async removeReaction(emoji, user) {
+        const { rest } = ctxOf(this);
+        const path = [this.channelId, this.id, emojiPath(emoji)];
+        if (user === undefined)
+            await rest.request(DeleteOwnReaction, [...path]);
+        else
+            await rest.request(DeleteUserReaction, [...path, idOf(user)]);
+    }
+    /**
+     * Removes every reaction of the message, or every reaction of one emoji.
+     * @see https://docs.discord.com/developers/resources/message#delete-all-reactions
+     */
+    async clearReactions(emoji) {
+        const { rest } = ctxOf(this);
+        if (emoji === undefined) {
+            await rest.request(DeleteAllReactions, [this.channelId, this.id]);
+        }
+        else {
+            await rest.request(DeleteAllReactionsForEmoji, [
+                this.channelId,
+                this.id,
+                emojiPath(emoji),
+            ]);
+        }
+    }
+    /**
+     * The users who reacted with an emoji (100 at most per call).
+     * @see https://docs.discord.com/developers/resources/message#get-reactions
+     */
+    async fetchReactionUsers(emoji, options = {}) {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(GetReactions, [this.channelId, this.id, emojiPath(emoji)], { query: options });
+        return raw.map(user => entities.user(user));
+    }
+    /**
+     * Pins the message in its channel.
+     * @see https://docs.discord.com/developers/resources/message#pin-message
+     */
+    async pin(reason) {
+        await ctxOf(this).rest.request(PinMessage, [this.channelId, this.id], {
+            reason,
+        });
+    }
+    /**
+     * Unpins the message.
+     * @see https://docs.discord.com/developers/resources/message#unpin-message
+     */
+    async unpin(reason) {
+        await ctxOf(this).rest.request(UnpinMessage, [this.channelId, this.id], {
+            reason,
+        });
+    }
+    /**
+     * Publishes a message of an announcement channel to the servers that
+     * follow it.
+     * @see https://docs.discord.com/developers/resources/message#crosspost-message
+     */
+    async crosspost() {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(CrosspostMessage, [this.channelId, this.id]);
+        return entities.message(raw, this.guildId ?? undefined);
+    }
+    /**
+     * Starts a thread from the message.
+     * @see https://docs.discord.com/developers/resources/channel#start-thread-from-message
+     */
+    async startThread(options, reason) {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(StartThreadFromMessage, [this.channelId, this.id], { body: toSnakeCase(options), reason });
+        return entities.channel(raw);
+    }
+}
+/** One mechanism to send a message, used by channels, replies and users. */
+export async function sendMessage(ctx, channelId, message, guildId) {
+    const { body, files } = buildMessage(message, {
+        // What the server reads, or the default language in private messages.
+        t: translatorOf(ctx, {
+            guild: guildId ? ctx.cache.guilds.get(guildId) : null,
+        }),
+    });
+    const raw = await ctx.rest.request(CreateMessage, [channelId], {
+        body,
+        files,
+    });
+    return ctx.entities.message(raw, guildId);
+}

package/dist/structures/payload.d.ts

@@ -0,0 +1,91 @@
+import { type AssetFile } from '../assets/asset.js';
+import { type EmbedFile } from '../components/embed.js';
+import type { MessageComponent } from '../components/instance.js';
+import type { Snowflake } from '../discord/types/common.js';
+import { type CreateMessageJSONParams, type RawAllowedMentions, type RawEmbed } from '../discord/types/message.js';
+import type { RawPollCreateRequest } from '../discord/types/poll.js';
+import type { RestFile } from '../rest/rest.js';
+import { type Camelize } from '../util/case.js';
+import type { Translator } from '../messages/messages.js';
+/**
+ * A rich box in a message: title, description, fields, image...
+ * @see https://docs.discord.com/developers/resources/message#embed-object
+ */
+export type Embed = Camelize<RawEmbed>;
+/**
+ * Who a message is allowed to notify.
+ * @see https://docs.discord.com/developers/resources/message#allowed-mentions-object
+ */
+export type AllowedMentions = Camelize<RawAllowedMentions>;
+/**
+ * A poll to attach to a message.
+ * @see https://docs.discord.com/developers/resources/poll#poll-create-request-object
+ */
+export type PollInput = Camelize<RawPollCreateRequest>;
+/** A file to attach to a message. */
+export interface FileInput {
+    /** The name of the file, with its extension: `chart.png`. */
+    name: string;
+    /** The content of the file. */
+    data: Blob | Uint8Array | ArrayBuffer | string;
+    /** What the file shows, for people who can't see it. */
+    description?: string;
+    /** Hides the file until it is clicked. */
+    spoiler?: boolean;
+    /** The media type of the file (`image/png`); guessed from the name when missing. */
+    contentType?: string;
+}
+/** What a message can contain, and how it is sent. */
+export interface MessageOptions {
+    /** The text of the message (up to 2000 characters). */
+    content?: string;
+    /** Up to 10 embeds: written here, or files of `src/components/embeds/`. */
+    embeds?: (Embed | EmbedFile<[]>)[];
+    /**
+     * Buttons, select menus and layout components, made by ChapterJS: the
+     * files of `src/components/` and `row()`, `text()`, `container()`...
+     */
+    components?: MessageComponent[];
+    /** Up to 10 files to attach: their content, or `asset()` for a file of `public/`. */
+    files?: (FileInput | AssetFile)[];
+    /** Who the message is allowed to notify. */
+    allowedMentions?: AllowedMentions;
+    /** The ids of up to 3 stickers of the server. */
+    stickers?: Snowflake[];
+    /** A poll to attach to the message. */
+    poll?: PollInput;
+    /** Reads the message aloud. */
+    tts?: boolean;
+    /** Sends the message without a notification sound. */
+    silent?: boolean;
+    /** Does not show the previews of the links of the message. */
+    suppressEmbeds?: boolean;
+    /** The message to reply to. */
+    replyTo?: Snowflake | {
+        id: Snowflake;
+    };
+}
+/** A message to send: its text, or its options. */
+export type MessageInput = string | MessageOptions;
+/** What can be changed in a message that was already sent. */
+export type MessageEditOptions = Pick<MessageOptions, 'content' | 'embeds' | 'components' | 'files' | 'allowedMentions' | 'suppressEmbeds'>;
+export interface BuiltMessage {
+    body: CreateMessageJSONParams;
+    files: RestFile[] | undefined;
+}
+/**
+ * Checks one embed against the limits of Discord. `name` is how the embed
+ * is called in messages ("embed 1", "this embed").
+ * @returns how many characters it holds, which add up per message
+ * @see https://docs.discord.com/developers/resources/message#embed-object-embed-limits
+ */
+export declare function checkEmbed(embed: Embed, name: string): number;
+/**
+ * Validates a message and builds the request that sends it (or edits it).
+ * @see https://docs.discord.com/developers/resources/message#create-message
+ */
+export declare function buildMessage(input: MessageInput, { t, edit, }?: {
+    /** `t` for who will read the message: what its components may be computed from. */
+    t?: Translator;
+    edit?: boolean;
+}): BuiltMessage;

package/dist/structures/payload.js

@@ -0,0 +1,184 @@
+// Turns what users pass to send or edit a message into what Discord
+// expects. Used by everything that sends a message: channels, replies,
+// webhooks, and later interactions.
+import { isAssetFile, readAsset } from '../assets/asset.js';
+import { isEmbedFile } from '../components/embed.js';
+import { renderComponents } from '../components/render.js';
+import { Limits } from '../discord/api.js';
+import { MessageFlags, } from '../discord/types/message.js';
+import { toSnakeCase } from '../util/case.js';
+import { missingTranslator } from '../messages/translate.js';
+const count = (text) => text?.trim().length ?? 0;
+/**
+ * Checks one embed against the limits of Discord. `name` is how the embed
+ * is called in messages ("embed 1", "this embed").
+ * @returns how many characters it holds, which add up per message
+ * @see https://docs.discord.com/developers/resources/message#embed-object-embed-limits
+ */
+export function checkEmbed(embed, name) {
+    if (typeof embed !== 'object' || embed === null) {
+        throw new TypeError(`${name} is an object like { title: '...' }, got ${embed === null ? 'null' : typeof embed}.`);
+    }
+    let total = 0;
+    const check = (what, text, max) => {
+        const length = count(text);
+        total += length;
+        if (length > max) {
+            throw new RangeError(`The ${what} of ${name} is ${length} characters long: Discord accepts ${max} at most.`);
+        }
+    };
+    check('title', embed.title, Limits.EmbedTitle);
+    check('description', embed.description, Limits.EmbedDescription);
+    check('footer text', embed.footer?.text, Limits.EmbedFooterText);
+    check('author name', embed.author?.name, Limits.EmbedAuthorName);
+    const fields = embed.fields ?? [];
+    if (fields.length > Limits.EmbedFields) {
+        throw new RangeError(`${name[0].toUpperCase()}${name.slice(1)} has ${fields.length} fields: Discord accepts ${Limits.EmbedFields} at most.`);
+    }
+    fields.forEach((field, at) => {
+        check(`name of field ${at + 1}`, field.name, Limits.EmbedFieldName);
+        check(`value of field ${at + 1}`, field.value, Limits.EmbedFieldValue);
+    });
+    return total;
+}
+/** The embeds of a message, with the files of `src/components/embeds/` called. */
+function resolveEmbeds(embeds) {
+    if (!Array.isArray(embeds)) {
+        throw new TypeError(`The embeds of a message are a list, got ${typeof embeds}.`);
+    }
+    return embeds.map((embed, index) => {
+        if (isEmbedFile(embed))
+            return embed();
+        if (typeof embed === 'function') {
+            throw new TypeError(`Embed ${index + 1} of the message is a function: an embed is an object like { title: '...' }, or a file of src/components/embeds/.`);
+        }
+        return embed;
+    });
+}
+function checkEmbeds(embeds) {
+    if (embeds.length > Limits.MessageEmbeds) {
+        throw new RangeError(`A message has ${Limits.MessageEmbeds} embeds at most, got ${embeds.length}.`);
+    }
+    let total = 0;
+    embeds.forEach((embed, index) => {
+        total += checkEmbed(embed, `embed ${index + 1}`);
+    });
+    if (total > Limits.EmbedTotal) {
+        throw new RangeError(`The embeds of the message contain ${total} characters in total: Discord accepts ${Limits.EmbedTotal} at most.`);
+    }
+}
+/**
+ * Validates a message and builds the request that sends it (or edits it).
+ * @see https://docs.discord.com/developers/resources/message#create-message
+ */
+export function buildMessage(input, { t = missingTranslator(null), edit = false, } = {}) {
+    if (typeof input === 'string')
+        input = { content: input };
+    if (typeof input !== 'object' || input === null) {
+        throw new TypeError(`A message is a text or an object like { content: "Hello" }, got ${input === null ? 'null' : typeof input}.`);
+    }
+    const { content, components, files, stickers, poll } = input;
+    const embeds = input.embeds ? resolveEmbeds(input.embeds) : undefined;
+    if (content !== undefined && typeof content !== 'string') {
+        throw new TypeError(`The content of a message is a text, got ${typeof content}.`);
+    }
+    if (content !== undefined && content.length > Limits.MessageContent) {
+        throw new RangeError(`The message is ${content.length} characters long: Discord accepts ${Limits.MessageContent} at most. Split it in several messages or put the text in a file.`);
+    }
+    if (embeds)
+        checkEmbeds(embeds);
+    const rendered = components ? renderComponents(components, t) : undefined;
+    if (rendered?.v2 && (count(content) > 0 || embeds?.length)) {
+        throw new TypeError('A message built with texts, sections, galleries, files, separators or containers takes no content and no embeds: Discord shows components only. Put the text in text() and the embed in a container().');
+    }
+    if (rendered?.v2 && poll) {
+        throw new TypeError("A message built with components only can't have a poll.");
+    }
+    if (stickers && stickers.length > Limits.MessageStickers) {
+        throw new RangeError(`A message has ${Limits.MessageStickers} stickers at most, got ${stickers.length}.`);
+    }
+    if (files && files.length > Limits.MessageAttachments) {
+        throw new RangeError(`A message has ${Limits.MessageAttachments} files at most, got ${files.length}.`);
+    }
+    const empty = count(content) === 0 &&
+        !embeds?.length &&
+        !rendered?.raw.length &&
+        !files?.length &&
+        !stickers?.length &&
+        !poll;
+    if (empty && !edit) {
+        throw new TypeError('The message is empty: give it a content, an embed, a file, a component, a sticker or a poll.');
+    }
+    const body = {};
+    if (content !== undefined)
+        body.content = content;
+    if (embeds)
+        body.embeds = toSnakeCase(embeds);
+    if (rendered)
+        body.components = rendered.raw;
+    if (input.allowedMentions) {
+        body.allowed_mentions = toSnakeCase(input.allowedMentions);
+    }
+    if (stickers)
+        body.sticker_ids = stickers;
+    if (poll)
+        body.poll = toSnakeCase(poll);
+    if (input.tts)
+        body.tts = true;
+    let flags = 0;
+    if (input.silent)
+        flags |= MessageFlags.SuppressNotifications;
+    if (input.suppressEmbeds)
+        flags |= MessageFlags.SuppressEmbeds;
+    // Discord wants to be told when a message is made of components only.
+    if (rendered?.v2)
+        flags |= MessageFlags.IsComponentsV2;
+    if (flags !== 0 || (edit && input.suppressEmbeds === false)) {
+        body.flags = flags;
+    }
+    if (input.replyTo !== undefined) {
+        const id = typeof input.replyTo === 'string' ? input.replyTo : input.replyTo.id;
+        body.message_reference = { message_id: id };
+    }
+    let restFiles;
+    if (files?.length) {
+        restFiles = files.map(file => {
+            if (typeof file?.name !== 'string' || file.name.trim() === '') {
+                throw new TypeError('Every file needs a name with its extension, like "chart.png".');
+            }
+            if (isAssetFile(file)) {
+                return {
+                    name: file.name,
+                    data: () => readAsset(file),
+                    contentType: file.contentType,
+                };
+            }
+            if (typeof file.data === 'function' ||
+                (typeof file.data !== 'string' && typeof file.data !== 'object') ||
+                file.data === null) {
+                throw new TypeError(`The data of the file ${file.name} is its content (a text, a Buffer, an ArrayBuffer or a Blob), or asset('...') for a file of public/.`);
+            }
+            return {
+                name: file.name,
+                data: file.data,
+                contentType: file.contentType,
+            };
+        });
+        const names = new Set();
+        for (const { name } of restFiles) {
+            if (names.has(name)) {
+                throw new TypeError(`Two files of the message are named ${name}: Discord tells them apart by their name. Give one another name (asset(path, { name: '...' })).`);
+            }
+            names.add(name);
+        }
+        // Each file is described by the attachment whose id is its index.
+        // https://docs.discord.com/developers/reference#uploading-files
+        body.attachments = files.map((file, index) => ({
+            id: index,
+            filename: file.name,
+            ...(file.description ? { description: file.description } : {}),
+            ...(file.spoiler ? { is_spoiler: true } : {}),
+        }));
+    }
+    return { body, files: restFiles };
+}

package/dist/structures/role.d.ts

@@ -0,0 +1,69 @@
+import { type ImageOptions } from '../discord/cdn.js';
+import { Permissions } from '../discord/permissions.js';
+import type { Snowflake } from '../discord/types/common.js';
+import type { ModifyGuildRoleJSONParams } from '../discord/types/guild.js';
+import type { RawRole } from '../discord/types/permissions.js';
+import { type Camelize } from '../util/case.js';
+import { IdStructure } from './base.js';
+import type { Context } from './context.js';
+import type { Guild } from './guild.js';
+import type { GuildMember } from './member.js';
+/**
+ * What `edit()` takes on a role: only what is passed changes. Permissions
+ * are given by name, as a list of names or as a `Permissions` set.
+ * @see https://docs.discord.com/developers/resources/guild#modify-guild-role-json-params
+ */
+export type RoleEditOptions = Camelize<Omit<ModifyGuildRoleJSONParams, 'permissions'>> & {
+    permissions?: Permissions | ConstructorParameters<typeof Permissions>[0];
+};
+/**
+ * A role of a server.
+ * @see https://docs.discord.com/developers/topics/permissions#role-object
+ */
+export declare class Role extends IdStructure<RawRole> {
+    /** The id of the server of the role. */
+    readonly guildId: Snowflake;
+    constructor(ctx: Context, data: RawRole, guildId: Snowflake);
+    /** The server of the role. */
+    get guild(): Guild;
+    /** The name of the role. */
+    get name(): string;
+    /** The color as a number (`0xff0000`); `0` means no color. */
+    get color(): number;
+    /** Whether members with this role are shown apart in the member list. */
+    get hoist(): boolean;
+    /** Where the role is in the hierarchy: the higher, the more powerful. */
+    get position(): number;
+    /** What the role allows in the server. */
+    get permissions(): Permissions;
+    /** Whether the role belongs to an integration (a bot, boosters...). */
+    get managed(): boolean;
+    /** Whether everyone can mention the role. */
+    get mentionable(): boolean;
+    /** The standard emoji shown next to the role, when it has one. */
+    get unicodeEmoji(): string | null;
+    /** Whether this is the @everyone role, which every member has. */
+    get isEveryone(): boolean;
+    /** The members that have this role, among the ones the bot knows. */
+    get members(): GuildMember[];
+    /** The URL of the icon of the role, when it has one. */
+    iconURL(options?: ImageOptions): string | null;
+    /**
+     * Whether this role is above another one in the hierarchy. With the same
+     * position, the oldest role is above.
+     * @see https://docs.discord.com/developers/topics/permissions#permission-hierarchy
+     */
+    isHigherThan(other: Role): boolean;
+    /**
+     * Changes the role.
+     * @see https://docs.discord.com/developers/resources/guild#modify-guild-role
+     */
+    edit(options: RoleEditOptions, reason?: string): Promise<Role>;
+    /**
+     * Deletes the role.
+     * @see https://docs.discord.com/developers/resources/guild#delete-guild-role
+     */
+    delete(reason?: string): Promise<void>;
+    /** `<@&id>`: mentions the role when put in a message. */
+    toString(): string;
+}