baff.js 0.0.0-stage → 0.1.0

package/dist/esm/builders/messagePayload.d.ts

@@ -0,0 +1,35 @@
+import { AttachmentBuilder, type RawFile } from '../rest/files.js';
+import type { APIComponent, APIEmbed } from '../types.js';
+import { EmbedBuilder } from './EmbedBuilder.js';
+import { type Serializable } from './validate.js';
+export interface PollData {
+    question: string;
+    answers: {
+        text: string;
+        emoji?: string;
+    }[];
+    duration?: number;
+    allowMultiselect?: boolean;
+}
+export interface MessageOptions {
+    content?: string;
+    embeds?: (EmbedBuilder | APIEmbed)[];
+    components?: (Serializable | APIComponent)[];
+    files?: (AttachmentBuilder | RawFile)[];
+    flags?: number;
+    ephemeral?: boolean;
+    replyTo?: string;
+    mentionReply?: boolean;
+    stickers?: string[];
+    poll?: PollData;
+    nonce?: string;
+}
+export interface ResolvedMessage {
+    body: Record<string, unknown>;
+    files: RawFile[];
+}
+export declare function checkComponents(list: APIComponent[], v2: boolean): void;
+export declare function resolveEmbeds(embeds: (EmbedBuilder | APIEmbed)[]): APIEmbed[];
+export declare function resolveMessage(input: string | MessageOptions, options?: {
+    allowEphemeral?: boolean;
+}): ResolvedMessage;

package/dist/esm/builders/messagePayload.js

@@ -0,0 +1,83 @@
+import { BaffError } from '../errors/BaffError.js';
+import { AttachmentBuilder } from '../rest/files.js';
+import { ComponentType, MessageFlags } from '../util/constants.js';
+import { EmbedBuilder, EmbedLimits } from './EmbedBuilder.js';
+import { resolveJSON } from './validate.js';
+const V2_ONLY = new Set([ComponentType.Section, ComponentType.TextDisplay, ComponentType.MediaGallery, ComponentType.Separator, ComponentType.Container]);
+const MAX_COMPONENTS = 40;
+const MAX_ROWS = 5;
+const MAX_TEXT = 4000;
+export function checkComponents(list, v2) {
+    const code = 'INVALID_COMPONENT';
+    if (!v2 && list.length > MAX_ROWS)
+        throw new BaffError(code, `A message can have up to ${MAX_ROWS} action rows (or use the IsComponentsV2 flag).`);
+    let total = 0;
+    let textLength = 0;
+    const ids = new Set();
+    const visit = (component) => {
+        total++;
+        if (typeof component.custom_id === 'string') {
+            if (ids.has(component.custom_id))
+                throw new BaffError(code, `Custom id "${component.custom_id}" is used twice in one message.`);
+            ids.add(component.custom_id);
+        }
+        if (component.type === ComponentType.TextDisplay)
+            textLength += [...String(component.content)].length;
+        for (const child of component.components ?? [])
+            visit(child);
+        if (component.accessory)
+            visit(component.accessory);
+    };
+    list.forEach(visit);
+    if (total > MAX_COMPONENTS)
+        throw new BaffError(code, `A message can have up to ${MAX_COMPONENTS} components in total (nested ones included); this has ${total}.`);
+    if (textLength > MAX_TEXT)
+        throw new BaffError(code, `Text displays can have up to ${MAX_TEXT} characters in total; this has ${textLength}.`);
+}
+export function resolveEmbeds(embeds) {
+    if (embeds.length > EmbedLimits.embeds)
+        throw new BaffError('INVALID_EMBED', `A message can have up to ${EmbedLimits.embeds} embeds.`);
+    const out = embeds.map((embed) => (embed instanceof EmbedBuilder ? embed.toJSON() : new EmbedBuilder(embed).toJSON()));
+    const total = embeds.reduce((sum, embed) => sum + (embed instanceof EmbedBuilder ? embed : new EmbedBuilder(embed)).length, 0);
+    if (total > EmbedLimits.total)
+        throw new BaffError('INVALID_EMBED', `Embeds can have up to ${EmbedLimits.total} characters in total; these have ${total}.`);
+    return out;
+}
+export function resolveMessage(input, options = {}) {
+    const message = typeof input === 'string' ? { content: input } : input;
+    const body = {};
+    let flags = message.flags ?? 0;
+    if (message.content !== undefined)
+        body.content = message.content;
+    if (message.embeds)
+        body.embeds = resolveEmbeds(message.embeds);
+    if (message.components) {
+        const components = message.components.map((c) => resolveJSON(c));
+        if (components.some((c) => V2_ONLY.has(c.type)))
+            flags |= MessageFlags.IsComponentsV2;
+        checkComponents(components, (flags & MessageFlags.IsComponentsV2) !== 0);
+        body.components = components;
+    }
+    if ((flags & MessageFlags.IsComponentsV2) !== 0 && (body.content || body.embeds?.length)) {
+        throw new BaffError('INVALID_COMPONENT', 'A message with the IsComponentsV2 flag can not have content or embeds: put the text in text displays.');
+    }
+    if (message.ephemeral) {
+        if (!options.allowEphemeral)
+            throw new BaffError('INVALID_MESSAGE', 'ephemeral only works on interaction replies.');
+        body.ephemeral = true;
+    }
+    if (flags)
+        body.flags = flags;
+    if (message.replyTo)
+        body.replyTo = message.replyTo;
+    if (message.mentionReply !== undefined)
+        body.mentionReply = message.mentionReply;
+    if (message.stickers?.length)
+        body.stickerIds = message.stickers;
+    if (message.poll)
+        body.poll = message.poll;
+    if (message.nonce)
+        body.nonce = message.nonce;
+    const files = (message.files ?? []).map((f) => (f instanceof AttachmentBuilder ? f.toFile() : f));
+    return { body, files };
+}

