chapterjs 0.1.2 → 0.1.4

package/dist/context.d.ts

@@ -1,72 +0,0 @@
-import type { Client } from './discord/client.js';
-import type { EventName } from './discord/events.js';
-import type { APIRateLimitedEvent, GatewayObject, PartialEmoji, Snowflake } from './discord/types.js';
-import { Channel } from './structures/Channel.js';
-import { Guild } from './structures/Guild.js';
-import { Interaction } from './structures/Interaction.js';
-import { Member } from './structures/Member.js';
-import { Message } from './structures/Message.js';
-import { Reaction } from './structures/Reaction.js';
-import { Role } from './structures/Role.js';
-import { User } from './structures/User.js';
-/**
- * What a handler receives. Each event only fills some keys, named after what
- * it is about (`message` in messageCreate, `member` in guildMemberAdd…):
- * reading a key the event doesn't have throws an error listing the right ones.
- * Every event has `client` and `data`, the raw payload sent by Discord.
- */
-export interface EventContext {
-    client: Client;
-    /** Payload sent by Discord, https://docs.discord.com/developers/events/gateway-events */
-    data: any;
-    user: User;
-    member: Member;
-    members: Member[];
-    message: Message;
-    /** Server of the event, for events that only happen in servers. Elsewhere, use `channel.guild`. */
-    guild: Guild;
-    guilds: Guild[];
-    channel: Channel;
-    thread: Channel;
-    threads: Channel[];
-    role: Role;
-    interaction: Interaction;
-    reaction: Reaction;
-    messageId: Snowflake;
-    messageIds: Snowflake[];
-    userId: Snowflake;
-    roleId: Snowflake;
-    scheduledEventId: Snowflake;
-    soundId: Snowflake;
-    integrationId: Snowflake;
-    /** Id of the poll answer. */
-    answerId: number;
-    /** Invite code. */
-    code: string;
-    emoji: PartialEmoji;
-    /** guildCreate/guildDelete: the guild is unavailable because of an outage. In guildDelete, false means the bot was removed. */
-    unavailable: boolean;
-    rateLimit: APIRateLimitedEvent;
-    permissions: GatewayObject;
-    rule: GatewayObject;
-    execution: GatewayObject;
-    entry: GatewayObject;
-    emojis: GatewayObject[];
-    stickers: GatewayObject[];
-    scheduledEvent: GatewayObject;
-    sound: GatewayObject;
-    sounds: GatewayObject[];
-    integration: GatewayObject;
-    invite: GatewayObject;
-    voiceState: GatewayObject;
-    voiceServer: GatewayObject;
-    effect: GatewayObject;
-    stageInstance: GatewayObject;
-    presence: GatewayObject;
-    entitlement: GatewayObject;
-    subscription: GatewayObject;
-    threadMember: GatewayObject;
-    channels: GatewayObject[];
-}
-/** Builds the context of one event, shared by all its handlers. */
-export declare function createContext(name: EventName, client: Client, data: unknown): EventContext;

package/dist/context.js

