chapterjs 0.1.1 → 0.1.4

package/dist/structures/guild.js

@@ -0,0 +1,466 @@
+import { Limits } from '../discord/api.js';
+import { cdn } from '../discord/cdn.js';
+import { BulkGuildBan, CreateGuildChannel, CreateGuildEmoji, CreateGuildRole, CreateGuildScheduledEvent, GetGuild, GetGuildAuditLog, GetGuildBan, GetGuildBans, GetGuildChannels, GetGuildInvites, GetGuildMember, GetGuildRoles, GetGuildWebhooks, LeaveGuild, ListActiveGuildThreads, ListAutoModerationRulesForGuild, ListGuildEmojis, ListGuildMembers, ListGuildStickers, ListScheduledEventsForGuild, ModifyGuild, RemoveGuildBan, RemoveGuildMember, SearchGuildMembers, } from '../discord/endpoints.js';
+import { Permissions } from '../discord/permissions.js';
+import { toCamelCase, toSnakeCase } from '../util/case.js';
+import { ctxOf, dataOf, idOf, IdStructure } from './base.js';
+import { knownMember } from './known.js';
+import { banUser } from './member.js';
+/** Only the framework writes to the stores of a server. */
+export let storesOf;
+/**
+ * A server ("guild" is the name Discord gives servers in its API).
+ * @see https://docs.discord.com/developers/resources/guild#guild-object
+ */
+export class Guild extends IdStructure {
+    #stores;
+    static {
+        storesOf = guild => guild.#stores;
+    }
+    constructor(ctx, data) {
+        super(ctx, data);
+        const { createStore, limits } = ctx.cache;
+        this.#stores = {
+            roles: createStore(),
+            members: createStore({ limit: limits.members }),
+            channels: createStore(),
+            emojis: createStore(),
+            voiceStates: createStore(),
+        };
+    }
+    /** The name of the server. */
+    get name() {
+        return dataOf(this).name;
+    }
+    /** The description of the server, when it has one. */
+    get description() {
+        return dataOf(this).description ?? null;
+    }
+    /** The id of the user who owns the server. */
+    get ownerId() {
+        return dataOf(this).owner_id;
+    }
+    /** `false` during an outage of Discord: the data may be out of date. */
+    get available() {
+        return !dataOf(this).unavailable;
+    }
+    /**
+     * How many members the server has. Exact when the bot receives member
+     * events, approximate otherwise; `null` when Discord never said it.
+     */
+    get memberCount() {
+        const data = dataOf(this);
+        return data.member_count ?? data.approximate_member_count ?? null;
+    }
+    /**
+     * What the server has enabled or unlocked (`COMMUNITY`, `VANITY_URL`...).
+     * @see https://docs.discord.com/developers/resources/guild#guild-object-guild-features
+     */
+    get features() {
+        return dataOf(this).features ?? [];
+    }
+    /** What Discord asks of new members before they can write. */
+    get verificationLevel() {
+        return dataOf(this).verification_level;
+    }
+    /** The boost level of the server. */
+    get premiumTier() {
+        return dataOf(this).premium_tier;
+    }
+    /** How many boosts the server has. */
+    get boostCount() {
+        return dataOf(this).premium_subscription_count ?? 0;
+    }
+    /** The language of the server, used for what Discord sends to it. */
+    get preferredLocale() {
+        return dataOf(this).preferred_locale;
+    }
+    /** The code of the custom invite link of the server, when it has one. */
+    get vanityUrlCode() {
+        return dataOf(this).vanity_url_code ?? null;
+    }
+    /** The id of the channel where Discord posts welcome messages. */
+    get systemChannelId() {
+        return dataOf(this).system_channel_id ?? null;
+    }
+    /** The id of the channel that shows the rules, in a community server. */
+    get rulesChannelId() {
+        return dataOf(this).rules_channel_id ?? null;
+    }
+    /** The id of the voice channel inactive members are moved to. */
+    get afkChannelId() {
+        return dataOf(this).afk_channel_id ?? null;
+    }
+    /** When the bot joined the server, when Discord said it. */
+    get joinedAt() {
+        const joined = dataOf(this).joined_at;
+        return joined ? new Date(joined) : null;
+    }
+    /** The roles of the server, @everyone included. */
+    get roles() {
+        return this.#stores.roles;
+    }
+    /**
+     * The members of the server the bot knows: the ones seen the most
+     * recently, not all of them.
+     */
+    get members() {
+        return this.#stores.members;
+    }
+    /** The channels and active threads of the server. */
+    get channels() {
+        return this.#stores.channels;
+    }
+    /** The custom emojis of the server. */
+    get emojis() {
+        return this.#stores.emojis;
+    }
+    /**
+     * The bot in voice in this server, to play or leave; `null` when it is
+     * in no voice channel here.
+     */
+    get voice() {
+        return ctxOf(this).voice?.connectionOf(this.id) ?? null;
+    }
+    /** The @everyone role, which every member has. */
+    get everyoneRole() {
+        const role = this.#stores.roles.get(this.id);
+        if (!role)
+            throw this.#notReceived('roles');
+        return role;
+    }
+    /** The bot as a member of this server. */
+    get me() {
+        const self = ctxOf(this).self;
+        // Kept apart too: a limit on how many members are remembered must
+        // never make the bot forget itself.
+        const member = (self ? this.#stores.members.get(self.userId) : undefined) ??
+            knownMember(this);
+        if (!member)
+            throw this.#notReceived('members');
+        return member;
+    }
+    /**
+     * Discord sends the roles of a server and the bot as one of its members
+     * with the server itself: they are only missing while it is unavailable.
+     */
+    #notReceived(what) {
+        return new Error(`Discord has not sent the ${what} of the server ${this.id}${this.available ? '' : ', which is unavailable (an outage on their side)'}.`);
+    }
+    /** The URL of the icon of the server, when it has one. */
+    iconURL(options) {
+        const icon = dataOf(this).icon;
+        return icon ? cdn.guildIcon(this.id, icon, options) : null;
+    }
+    /** The URL of the banner of the server, when it has one. */
+    bannerURL(options) {
+        const banner = dataOf(this).banner;
+        return banner ? cdn.guildBanner(this.id, banner, options) : null;
+    }
+    /** The URL of the invite background of the server, when it has one. */
+    splashURL(options) {
+        const splash = dataOf(this).splash;
+        return splash ? cdn.guildSplash(this.id, splash, options) : null;
+    }
+    /**
+     * Asks Discord for the latest data of the server.
+     * @see https://docs.discord.com/developers/resources/guild#get-guild
+     */
+    async fetch() {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(GetGuild, [this.id], {
+            query: { with_counts: true },
+        });
+        return entities.guild(raw);
+    }
+    /**
+     * Changes the settings of the server.
+     * @see https://docs.discord.com/developers/resources/guild#modify-guild
+     */
+    async edit(options, reason) {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(ModifyGuild, [this.id], {
+            body: toSnakeCase(options),
+            reason,
+        });
+        return entities.guild(raw);
+    }
+    /**
+     * Makes the bot leave the server.
+     * @see https://docs.discord.com/developers/resources/user#leave-guild
+     */
+    async leave() {
+        await ctxOf(this).rest.request(LeaveGuild, [this.id]);
+    }
+    // -- Members ---------------------------------------------------------------
+    /**
+     * A member of the server: from what the bot remembers, or else from Discord.
+     * @see https://docs.discord.com/developers/resources/guild#get-guild-member
+     */
+    async fetchMember(user, { force = false } = {}) {
+        const { rest, entities } = ctxOf(this);
+        const id = idOf(user);
+        const cached = force ? undefined : this.#stores.members.get(id);
+        if (cached)
+            return cached;
+        return entities.member(this.id, await rest.request(GetGuildMember, [this.id, id]));
+    }
+    /**
+     * Members of the server, by pages of 1000 at most, ordered by id. Needs
+     * the Server Members intent to be enabled for the bot.
+     * @see https://docs.discord.com/developers/resources/guild#list-guild-members
+     */
+    async fetchMembers(options = {}) {
+        const { rest, entities } = ctxOf(this);
+        const limit = options.limit ?? Limits.ListGuildMembers;
+        if (!Number.isInteger(limit) ||
+            limit < 1 ||
+            limit > Limits.ListGuildMembers) {
+            throw new RangeError(`limit is a whole number between 1 and ${Limits.ListGuildMembers}, got ${limit}.`);
+        }
+        const raw = await rest.request(ListGuildMembers, [this.id], {
+            query: { limit, after: options.after && idOf(options.after) },
+        });
+        return raw.map(member => entities.member(this.id, member));
+    }
+    /**
+     * Members whose username or nickname starts with the given text.
+     * @see https://docs.discord.com/developers/resources/guild#search-guild-members
+     */
+    async searchMembers(query, limit = 1) {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(SearchGuildMembers, [this.id], {
+            query: { query, limit },
+        });
+        return raw.map(member => entities.member(this.id, member));
+    }
+    /** The member who owns the server. */
+    async fetchOwner() {
+        return this.fetchMember(this.ownerId);
+    }
+    /**
+     * Removes a member from the server; they can come back with an invite.
+     * @see https://docs.discord.com/developers/resources/guild#remove-guild-member
+     */
+    async kick(user, reason) {
+        await ctxOf(this).rest.request(RemoveGuildMember, [this.id, idOf(user)], {
+            reason,
+        });
+    }
+    // -- Bans ------------------------------------------------------------------
+    /**
+     * Bans a user from the server, member or not.
+     * @see https://docs.discord.com/developers/resources/guild#create-guild-ban
+     */
+    async ban(user, options = {}) {
+        await banUser(ctxOf(this), this.id, idOf(user), options);
+    }
+    /**
+     * Bans up to 200 users at once.
+     * @returns the ids of the users that were banned, and of those that could not be
+     * @see https://docs.discord.com/developers/resources/guild#bulk-guild-ban
+     */
+    async bulkBan(users, options = {}) {
+        if (users.length === 0 || users.length > Limits.BulkBanUsers) {
+            throw new RangeError(`bulkBan() takes between 1 and ${Limits.BulkBanUsers} users, got ${users.length}.`);
+        }
+        const raw = await ctxOf(this).rest.request(BulkGuildBan, [this.id], {
+            body: {
+                user_ids: users.map(idOf),
+                delete_message_seconds: options.deleteMessageSeconds,
+            },
+            reason: options.reason,
+        });
+        return toCamelCase(raw);
+    }
+    /**
+     * Lifts the ban of a user.
+     * @see https://docs.discord.com/developers/resources/guild#remove-guild-ban
+     */
+    async unban(user, reason) {
+        await ctxOf(this).rest.request(RemoveGuildBan, [this.id, idOf(user)], {
+            reason,
+        });
+    }
+    /**
+     * The ban of a user; `null` when they are not banned.
+     * @see https://docs.discord.com/developers/resources/guild#get-guild-ban
+     */
+    async fetchBan(user) {
+        const { rest, entities } = ctxOf(this);
+        try {
+            const raw = await rest.request(GetGuildBan, [this.id, idOf(user)]);
+            return { user: entities.user(raw.user), reason: raw.reason };
+        }
+        catch (error) {
+            // 10026: Unknown ban.
+            if (error?.code === 10026)
+                return null;
+            throw error;
+        }
+    }
+    /**
+     * The bans of the server, by pages of 1000 at most.
+     * @see https://docs.discord.com/developers/resources/guild#get-guild-bans
+     */
+    async fetchBans(options = {}) {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(GetGuildBans, [this.id], { query: options });
+        return raw.map(ban => ({
+            user: entities.user(ban.user),
+            reason: ban.reason,
+        }));
+    }
+    // -- Roles -----------------------------------------------------------------
+    /**
+     * Asks Discord for the roles of the server.
+     * @see https://docs.discord.com/developers/resources/guild#get-guild-roles
+     */
+    async fetchRoles() {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(GetGuildRoles, [this.id]);
+        return raw.map(role => entities.role(this.id, role));
+    }
+    /**
+     * Creates a role.
+     * @see https://docs.discord.com/developers/resources/guild#create-guild-role
+     */
+    async createRole(options = {}, reason) {
+        const { rest, entities } = ctxOf(this);
+        const { permissions, ...others } = options;
+        const body = toSnakeCase(others);
+        if (permissions !== undefined) {
+            body.permissions = new Permissions(permissions).toString();
+        }
+        const raw = await rest.request(CreateGuildRole, [this.id], {
+            body,
+            reason,
+        });
+        return entities.role(this.id, raw);
+    }
+    // -- Channels --------------------------------------------------------------
+    /**
+     * The channels of the server (threads are not included).
+     * @see https://docs.discord.com/developers/resources/guild#get-guild-channels
+     */
+    async fetchChannels() {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(GetGuildChannels, [this.id]);
+        return raw.map(channel => entities.channel(channel, this.id));
+    }
+    /**
+     * Creates a channel.
+     * @see https://docs.discord.com/developers/resources/guild#create-guild-channel
+     */
+    async createChannel(options, reason) {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(CreateGuildChannel, [this.id], {
+            body: toSnakeCase(options),
+            reason,
+        });
+        return entities.channel(raw, this.id);
+    }
+    /**
+     * The threads of the server that are not archived.
+     * @see https://docs.discord.com/developers/resources/guild#list-active-guild-threads
+     */
+    async fetchActiveThreads() {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(ListActiveGuildThreads, [this.id]);
+        return raw.threads.map(thread => entities.channel(thread, this.id));
+    }
+    // -- Everything else -------------------------------------------------------
+    /**
+     * Asks Discord for the custom emojis of the server.
+     * @see https://docs.discord.com/developers/resources/emoji#list-guild-emojis
+     */
+    async fetchEmojis() {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(ListGuildEmojis, [this.id]);
+        return raw.map(emoji => entities.emoji(this.id, emoji));
+    }
+    /**
+     * Adds a custom emoji to the server.
+     * @param options.image the image as a data URI (`data:image/png;base64,...`)
+     * @see https://docs.discord.com/developers/resources/emoji#create-guild-emoji
+     */
+    async createEmoji(options, reason) {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(CreateGuildEmoji, [this.id], {
+            body: {
+                name: options.name,
+                image: options.image,
+                roles: options.roles?.map(idOf) ?? [],
+            },
+            reason,
+        });
+        return entities.emoji(this.id, raw);
+    }
+    /**
+     * The invites of the server, with how many times each was used.
+     * @see https://docs.discord.com/developers/resources/guild#get-guild-invites
+     */
+    async fetchInvites() {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(GetGuildInvites, [this.id]);
+        return raw.map(invite => entities.invite(invite));
+    }
+    /**
+     * The webhooks of every channel of the server.
+     * @see https://docs.discord.com/developers/resources/webhook#get-guild-webhooks
+     */
+    async fetchWebhooks() {
+        const { rest, entities } = ctxOf(this);
+        const raw = await rest.request(GetGuildWebhooks, [this.id]);
+        return raw.map(webhook => entities.webhook(webhook));
+    }
+    /**
+     * What moderators and bots did in the server.
+     * @see https://docs.discord.com/developers/resources/audit-log#get-guild-audit-log
+     */
+    async fetchAuditLog(options = {}) {
+        const raw = await ctxOf(this).rest.request(GetGuildAuditLog, [this.id], {
+            query: toSnakeCase(options),
+        });
+        return toCamelCase(raw);
+    }
+    /**
+     * The scheduled events of the server.
+     * @see https://docs.discord.com/developers/resources/guild-scheduled-event#list-scheduled-events-for-guild
+     */
+    async fetchScheduledEvents() {
+        const raw = await ctxOf(this).rest.request(ListScheduledEventsForGuild, [this.id], { query: { with_user_count: true } });
+        return toCamelCase(raw);
+    }
+    /**
+     * Schedules an event in the server.
+     * @see https://docs.discord.com/developers/resources/guild-scheduled-event#create-guild-scheduled-event
+     */
+    async createScheduledEvent(options, reason) {
+        const raw = await ctxOf(this).rest.request(CreateGuildScheduledEvent, [this.id], {
+            body: toSnakeCase(options),
+            reason,
+        });
+        return toCamelCase(raw);
+    }
+    /**
+     * The auto moderation rules of the server.
+     * @see https://docs.discord.com/developers/resources/auto-moderation#list-auto-moderation-rules-for-guild
+     */
+    async fetchAutoModerationRules() {
+        const raw = await ctxOf(this).rest.request(ListAutoModerationRulesForGuild, [this.id]);
+        return toCamelCase(raw);
+    }
+    /**
+     * The custom stickers of the server.
+     * @see https://docs.discord.com/developers/resources/sticker#list-guild-stickers
+     */
+    async fetchStickers() {
+        const raw = await ctxOf(this).rest.request(ListGuildStickers, [this.id]);
+        return toCamelCase(raw);
+    }
+    /** The name of the server. */
+    toString() {
+        return this.name;
+    }
+}