package/dist/esm/builders/validate.d.ts

@@ -0,0 +1,12 @@
+export declare function fail(code: string, path: string, message: string): never;
+export declare function text(code: string, path: string, value: unknown, max: number, options?: {
+    min?: number;
+    optional?: boolean;
+}): string | undefined;
+export declare function url(code: string, path: string, value: unknown, optional?: boolean): string | undefined;
+export declare function range(code: string, path: string, value: number, min: number, max: number): number;
+export interface Serializable {
+    toJSON(): unknown;
+}
+export declare function isSerializable(value: unknown): value is Serializable;
+export declare function resolveJSON<T>(value: T | Serializable): T;

package/dist/esm/builders/validate.js

@@ -0,0 +1,46 @@
+import { BaffError } from '../errors/BaffError.js';
+export function fail(code, path, message) {
+    throw new BaffError(code, `${path} ${message}`);
+}
+export function text(code, path, value, max, options = {}) {
+    if (value === undefined || value === null || value === '') {
+        if (options.optional)
+            return undefined;
+        return fail(code, path, `is required (${options.min ?? 1}-${max} characters).`);
+    }
+    if (typeof value !== 'string')
+        return fail(code, path, 'must be a string.');
+    if ((options.min ?? 1) > value.length || [...value].length > max)
+        return fail(code, path, `must be ${options.min ?? 1}-${max} characters.`);
+    return value;
+}
+export function url(code, path, value, optional = true) {
+    if (value === undefined || value === null) {
+        if (optional)
+            return undefined;
+        return fail(code, path, 'is required.');
+    }
+    if (typeof value !== 'string' || value.length > 2048)
+        return fail(code, path, 'must be an http:// or https:// URL.');
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return fail(code, path, 'must be an http:// or https:// URL.');
+    }
+    if (!/^https?:$/.test(parsed.protocol) || parsed.username || parsed.password)
+        return fail(code, path, 'must be an http:// or https:// URL.');
+    return value;
+}
+export function range(code, path, value, min, max) {
+    if (!Number.isInteger(value) || value < min || value > max)
+        return fail(code, path, `must be a whole number from ${min} to ${max}.`);
+    return value;
+}
+export function isSerializable(value) {
+    return typeof value === 'object' && value !== null && typeof value.toJSON === 'function';
+}
+export function resolveJSON(value) {
+    return (isSerializable(value) ? value.toJSON() : value);
+}