@@ -1,273 +0,0 @@
-import { Channel } from './structures/Channel.js';
-import { Guild } from './structures/Guild.js';
-import { Interaction } from './structures/Interaction.js';
-import { Member } from './structures/Member.js';
-import { Message } from './structures/Message.js';
-import { Reaction } from './structures/Reaction.js';
-import { Role } from './structures/Role.js';
-import { User } from './structures/User.js';
-/** Every key, to tell a key missing from this event apart from a typo. */
-const CONTEXT_KEYS = {
-    client: true,
-    data: true,
-    user: true,
-    member: true,
-    members: true,
-    message: true,
-    guild: true,
-    guilds: true,
-    channel: true,
-    thread: true,
-    threads: true,
-    role: true,
-    interaction: true,
-    reaction: true,
-    messageId: true,
-    messageIds: true,
-    userId: true,
-    roleId: true,
-    scheduledEventId: true,
-    soundId: true,
-    integrationId: true,
-    answerId: true,
-    code: true,
-    emoji: true,
-    unavailable: true,
-    rateLimit: true,
-    permissions: true,
-    rule: true,
-    execution: true,
-    entry: true,
-    emojis: true,
-    stickers: true,
-    scheduledEvent: true,
-    sound: true,
-    sounds: true,
-    integration: true,
-    invite: true,
-    voiceState: true,
-    voiceServer: true,
-    effect: true,
-    stageInstance: true,
-    presence: true,
-    entitlement: true,
-    subscription: true,
-    threadMember: true,
-    channels: true,
-};
-const guildOf = (client, data) => new Guild(client, { id: data.guild_id });
-/** Channel known by id, with its guild when the event says it. */
-const channelOf = (client, id, guildId) => new Channel(client, { id, ...(guildId && { guild_id: guildId }) });
-const inGuild = (build = () => ({})) => (client, data) => ({ guild: guildOf(client, data), ...build(client, data) });
-const message = (client, data) => {
-    const message = new Message(client, data);
-    return { message, channel: message.channel };
-};
-const reaction = (client, data) => ({
-    reaction: new Reaction(client, data),
-    channel: channelOf(client, data.channel_id, data.guild_id),
-    messageId: data.message_id,
-    userId: data.user_id,
-});
-const pollVote = (client, data) => ({
-    channel: channelOf(client, data.channel_id, data.guild_id),
-    messageId: data.message_id,
-    userId: data.user_id,
-    answerId: data.answer_id,
-});
-const member = inGuild((client, data) => {
-    const member = new Member(client, data.guild_id, data);
-    return { member, user: member.user };
-});
-const user = (key) => (client, data) => ({
-    user: new User(client, data[key]),
-});
-// Payloads: https://docs.discord.com/developers/events/gateway-events#receive-events
-const BUILDERS = {
-    ready: (client, data) => ({
-        user: new User(client, data.user),
-        guilds: data.guilds.map((guild) => new Guild(client, guild)),
-    }),
-    resumed: () => ({}),
-    rateLimited: (_, data) => ({ rateLimit: data }),
-    applicationCommandPermissionsUpdate: inGuild((_, data) => ({
-        permissions: data,
-    })),
-    autoModerationRuleCreate: inGuild((_, data) => ({ rule: data })),
-    autoModerationRuleUpdate: inGuild((_, data) => ({ rule: data })),
-    autoModerationRuleDelete: inGuild((_, data) => ({ rule: data })),
-    autoModerationActionExecution: inGuild((_, data) => ({
-        execution: data,
-        userId: data.user_id,
-    })),
-    channelCreate: inGuild((client, data) => ({
-        channel: new Channel(client, data),
-    })),
-    channelUpdate: inGuild((client, data) => ({
-        channel: new Channel(client, data),
-    })),
-    channelDelete: inGuild((client, data) => ({
-        channel: new Channel(client, data),
-    })),
-    channelInfo: inGuild((_, data) => ({ channels: data.channels })),
-    channelPinsUpdate: (client, data) => ({
-        channel: channelOf(client, data.channel_id, data.guild_id),
-    }),
-    voiceChannelStatusUpdate: inGuild((client, data) => ({
-        channel: channelOf(client, data.id, data.guild_id),
-    })),
-    voiceChannelStartTimeUpdate: inGuild((client, data) => ({
-        channel: channelOf(client, data.id, data.guild_id),
-    })),
-    threadCreate: inGuild((client, data) => ({
-        thread: new Channel(client, data),
-    })),
-    threadUpdate: inGuild((client, data) => ({
-        thread: new Channel(client, data),
-    })),
-    threadDelete: inGuild((client, data) => ({
-        thread: new Channel(client, data),
-    })),
-    threadListSync: inGuild((client, data) => ({
-        threads: data.threads.map((thread) => new Channel(client, thread)),
-    })),
-    threadMemberUpdate: inGuild((_, data) => ({ threadMember: data })),
-    threadMembersUpdate: inGuild((client, data) => ({
-        thread: channelOf(client, data.id, data.guild_id),
-    })),
-    entitlementCreate: (_, data) => ({ entitlement: data }),
-    entitlementUpdate: (_, data) => ({ entitlement: data }),
-    entitlementDelete: (_, data) => ({ entitlement: data }),
-    guildCreate: (client, data) => ({
-        guild: new Guild(client, data),
-        unavailable: data.unavailable === true,
-    }),
-    guildUpdate: (client, data) => ({ guild: new Guild(client, data) }),
-    guildDelete: (client, data) => ({
-        guild: new Guild(client, data),
-        unavailable: data.unavailable === true,
-    }),
-    guildAuditLogEntryCreate: inGuild((_, data) => ({ entry: data })),
-    guildBanAdd: inGuild(user('user')),
-    guildBanRemove: inGuild(user('user')),
-    guildEmojisUpdate: inGuild((_, data) => ({ emojis: data.emojis })),
-    guildStickersUpdate: inGuild((_, data) => ({ stickers: data.stickers })),
-    guildIntegrationsUpdate: inGuild(),
-    guildMemberAdd: member,
-    guildMemberRemove: inGuild(user('user')),
-    guildMemberUpdate: member,
-    guildMembersChunk: inGuild((client, data) => ({
-        members: data.members.map((member) => new Member(client, data.guild_id, member)),
-    })),
-    guildRoleCreate: inGuild((client, data) => ({
-        role: new Role(client, data.guild_id, data.role),
-    })),
-    guildRoleUpdate: inGuild((client, data) => ({
-        role: new Role(client, data.guild_id, data.role),
-    })),
-    guildRoleDelete: inGuild((_, data) => ({ roleId: data.role_id })),
-    guildScheduledEventCreate: inGuild((_, data) => ({ scheduledEvent: data })),
-    guildScheduledEventUpdate: inGuild((_, data) => ({ scheduledEvent: data })),
-    guildScheduledEventDelete: inGuild((_, data) => ({ scheduledEvent: data })),
-    guildScheduledEventUserAdd: inGuild((_, data) => ({
-        userId: data.user_id,
-        scheduledEventId: data.guild_scheduled_event_id,
-    })),
-    guildScheduledEventUserRemove: inGuild((_, data) => ({
-        userId: data.user_id,
-        scheduledEventId: data.guild_scheduled_event_id,
-    })),
-    guildSoundboardSoundCreate: inGuild((_, data) => ({ sound: data })),
-    guildSoundboardSoundUpdate: inGuild((_, data) => ({ sound: data })),
-    guildSoundboardSoundDelete: inGuild((_, data) => ({
-        soundId: data.sound_id,
-    })),
-    guildSoundboardSoundsUpdate: inGuild((_, data) => ({
-        sounds: data.soundboard_sounds,
-    })),
-    soundboardSounds: inGuild((_, data) => ({ sounds: data.soundboard_sounds })),
-    integrationCreate: inGuild((_, data) => ({ integration: data })),
-    integrationUpdate: inGuild((_, data) => ({ integration: data })),
-    integrationDelete: inGuild((_, data) => ({ integrationId: data.id })),
-    interactionCreate: (client, data) => ({
-        interaction: new Interaction(client, data),
-    }),
-    inviteCreate: (client, data) => ({
-        channel: channelOf(client, data.channel_id, data.guild_id),
-        invite: data,
-    }),
-    inviteDelete: (client, data) => ({
-        channel: channelOf(client, data.channel_id, data.guild_id),
-        code: data.code,
-    }),
-    messageCreate: message,
-    messageUpdate: message,
-    messageDelete: (client, data) => ({
-        messageId: data.id,
-        channel: channelOf(client, data.channel_id, data.guild_id),
-    }),
-    messageDeleteBulk: (client, data) => ({
-        messageIds: data.ids,
-        channel: channelOf(client, data.channel_id, data.guild_id),
-    }),
-    messageReactionAdd: reaction,
-    messageReactionRemove: reaction,
-    messageReactionRemoveAll: (client, data) => ({
-        channel: channelOf(client, data.channel_id, data.guild_id),
-        messageId: data.message_id,
-    }),
-    messageReactionRemoveEmoji: (client, data) => ({
-        channel: channelOf(client, data.channel_id, data.guild_id),
-        messageId: data.message_id,
-        emoji: data.emoji,
-    }),
-    // The user object can be partial, only its id is guaranteed
-    presenceUpdate: inGuild((_, data) => ({
-        userId: data.user.id,
-        presence: data,
-    })),
-    stageInstanceCreate: inGuild((_, data) => ({ stageInstance: data })),
-    stageInstanceUpdate: inGuild((_, data) => ({ stageInstance: data })),
-    stageInstanceDelete: inGuild((_, data) => ({ stageInstance: data })),
-    subscriptionCreate: (_, data) => ({ subscription: data }),
-    subscriptionUpdate: (_, data) => ({ subscription: data }),
-    subscriptionDelete: (_, data) => ({ subscription: data }),
-    typingStart: (client, data) => ({
-        channel: channelOf(client, data.channel_id, data.guild_id),
-        userId: data.user_id,
-    }),
-    userUpdate: (client, data) => ({ user: new User(client, data) }),
-    voiceChannelEffectSend: inGuild((client, data) => ({
-        channel: channelOf(client, data.channel_id, data.guild_id),
-        userId: data.user_id,
-        effect: data,
-    })),
-    voiceStateUpdate: (_, data) => ({ userId: data.user_id, voiceState: data }),
-    voiceServerUpdate: inGuild((_, data) => ({ voiceServer: data })),
-    webhooksUpdate: inGuild((client, data) => ({
-        channel: channelOf(client, data.channel_id, data.guild_id),
-    })),
-    messagePollVoteAdd: pollVote,
-    messagePollVoteRemove: pollVote,
-};
-/** Builds the context of one event, shared by all its handlers. */
-export function createContext(name, client, data) {
-    const values = {
-        client,
-        data,
-        ...BUILDERS[name](client, data),
-    };
-    return new Proxy(values, {
-        get(target, key) {
-            if (typeof key !== 'string' || Object.hasOwn(target, key))
-                return Reflect.get(target, key);
-            if (Object.hasOwn(CONTEXT_KEYS, key)) {
-                const hint = key === 'guild' && ('message' in target || 'channel' in target)
-                    ? ` For the server, use ${'message' in target ? 'message' : 'channel'}.guild (null in DMs).`
-                    : '';
-                throw new Error(`"${key}" doesn't exist in ${name} events. You can use: ${Object.keys(target).join(', ')}.${hint}`);
-            }
-            return undefined;
-        },
-    });
-}