package/dist/structures/interaction.d.ts

@@ -0,0 +1,197 @@
+import type { ModalComponent } from '../components/instance.js';
+import type { Locale, Snowflake } from '../discord/types/common.js';
+import { type RawInteraction } from '../discord/types/interaction.js';
+import type { Camelize } from '../util/case.js';
+import { IdStructure } from './base.js';
+import type { DMChannel, GuildTextBasedChannel, TextBasedChannel } from './channel.js';
+import type { Context } from './context.js';
+import type { Guild } from './guild.js';
+import type { GuildMember } from './member.js';
+import type { Message } from './message.js';
+import { type MessageEditOptions, type MessageOptions } from './payload.js';
+import type { User } from './user.js';
+export type InteractionData = Omit<RawInteraction, 'user' | 'member' | 'message'>;
+/** Only the framework reads how far an interaction was answered. */
+export declare let isUpdating: (interaction: Interaction) => boolean;
+/** An answer to an interaction: its text, or its options. */
+export type InteractionReply = string | InteractionReplyOptions;
+/** The options of an answer: everything a message takes, except `replyTo` and `stickers`. */
+export interface InteractionReplyOptions extends Omit<MessageOptions, 'replyTo' | 'stickers'> {
+    /**
+     * Only show the answer to who used the command. By default: what the
+     * command says with its own `ephemeral`, else visible to everyone.
+     */
+    ephemeral?: boolean;
+}
+/**
+ * Someone used something of the bot (a command...) and waits for an answer.
+ * Discord wants a first answer within 3 seconds, and accepts edits and
+ * other messages for 15 minutes.
+ * @see https://docs.discord.com/developers/interactions/receiving-and-responding
+ */
+export declare class Interaction extends IdStructure<InteractionData> {
+    #private;
+    /** Who did it. */
+    readonly user: User;
+    constructor(ctx: Context, data: InteractionData, user: User, { ephemeral }?: {
+        ephemeral?: boolean;
+    });
+    /** The id of the server; `null` in a private message. */
+    get guildId(): Snowflake | null;
+    /** The id of the channel it happened in. */
+    get channelId(): Snowflake;
+    /** The server it happened in; `null` in a private message. */
+    get guild(): Guild | null;
+    /** The channel it happened in: Discord sends it with the interaction. */
+    get channel(): TextBasedChannel;
+    /** Who did it, as a member of the server; `null` in a private message. */
+    get member(): GuildMember | null;
+    /** The language of the person: use it to answer in their language. */
+    get locale(): Locale;
+    /** Whether an answer was sent, or promised with `defer()`. */
+    get answered(): boolean;
+    /** Whether `defer()` was called and the answer is still to come. */
+    get deferred(): boolean;
+    /** The data of the interaction, without its token: a token is a secret. */
+    toJSON(): Camelize<InteractionData>;
+    /**
+     * Answers. If `defer()` was called (by you, or by the framework because
+     * the answer was taking long), this completes the pending answer.
+     * @see https://docs.discord.com/developers/interactions/receiving-and-responding#create-interaction-response
+     */
+    reply(message: InteractionReply): Promise<Message>;
+    /**
+     * Tells Discord the answer is coming: the person sees "thinking…" and
+     * `reply()` can then take up to 15 minutes. The framework does it by
+     * itself when an answer takes long; call it yourself to choose when.
+     */
+    defer({ ephemeral }?: {
+        ephemeral?: boolean;
+    }): Promise<void>;
+    /**
+     * Changes the answer.
+     * @see https://docs.discord.com/developers/interactions/receiving-and-responding#edit-original-interaction-response
+     */
+    edit(message: string | MessageEditOptions): Promise<Message>;
+    /**
+     * Sends another message, after the answer.
+     * @see https://docs.discord.com/developers/interactions/receiving-and-responding#create-followup-message
+     */
+    followUp(message: InteractionReply): Promise<Message>;
+    /**
+     * Deletes the answer.
+     * @see https://docs.discord.com/developers/interactions/receiving-and-responding#delete-original-interaction-response
+     */
+    delete(): Promise<void>;
+}
+/** Someone used a slash command. */
+export declare class CommandInteraction extends Interaction {
+    /** The command as the person typed it: `/mod ban`. */
+    readonly commandName: string;
+    constructor(ctx: Context, data: InteractionData, user: User, options: {
+        ephemeral?: boolean;
+        commandName: string;
+    });
+    /**
+     * Opens a form, as the answer: `showModal(report({ userId }))`, with a
+     * form of `src/components/modals/`. It must be the first answer, and the
+     * person has as long as they want to fill it in.
+     * @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-response-object-modal
+     */
+    showModal(form: ModalComponent): Promise<void>;
+}
+/**
+ * Someone clicked a button or picked something in a select menu of a
+ * message of the bot. It can answer like a command, or change the message
+ * the component is on.
+ * @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-object-message-component-data-structure
+ */
+export declare class ComponentInteraction extends Interaction {
+    /** The message the component is on. */
+    readonly message: Message;
+    constructor(ctx: Context, data: InteractionData, user: User, options: {
+        ephemeral?: boolean;
+        message: Message;
+    });
+    /**
+     * Changes the message the component is on, as the answer: its text, its
+     * embeds, its components, its files. Only what you pass changes;
+     * `components: []` removes the buttons and menus.
+     * @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-response-object-interaction-callback-type
+     */
+    update(message: string | MessageEditOptions): Promise<Message>;
+    /**
+     * Tells Discord the message will change later: the person sees nothing
+     * meanwhile, and `update()` can then take up to 15 minutes. The
+     * framework does it by itself when an answer takes long.
+     */
+    deferUpdate(): Promise<void>;
+    /**
+     * Opens a form, as the answer: `showModal(report({ userId }))`, with a
+     * form of `src/components/modals/`. It must be the first answer.
+     * @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-response-object-modal
+     */
+    showModal(form: ModalComponent): Promise<void>;
+}
+/**
+ * Someone sent a form of the bot. It can answer like a command; when a
+ * button or a menu opened the form, it can also change their message.
+ * @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-object-modal-submit-data-structure
+ */
+export declare class ModalInteraction extends Interaction {
+    /** The message whose button or menu opened the form; `null` when a command did. */
+    readonly message: Message | null;
+    constructor(ctx: Context, data: InteractionData, user: User, options: {
+        ephemeral?: boolean;
+        message: Message | null;
+    });
+    /**
+     * Changes the message whose button or menu opened the form, as the
+     * answer. Only what you pass changes.
+     * @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-response-object-interaction-callback-type
+     */
+    update(message: string | MessageEditOptions): Promise<Message>;
+    /**
+     * Tells Discord the message that opened the form will change later: the
+     * person sees nothing meanwhile.
+     */
+    deferUpdate(): Promise<void>;
+}
+/**
+ * A slash command used in a server: what a command receives by default.
+ * Discord sends the server, the member and the channel with it.
+ * @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-object-interaction-structure
+ */
+export interface GuildCommandInteraction extends CommandInteraction {
+    /** The id of the server. */
+    readonly guildId: Snowflake;
+    /** The server it happened in. */
+    readonly guild: Guild;
+    /** Who did it, as a member of the server. */
+    readonly member: GuildMember;
+    /** The channel it happened in. */
+    readonly channel: GuildTextBasedChannel;
+}
+/**
+ * A slash command used in a private message with the bot, for a command
+ * that works in both places (`where: 'both'`): there is no server, which is
+ * how it is told apart from `GuildCommandInteraction`.
+ */
+export interface PrivateCommandInteraction extends CommandInteraction {
+    /** No server: it happened in a private message. */
+    readonly guildId: null;
+    /** No server: it happened in a private message. */
+    readonly guild: null;
+    /** No member: the person is `user`. */
+    readonly member: null;
+    /** The private conversation it happened in. */
+    readonly channel: DMChannel;
+}
+/**
+ * A slash command that is only used in private messages with the bot
+ * (`where: 'dm'`): nothing about a server exists on it.
+ */
+export interface DmCommandInteraction extends Omit<CommandInteraction, 'guildId' | 'guild' | 'member' | 'channel'> {
+    /** The private conversation it happened in. */
+    readonly channel: DMChannel;
+}