package/dist/esm/client/Client.d.ts

@@ -0,0 +1,63 @@
+import { type WebSocketConstructor } from '../gateway/Gateway.js';
+import { ApplicationCommandManager } from '../managers/CommandManager.js';
+import { ChannelManager } from '../managers/ChannelManager.js';
+import { ServerManager } from '../managers/ServerManager.js';
+import { UserManager } from '../managers/UserManager.js';
+import { VoiceManager } from '../managers/VoiceManager.js';
+import { REST, type RESTOptions } from '../rest/REST.js';
+import { Invite } from '../structures/ServerAssets.js';
+import { ClientUser } from '../structures/User.js';
+import { type PermissionResolvable } from '../util/Permissions.js';
+import { TypedEmitter } from '../util/TypedEmitter.js';
+import type { ClientEvents } from './events.js';
+export interface ClientOptions {
+    token?: string;
+    applicationId?: string;
+    api?: string;
+    gateway?: string;
+    appUrl?: string;
+    WebSocket?: WebSocketConstructor;
+    fetch?: typeof fetch;
+    rest?: Omit<RESTOptions, 'token' | 'api' | 'fetch'>;
+    reconnect?: boolean;
+    initialBackoff?: number;
+    maxBackoff?: number;
+    messageCacheLimit?: number;
+    fetchServersOnReady?: boolean;
+    fetchMembersOnReady?: boolean;
+}
+export declare class ClientApplication {
+    readonly id: string;
+    readonly commands: ApplicationCommandManager;
+    constructor(client: Client, id: string);
+}
+export declare class Client extends TypedEmitter<ClientEvents> {
+    readonly options: Required<Omit<ClientOptions, 'token' | 'applicationId' | 'WebSocket' | 'fetch' | 'rest' | 'appUrl'>> & Pick<ClientOptions, 'WebSocket'>;
+    readonly rest: REST;
+    readonly appUrl: string;
+    readonly users: UserManager;
+    readonly servers: ServerManager;
+    readonly channels: ChannelManager;
+    readonly voice: VoiceManager;
+    user: ClientUser | null;
+    application: ClientApplication | null;
+    readyAt: Date | null;
+    private gateway;
+    constructor(options?: ClientOptions);
+    get token(): string | null;
+    get applicationId(): string | null;
+    get uptime(): number | null;
+    isReady(): boolean;
+    setApplicationId(id: string): void;
+    requireApplication(): ClientApplication;
+    requireApplicationId(): string;
+    fetchSelf(): Promise<ClientUser>;
+    login(token?: string): Promise<string>;
+    destroy(): Promise<void>;
+    generateInvite(options?: {
+        permissions?: PermissionResolvable;
+        applicationId?: string;
+    }): string;
+    fetchInvite(code: string): Promise<Invite>;
+    private sync;
+}

package/dist/esm/client/Client.js