package/dist/discord/client.d.ts

@@ -1,35 +0,0 @@
-import type { Gateway } from './gateway.js';
-import type { RestClient } from './rest.js';
-import { Channel } from '../structures/Channel.js';
-import { Guild } from '../structures/Guild.js';
-import { User } from '../structures/User.js';
-import type { Snowflake } from './types.js';
-/**
- * What handlers, buttons and presence functions receive as `client`. It reads
- * the connection state and acts on Discord, but can't drive the connection:
- * logging in, intents, presence and shutdown belong to the framework.
- */
-export declare class Client {
-    #private;
-    /** Created by the framework, use the `client` passed to your handlers. */
-    private constructor();
-    /** REST client, to call endpoints not wrapped by the framework. */
-    get rest(): RestClient;
-    /** The bot's user, set once connected. */
-    get user(): User | null;
-    get applicationId(): string | null;
-    /** Ids of the guilds the bot is in, as sent in READY. */
-    get guildIds(): ReadonlySet<string>;
-    /** Bitfield of the gateway intents of the current session. */
-    get intents(): number;
-    /** A channel by id, to send messages or fetch it without fetching it first. */
-    channel(id: Snowflake): Channel;
-    /** A server by id, to fetch members, ban… without fetching it first. */
-    guild(id: Snowflake): Guild;
-    /** https://docs.discord.com/developers/resources/user#get-user */
-    fetchUser(id: Snowflake): Promise<User>;
-}
-/** Internal: the client of a gateway. */
-export declare const createClient: (gateway: Gateway) => Client;
-/** Internal: a message for the user, printed by `chapterjs dev`. */
-export declare function emitWarning(client: Client, message: string): void;

package/dist/discord/client.js

@@ -1,66 +0,0 @@
-import { Channel } from '../structures/Channel.js';
-import { Guild } from '../structures/Guild.js';
-import { User } from '../structures/User.js';
-/** Proves a `Client` is created by the framework, not by user code. */
-const INTERNAL = Symbol('chapterjs.client');
-let gatewayOf;
-let construct;
-/**
- * What handlers, buttons and presence functions receive as `client`. It reads
- * the connection state and acts on Discord, but can't drive the connection:
- * logging in, intents, presence and shutdown belong to the framework.
- */
-export class Client {
-    #gateway;
-    static {
-        gatewayOf = client => client.#gateway;
-        construct = gateway => new Client(INTERNAL, gateway);
-    }
-    /** Created by the framework, use the `client` passed to your handlers. */
-    constructor(key, gateway) {
-        if (key !== INTERNAL) {
-            throw new TypeError('Client is created by ChapterJS: use the `client` passed to your handlers.');
-        }
-        this.#gateway = gateway;
-        Object.freeze(this);
-    }
-    /** REST client, to call endpoints not wrapped by the framework. */
-    get rest() {
-        return this.#gateway.rest;
-    }
-    /** The bot's user, set once connected. */
-    get user() {
-        return this.#gateway.user;
-    }
-    get applicationId() {
-        return this.#gateway.applicationId;
-    }
-    /** Ids of the guilds the bot is in, as sent in READY. */
-    get guildIds() {
-        return new Set(this.#gateway.guildIds);
-    }
-    /** Bitfield of the gateway intents of the current session. */
-    get intents() {
-        return this.#gateway.intents;
-    }
-    /** A channel by id, to send messages or fetch it without fetching it first. */
-    channel(id) {
-        return new Channel(this, { id });
-    }
-    /** A server by id, to fetch members, ban… without fetching it first. */
-    guild(id) {
-        return new Guild(this, { id });
-    }
-    /** https://docs.discord.com/developers/resources/user#get-user */
-    async fetchUser(id) {
-        return new User(this, await this.rest.get(`/users/${id}`));
-    }
-}
-Object.freeze(Client);
-Object.freeze(Client.prototype);
-/** Internal: the client of a gateway. */
-export const createClient = (gateway) => construct(gateway);
-/** Internal: a message for the user, printed by `chapterjs dev`. */
-export function emitWarning(client, message) {
-    gatewayOf(client).emit('warning', message);
-}

package/dist/discord/constants.d.ts

@@ -1,49 +0,0 @@
-export declare const API_VERSION = 10;
-export declare const API_BASE_URL = "https://discord.com/api/v10";
-export declare const GatewayOpcodes: {
-    readonly Dispatch: 0;
-    readonly Heartbeat: 1;
-    readonly Identify: 2;
-    readonly PresenceUpdate: 3;
-    readonly Resume: 6;
-    readonly Reconnect: 7;
-    readonly InvalidSession: 9;
-    readonly Hello: 10;
-    readonly HeartbeatAck: 11;
-};
-export declare const GatewayCloseCodes: {
-    readonly AuthenticationFailed: 4004;
-    readonly InvalidSeq: 4007;
-    readonly SessionTimedOut: 4009;
-    readonly InvalidShard: 4010;
-    readonly ShardingRequired: 4011;
-    readonly InvalidApiVersion: 4012;
-    readonly InvalidIntents: 4013;
-    readonly DisallowedIntents: 4014;
-};
-/** Close codes after which reconnecting is pointless. */
-export declare const INVALID_TOKEN_MESSAGE: string;
-export declare const FATAL_CLOSE_CODES: Record<number, string>;
-export declare const GatewayIntents: {
-    readonly Guilds: number;
-    readonly GuildMembers: number;
-    readonly GuildModeration: number;
-    readonly GuildExpressions: number;
-    readonly GuildIntegrations: number;
-    readonly GuildWebhooks: number;
-    readonly GuildInvites: number;
-    readonly GuildVoiceStates: number;
-    readonly GuildPresences: number;
-    readonly GuildMessages: number;
-    readonly GuildMessageReactions: number;
-    readonly GuildMessageTyping: number;
-    readonly DirectMessages: number;
-    readonly DirectMessageReactions: number;
-    readonly DirectMessageTyping: number;
-    readonly MessageContent: number;
-    readonly GuildScheduledEvents: number;
-    readonly AutoModerationConfiguration: number;
-    readonly AutoModerationExecution: number;
-    readonly GuildMessagePolls: number;
-    readonly DirectMessagePolls: number;
-};

package/dist/discord/constants.js

@@ -1,61 +0,0 @@
-// https://docs.discord.com/developers/reference#api-versioning
-export const API_VERSION = 10;
-export const API_BASE_URL = `https://discord.com/api/v${API_VERSION}`;
-// https://docs.discord.com/developers/topics/opcodes-and-status-codes#gateway-gateway-opcodes
-export const GatewayOpcodes = {
-    Dispatch: 0,
-    Heartbeat: 1,
-    Identify: 2,
-    PresenceUpdate: 3,
-    Resume: 6,
-    Reconnect: 7,
-    InvalidSession: 9,
-    Hello: 10,
-    HeartbeatAck: 11,
-};
-// https://docs.discord.com/developers/topics/opcodes-and-status-codes#gateway-gateway-close-event-codes
-export const GatewayCloseCodes = {
-    AuthenticationFailed: 4004,
-    InvalidSeq: 4007,
-    SessionTimedOut: 4009,
-    InvalidShard: 4010,
-    ShardingRequired: 4011,
-    InvalidApiVersion: 4012,
-    InvalidIntents: 4013,
-    DisallowedIntents: 4014,
-};
-/** Close codes after which reconnecting is pointless. */
-export const INVALID_TOKEN_MESSAGE = 'Discord refused the bot token: check BOT_TOKEN in your .env file. ' +
-    'If it was reset or leaked, get a new one in the Developer Portal (your application > Bot > Reset Token).';
-export const FATAL_CLOSE_CODES = {
-    [GatewayCloseCodes.AuthenticationFailed]: INVALID_TOKEN_MESSAGE,
-    [GatewayCloseCodes.InvalidShard]: 'Invalid shard.',
-    [GatewayCloseCodes.ShardingRequired]: 'Discord requires sharding for this bot (it is in too many servers), which ChapterJS does not support yet.',
-    [GatewayCloseCodes.InvalidApiVersion]: `Discord no longer supports the gateway API v${API_VERSION}: update chapterjs.`,
-    [GatewayCloseCodes.InvalidIntents]: 'Discord refused the intents sent by ChapterJS.',
-    [GatewayCloseCodes.DisallowedIntents]: 'Discord refused to connect: your code asks for privileged intents that are not enabled for this bot.',
-};
-// https://docs.discord.com/developers/events/gateway#list-of-intents
-export const GatewayIntents = {
-    Guilds: 1 << 0,
-    GuildMembers: 1 << 1,
-    GuildModeration: 1 << 2,
-    GuildExpressions: 1 << 3,
-    GuildIntegrations: 1 << 4,
-    GuildWebhooks: 1 << 5,
-    GuildInvites: 1 << 6,
-    GuildVoiceStates: 1 << 7,
-    GuildPresences: 1 << 8,
-    GuildMessages: 1 << 9,
-    GuildMessageReactions: 1 << 10,
-    GuildMessageTyping: 1 << 11,
-    DirectMessages: 1 << 12,
-    DirectMessageReactions: 1 << 13,
-    DirectMessageTyping: 1 << 14,
-    MessageContent: 1 << 15,
-    GuildScheduledEvents: 1 << 16,
-    AutoModerationConfiguration: 1 << 20,
-    AutoModerationExecution: 1 << 21,
-    GuildMessagePolls: 1 << 24,
-    DirectMessagePolls: 1 << 25,
-};

package/dist/discord/events.d.ts

@@ -1,129 +0,0 @@
-import type { GatewayObject, APIGuild, APIGuildBanEvent, APIGuildCreateEvent, APIGuildMemberAddEvent, APIGuildMemberRemoveEvent, APIGuildMemberUpdateEvent, APIInteraction, APIMessage, APIMessageDeleteBulkEvent, APIMessageDeleteEvent, APIMessageReactionAddEvent, APIMessageReactionRemoveAllEvent, APIMessageReactionRemoveEmojiEvent, APIMessageReactionRemoveEvent, APIRateLimitedEvent, APIReadyEvent, APITypingStartEvent, APIUnavailableGuild, APIUser } from './types.js';
-/**
- * Every dispatch event an app can receive, by camelCase name, with the intents
- * that make Discord send it (0 when it is always sent). An event listed under
- * several intents (guild and DM) needs any of them; all are requested.
- *
- * https://docs.discord.com/developers/events/gateway-events#receive-events
- * https://docs.discord.com/developers/events/gateway#list-of-intents
- */
-export declare const GATEWAY_EVENTS: {
-    readonly ready: 0;
-    readonly resumed: 0;
-    readonly rateLimited: 0;
-    readonly applicationCommandPermissionsUpdate: 0;
-    readonly autoModerationRuleCreate: number;
-    readonly autoModerationRuleUpdate: number;
-    readonly autoModerationRuleDelete: number;
-    readonly autoModerationActionExecution: number;
-    readonly channelCreate: number;
-    readonly channelUpdate: number;
-    readonly channelDelete: number;
-    readonly channelInfo: 0;
-    readonly channelPinsUpdate: number;
-    readonly voiceChannelStatusUpdate: number;
-    readonly voiceChannelStartTimeUpdate: number;
-    readonly threadCreate: number;
-    readonly threadUpdate: number;
-    readonly threadDelete: number;
-    readonly threadListSync: number;
-    readonly threadMemberUpdate: number;
-    readonly threadMembersUpdate: number;
-    readonly entitlementCreate: 0;
-    readonly entitlementUpdate: 0;
-    readonly entitlementDelete: 0;
-    readonly guildCreate: number;
-    readonly guildUpdate: number;
-    readonly guildDelete: number;
-    readonly guildAuditLogEntryCreate: number;
-    readonly guildBanAdd: number;
-    readonly guildBanRemove: number;
-    readonly guildEmojisUpdate: number;
-    readonly guildStickersUpdate: number;
-    readonly guildIntegrationsUpdate: number;
-    readonly guildMemberAdd: number;
-    readonly guildMemberRemove: number;
-    readonly guildMemberUpdate: number;
-    readonly guildMembersChunk: 0;
-    readonly guildRoleCreate: number;
-    readonly guildRoleUpdate: number;
-    readonly guildRoleDelete: number;
-    readonly guildScheduledEventCreate: number;
-    readonly guildScheduledEventUpdate: number;
-    readonly guildScheduledEventDelete: number;
-    readonly guildScheduledEventUserAdd: number;
-    readonly guildScheduledEventUserRemove: number;
-    readonly guildSoundboardSoundCreate: number;
-    readonly guildSoundboardSoundUpdate: number;
-    readonly guildSoundboardSoundDelete: number;
-    readonly guildSoundboardSoundsUpdate: number;
-    readonly soundboardSounds: 0;
-    readonly integrationCreate: number;
-    readonly integrationUpdate: number;
-    readonly integrationDelete: number;
-    readonly interactionCreate: 0;
-    readonly inviteCreate: number;
-    readonly inviteDelete: number;
-    readonly messageCreate: number;
-    readonly messageUpdate: number;
-    readonly messageDelete: number;
-    readonly messageDeleteBulk: number;
-    readonly messageReactionAdd: number;
-    readonly messageReactionRemove: number;
-    readonly messageReactionRemoveAll: number;
-    readonly messageReactionRemoveEmoji: number;
-    readonly presenceUpdate: number;
-    readonly stageInstanceCreate: number;
-    readonly stageInstanceUpdate: number;
-    readonly stageInstanceDelete: number;
-    readonly subscriptionCreate: 0;
-    readonly subscriptionUpdate: 0;
-    readonly subscriptionDelete: 0;
-    readonly typingStart: number;
-    readonly userUpdate: 0;
-    readonly voiceChannelEffectSend: number;
-    readonly voiceStateUpdate: number;
-    readonly voiceServerUpdate: 0;
-    readonly webhooksUpdate: number;
-    readonly messagePollVoteAdd: number;
-    readonly messagePollVoteRemove: number;
-};
-export type EventName = keyof typeof GATEWAY_EVENTS;
-/** Data of the events typed in detail; the others receive a plain object. */
-interface TypedEventData {
-    ready: APIReadyEvent;
-    resumed: unknown;
-    rateLimited: APIRateLimitedEvent;
-    guildCreate: APIGuildCreateEvent;
-    guildUpdate: APIGuild;
-    /** `unavailable` is not set when the bot was removed from the guild. */
-    guildDelete: APIUnavailableGuild;
-    guildBanAdd: APIGuildBanEvent;
-    guildBanRemove: APIGuildBanEvent;
-    guildMemberAdd: APIGuildMemberAddEvent;
-    guildMemberRemove: APIGuildMemberRemoveEvent;
-    guildMemberUpdate: APIGuildMemberUpdateEvent;
-    interactionCreate: APIInteraction;
-    messageCreate: APIMessage;
-    /** Same shape as messageCreate; `tts` is always false. */
-    messageUpdate: APIMessage;
-    messageDelete: APIMessageDeleteEvent;
-    messageDeleteBulk: APIMessageDeleteBulkEvent;
-    messageReactionAdd: APIMessageReactionAddEvent;
-    messageReactionRemove: APIMessageReactionRemoveEvent;
-    messageReactionRemoveAll: APIMessageReactionRemoveAllEvent;
-    messageReactionRemoveEmoji: APIMessageReactionRemoveEmojiEvent;
-    typingStart: APITypingStartEvent;
-    userUpdate: APIUser;
-}
-/** Data received by the `E` event handlers. */
-export type EventData<E extends EventName> = E extends keyof TypedEventData ? TypedEventData[E] : GatewayObject;
-/** `messageCreate` → `MESSAGE_CREATE`, as sent by Discord. */
-export declare function toDispatchName(name: EventName): string;
-/** Intents only granted once enabled in the Developer Portal (Bot > Privileged Gateway Intents). */
-export declare const PRIVILEGED_INTENTS: {
-    readonly GuildMembers: number;
-    readonly GuildPresences: number;
-    readonly MessageContent: number;
-};
-export {};