@@ -0,0 +1,147 @@
+import { BaffError } from '../errors/BaffError.js';
+import { Gateway } from '../gateway/Gateway.js';
+import { ApplicationCommandManager } from '../managers/CommandManager.js';
+import { ChannelManager } from '../managers/ChannelManager.js';
+import { ServerManager } from '../managers/ServerManager.js';
+import { UserManager } from '../managers/UserManager.js';
+import { VoiceManager } from '../managers/VoiceManager.js';
+import { REST } from '../rest/REST.js';
+import { Routes } from '../rest/Routes.js';
+import { Invite } from '../structures/ServerAssets.js';
+import { ClientUser } from '../structures/User.js';
+import { DEFAULT_API_URL, DEFAULT_GATEWAY_URL } from '../util/constants.js';
+import { PermissionsBitField } from '../util/Permissions.js';
+import { TypedEmitter } from '../util/TypedEmitter.js';
+import { dispatch } from './dispatch.js';
+export class ClientApplication {
+    id;
+    commands;
+    constructor(client, id) {
+        this.id = id;
+        this.commands = new ApplicationCommandManager(client, () => id);
+    }
+}
+export class Client extends TypedEmitter {
+    options;
+    rest;
+    appUrl;
+    users = new UserManager(this);
+    servers = new ServerManager(this);
+    channels = new ChannelManager(this);
+    voice = new VoiceManager(this);
+    user = null;
+    application = null;
+    readyAt = null;
+    gateway = null;
+    constructor(options = {}) {
+        super({ captureRejections: true });
+        const api = (options.api ?? DEFAULT_API_URL).replace(/\/+$/, '');
+        this.options = {
+            api,
+            gateway: options.gateway ?? DEFAULT_GATEWAY_URL,
+            WebSocket: options.WebSocket,
+            reconnect: options.reconnect ?? true,
+            initialBackoff: options.initialBackoff ?? 1000,
+            maxBackoff: options.maxBackoff ?? 30_000,
+            messageCacheLimit: options.messageCacheLimit ?? 200,
+            fetchServersOnReady: options.fetchServersOnReady ?? true,
+            fetchMembersOnReady: options.fetchMembersOnReady ?? false
+        };
+        this.appUrl = (options.appUrl ?? api.replace(/\/api$/, '')).replace(/\/+$/, '');
+        this.rest = new REST({ ...options.rest, api, token: options.token, fetch: options.fetch });
+        this.rest.on('rateLimited', (info) => this.emit('debug', `Rate limited on ${info.method} ${info.path}; waiting ${info.retryAfter}s.`));
+        if (options.applicationId)
+            this.setApplicationId(options.applicationId);
+    }
+    get token() {
+        return this.rest.token;
+    }
+    get applicationId() {
+        return this.application?.id ?? null;
+    }
+    get uptime() {
+        return this.readyAt ? Date.now() - this.readyAt.getTime() : null;
+    }
+    isReady() {
+        return this.readyAt !== null;
+    }
+    setApplicationId(id) {
+        if (this.application?.id !== id)
+            this.application = new ClientApplication(this, id);
+    }
+    requireApplication() {
+        if (!this.application) {
+            throw new BaffError('NO_APPLICATION_ID', 'The application id is unknown. Pass applicationId to Client: baff.gg does not tell bots their application id.');
+        }
+        return this.application;
+    }
+    requireApplicationId() {
+        return this.requireApplication().id;
+    }
+    async fetchSelf() {
+        const data = await this.rest.get(Routes.me());
+        if (this.user)
+            this.user._patch(data);
+        else
+            this.user = new ClientUser(this, data);
+        this.users.cache.set(this.user.id, this.user);
+        return this.user;
+    }
+    async login(token) {
+        if (token)
+            this.rest.setToken(token);
+        if (!this.rest.token)
+            throw new BaffError('NO_TOKEN', 'No token provided. Pass it to Client or login().');
+        await this.fetchSelf();
+        const gateway = new Gateway({
+            token: this.rest.token,
+            url: this.options.gateway,
+            WebSocket: this.options.WebSocket,
+            reconnect: this.options.reconnect,
+            initialBackoff: this.options.initialBackoff,
+            maxBackoff: this.options.maxBackoff
+        });
+        this.gateway = gateway;
+        gateway.on('dispatch', (event, data) => dispatch(this, event, data));
+        gateway.on('debug', (message) => this.emit('debug', message));
+        gateway.on('disconnect', (code, reason) => this.emit('disconnect', code, reason));
+        gateway.on('reconnecting', (attempt, delay) => this.emit('reconnecting', attempt, delay));
+        gateway.on('reconnected', () => {
+            this.sync().then(() => this.emit('reconnected', this), (error) => this.emit('debug', `Resync after reconnect failed: ${error.message}`));
+        });
+        try {
+            await gateway.connect();
+            await this.sync();
+        }
+        catch (error) {
+            gateway.destroy();
+            this.gateway = null;
+            throw error;
+        }
+        this.readyAt = new Date();
+        this.emit('ready', this);
+        return this.rest.token;
+    }
+    async destroy() {
+        this.gateway?.destroy();
+        this.gateway = null;
+        this.readyAt = null;
+    }
+    generateInvite(options = {}) {
+        const id = options.applicationId ?? this.requireApplicationId();
+        const permissions = new PermissionsBitField(options.permissions ?? 0n);
+        return `${this.appUrl}/oauth2/authorize?client_id=${id}&permissions=${permissions}`;
+    }
+    async fetchInvite(code) {
+        return new Invite(this, await this.rest.get(Routes.invite(code), { auth: false }));
+    }
+    async sync() {
+        if (!this.options.fetchServersOnReady)
+            return;
+        await this.users.fetchTags().catch((error) => this.emit('debug', `Could not load user tags: ${error.message}`));
+        const servers = await this.servers.fetch();
+        if (this.options.fetchMembersOnReady) {
+            await Promise.all(servers.map((server) => server.members.fetch().catch((error) => this.emit('debug', `Members of ${server.id}: ${error.message}`))));
+        }
+    }
+}

package/dist/esm/client/dispatch.d.ts

@@ -0,0 +1,2 @@
+import type { Client } from './Client.js';
+export declare function dispatch(client: Client, event: string, data: unknown): void;

package/dist/esm/client/dispatch.js

@@ -0,0 +1,221 @@
+import { MessageReaction } from '../structures/Message.js';
+import { ThreadChannel } from '../structures/channels/ServerChannels.js';
+import { createInteraction } from '../structures/interactions/createInteraction.js';
+import { ScheduledEvent } from '../structures/ScheduledEvent.js';
+const handlers = {
+    SERVER_CREATE(client, d) {
+        client.emit('serverCreate', client.servers._add(d));
+    },
+    SERVER_UPDATE(client, d) {
+        const server = client.servers.cache.get(d.id);
+        if (!server)
+            return void client.servers._add(d);
+        const before = server._clone();
+        client.emit('serverUpdate', before, server._patch(d));
+    },
+    SERVER_REMOVE(client, d) {
+        const server = client.servers._remove(d.serverId);
+        client.emit('serverRemove', { id: d.serverId, reason: d.reason ?? null, server });
+    },
+    SERVER_CHANNELS_UPDATE(client, d) {
+        const { created, updated, deleted } = client.channels._replaceServer(d.serverId, d.channels);
+        created.forEach((c) => client.emit('channelCreate', c));
+        updated.forEach(([before, after]) => client.emit('channelUpdate', before, after));
+        deleted.forEach((c) => client.emit('channelDelete', c));
+    },
+    SERVER_ROLES_UPDATE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        if (!server)
+            return;
+        const { created, updated, deleted } = server.roles._setAll(d.roles);
+        created.forEach((r) => client.emit('roleCreate', r));
+        updated.forEach(([before, after]) => client.emit('roleUpdate', before, after));
+        deleted.forEach((r) => client.emit('roleDelete', r));
+    },
+    THREAD_UPDATE(client, d) {
+        const data = { ...d.channel, serverId: d.serverId };
+        const existing = client.channels.cache.get(data.id);
+        if (!(existing instanceof ThreadChannel))
+            return void client.emit('threadCreate', client.channels._addThread(data));
+        const before = existing._clone();
+        client.emit('threadUpdate', before, client.channels._addThread(data));
+    },
+    MESSAGE_CREATE(client, d) {
+        const channel = client.channels._textChannel(d.channelId, d.serverId ?? null);
+        channel.lastMessageId = d.id;
+        client.emit('messageCreate', channel.messages._add(d));
+    },
+    MESSAGE_UPDATE(client, d) {
+        const channel = client.channels._textChannel(d.channelId, d.serverId ?? null);
+        const cached = channel.messages.cache.get(d.id);
+        const before = cached ? cached._clone() : null;
+        client.emit('messageUpdate', before, channel.messages._add(d));
+    },
+    MESSAGE_DELETE(client, d) {
+        const channel = client.channels._textChannel(d.channelId, null);
+        client.emit('messageDelete', { id: d.id, channelId: d.channelId, channel, message: channel.messages._remove(d.id) });
+    },
+    MESSAGE_REACTION_ADD(client, d) {
+        const event = reactionEvent(client, d);
+        const message = event.message;
+        if (message) {
+            const own = d.userId === client.user?.id;
+            const existing = message.reactions.get(d.emoji);
+            if (existing) {
+                existing.count++;
+                existing.me ||= own;
+            }
+            else {
+                message.reactions.set(d.emoji, new MessageReaction(message, d.emoji, 1, own));
+            }
+        }
+        client.emit('messageReactionAdd', event);
+    },
+    MESSAGE_REACTION_REMOVE(client, d) {
+        const event = reactionEvent(client, d);
+        const reaction = event.message?.reactions.get(d.emoji);
+        if (reaction) {
+            reaction.count = Math.max(0, reaction.count - 1);
+            if (d.userId === client.user?.id)
+                reaction.me = false;
+            if (reaction.count === 0)
+                event.message?.reactions.delete(d.emoji);
+        }
+        client.emit('messageReactionRemove', event);
+    },
+    MESSAGE_PIN(client, d) {
+        const channel = client.channels._textChannel(d.channelId, null);
+        const message = channel.messages.cache.get(d.messageId);
+        if (message)
+            message.pinned = d.pinned;
+        client.emit('messagePin', { channelId: d.channelId, messageId: d.messageId, pinned: d.pinned, channel });
+    },
+    TYPING_START(client, d) {
+        client.emit('typingStart', {
+            channelId: d.channelId,
+            userId: d.userId,
+            channel: client.channels._textChannel(d.channelId, null),
+            user: client.users.cache.get(d.userId) ?? null
+        });
+    },
+    MENTION(client, d) {
+        client.emit('mention', { channelId: d.channelId, messageId: d.messageId, serverId: d.serverId ?? null });
+    },
+    POLL_VOTE(client, d) {
+        client.emit('pollVote', d);
+    },
+    MEMBER_ADD(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        if (server)
+            client.emit('memberAdd', server.members._add(d.member));
+    },
+    MEMBER_REMOVE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        const member = server?.members.cache.get(d.userId) ?? null;
+        server?.members.cache.delete(d.userId);
+        client.emit('memberRemove', { serverId: d.serverId, userId: d.userId, member, user: member?.user ?? client.users.cache.get(d.userId) ?? null });
+    },
+    MEMBER_UPDATE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        if (!server)
+            return;
+        const cached = server.members.cache.get(d.userId);
+        const user = client.users.cache.get(d.userId) ?? { id: d.userId, username: '' };
+        const before = cached ? cached._clone() : null;
+        const after = cached ?? server.members._add({ user, roles: [], nick: null });
+        after._patch(d);
+        client.emit('memberUpdate', before, after);
+    },
+    PRESENCE_UPDATE(client, d) {
+        const user = client.users.cache.get(d.userId) ?? null;
+        user?._patch({ status: d.status, customStatus: d.customStatus ?? null });
+        client.emit('presenceUpdate', { userId: d.userId, status: d.status, customStatus: d.customStatus ?? null, user });
+    },
+    USER_UPDATE(client, d) {
+        const cached = client.users.cache.get(d.id);
+        const before = cached ? cached._clone() : null;
+        client.emit('userUpdate', before, client.users._add(d));
+    },
+    CLAN_TAG_UPDATE(client, d) {
+        client.emit('clanTagUpdate', d);
+    },
+    DM_OPEN(client, d) {
+        client.emit('dmOpen', client.channels._addDM(d));
+    },
+    VOICE_STATE_UPDATE(client, d) {
+        const state = d;
+        const states = state.serverId ? client.servers.cache.get(state.serverId)?.voiceStates : undefined;
+        const before = states?.get(state.userId) ?? null;
+        if (state.channelId)
+            states?.set(state.userId, state);
+        else
+            states?.delete(state.userId);
+        client.emit('voiceStateUpdate', before, state);
+    },
+    SOUNDBOARD_PLAY: (client, d) => void client.emit('soundboardPlay', d),
+    CALL_ALONE: (client, d) => void client.emit('callAlone', d),
+    STAGE_INSTANCE_CREATE: (client, d) => void client.emit('stageInstanceCreate', d),
+    STAGE_INSTANCE_UPDATE: (client, d) => void client.emit('stageInstanceUpdate', d),
+    STAGE_INSTANCE_DELETE: (client, d) => void client.emit('stageInstanceDelete', d),
+    VOICE_CHANNEL_STATUS_UPDATE: (client, d) => void client.emit('voiceChannelStatusUpdate', d),
+    SERVER_SOUNDBOARD_UPDATE: (client, d) => void client.emit('serverSoundboardUpdate', d),
+    SERVER_STICKERS_UPDATE(client, d) {
+        client.servers.cache.get(d.serverId)?.stickers._setAll(d.stickers);
+        client.emit('serverStickersUpdate', d);
+    },
+    SERVER_EVENT_CREATE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        client.emit('serverEventCreate', server ? server.events._add(d) : new ScheduledEvent(client, d));
+    },
+    SERVER_EVENT_UPDATE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        client.emit('serverEventUpdate', server ? server.events._add(d) : new ScheduledEvent(client, d));
+    },
+    SERVER_EVENT_DELETE(client, d) {
+        client.servers.cache.get(d.serverId)?.events.cache.delete(d.id);
+        client.emit('serverEventDelete', { serverId: d.serverId, id: d.id });
+    },
+    SERVER_EVENT_USER_ADD(client, d) {
+        const event = client.servers.cache.get(d.serverId)?.events.cache.get(d.eventId);
+        if (event)
+            event.interestedCount = d.interestedCount;
+        client.emit('serverEventUserAdd', { serverId: d.serverId, eventId: d.eventId, userId: d.userId, interestedCount: d.interestedCount });
+    },
+    SERVER_EVENT_USER_REMOVE(client, d) {
+        const event = client.servers.cache.get(d.serverId)?.events.cache.get(d.eventId);
+        if (event)
+            event.interestedCount = d.interestedCount;
+        client.emit('serverEventUserRemove', { serverId: d.serverId, eventId: d.eventId, userId: d.userId, interestedCount: d.interestedCount });
+    },
+    INTERACTION_CREATE(client, d) {
+        const raw = d;
+        if (raw.type === 'ping')
+            return;
+        client.setApplicationId(raw.applicationId);
+        client.emit('interactionCreate', createInteraction(client, raw));
+    }
+};
+function reactionEvent(client, d) {
+    const channel = client.channels._textChannel(d.channelId, null);
+    return {
+        channelId: d.channelId,
+        messageId: d.messageId,
+        userId: d.userId,
+        emoji: d.emoji,
+        channel,
+        message: channel.messages.cache.get(d.messageId) ?? null,
+        user: client.users.cache.get(d.userId) ?? null
+    };
+}
+export function dispatch(client, event, data) {
+    client.emit('raw', { t: event, d: data });
+    try {
+        handlers[event]?.(client, data);
+    }
+    catch (error) {
+        if (client.listenerCount('error') > 0)
+            client.emit('error', error);
+        else
+            queueMicrotask(() => { throw error; });
+    }
+}