@biggy1337/discord-sbjs 1.3.11

package/src/client/websocket/handlers/READY.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const USER_REQUIRED_ACTION = require('./USER_REQUIRED_ACTION_UPDATE');
+const { Opcodes } = require('../../../util/Constants');
+
+let ClientUser;
+const MAX_SUBSCRIPTION_PACKET_BYTES = 14 * 1024;
+const SUBSCRIPTION_PAYLOAD_PREFIX = `{"op":${Opcodes.GUILD_SUBSCRIPTIONS_BULK},"d":{"subscriptions":{`;
+const SUBSCRIPTION_PAYLOAD_SUFFIX = '}}}';
+const SUBSCRIPTION_PAYLOAD_BASE_SIZE =
+  Buffer.byteLength(SUBSCRIPTION_PAYLOAD_PREFIX) + Buffer.byteLength(SUBSCRIPTION_PAYLOAD_SUFFIX);
+
+const createSubscription = () => ({
+  typing: true,
+  threads: true,
+  activities: true,
+  member_updates: true,
+  thread_member_lists: [],
+  members: [],
+  channels: {},
+});
+const SERIALIZED_SUBSCRIPTION = JSON.stringify(createSubscription());
+const SERIALIZED_SUBSCRIPTION_SIZE = Buffer.byteLength(SERIALIZED_SUBSCRIPTION);
+const getSubscriptionEntrySize = guildId =>
+  Buffer.byteLength(JSON.stringify(guildId)) + 1 + SERIALIZED_SUBSCRIPTION_SIZE;
+
+module.exports = (client, { d: data }, shard) => {
+  const buildSubscriptionChunks = guilds => {
+    const chunks = [];
+    let subscriptions = {};
+    let subscriptionCount = 0;
+    let payloadSize = SUBSCRIPTION_PAYLOAD_BASE_SIZE;
+
+    for (const guild of guilds) {
+      const entrySize = getSubscriptionEntrySize(guild.id);
+      const separatorSize = subscriptionCount > 0 ? 1 : 0;
+
+      if (subscriptionCount > 0 && payloadSize + separatorSize + entrySize > MAX_SUBSCRIPTION_PACKET_BYTES) {
+        chunks.push(subscriptions);
+
+        subscriptions = {};
+        subscriptionCount = 0;
+        payloadSize = SUBSCRIPTION_PAYLOAD_BASE_SIZE;
+      }
+
+      subscriptions[guild.id] = createSubscription();
+      payloadSize += (subscriptionCount > 0 ? 1 : 0) + entrySize;
+      subscriptionCount++;
+
+      if (subscriptionCount === 1 && payloadSize > MAX_SUBSCRIPTION_PACKET_BYTES) {
+        chunks.push(subscriptions);
+        subscriptions = {};
+        subscriptionCount = 0;
+        payloadSize = SUBSCRIPTION_PAYLOAD_BASE_SIZE;
+      }
+    }
+
+    if (subscriptionCount > 0) {
+      chunks.push(subscriptions);
+    }
+
+    return chunks;
+  };
+
+  // Check
+  USER_REQUIRED_ACTION(client, { d: data });
+
+  // Overwrite ClientPresence
+  client.presence.userId = data.user.id;
+
+  if (client.user) {
+    client.user._patch(data.user);
+  } else {
+    ClientUser ??= require('../../../structures/ClientUser');
+    client.user = new ClientUser(client, data.user);
+    client.users.cache.set(client.user.id, client.user);
+  }
+
+  for (const private_channel of Array.isArray(data.private_channels) ? data.private_channels : []) {
+    if (private_channel?.id) client.channels._add(private_channel);
+  }
+
+  for (const guild of data.guilds) {
+    guild.shardId = shard.id;
+    client.guilds._add(guild);
+  }
+
+  // User Notes
+  client.notes._reload(data.notes);
+
+  // Relationship
+  client.relationships._setup(data.relationships);
+
+  if (Array.isArray(data.relationships)) {
+    for (const relation of data.relationships) {
+      if (!relation?.user) continue;
+      const user = client.users._add(relation.user);
+      if (!user) continue;
+      if (relation.type === 1) {
+        client.user.friends.set(user.id, user);
+      } else if (relation.type === 2) {
+        client.user.blocked.set(user.id, user);
+      } else if (relation.type === 3) {
+        client.user.pending.set(user.id, user);
+      } else if (relation.type === 4) {
+        client.user.outgoing.set(user.id, user);
+      }
+    }
+  }
+
+  // ClientSetting
+  client.settings._patch(data.user_settings);
+
+  // GuildSetting
+  for (const gSetting of Array.isArray(data.user_guild_settings) ? data.user_guild_settings : []) {
+    const guild = client.guilds.cache.get(gSetting.guild_id);
+    if (guild) guild.settings._patch(gSetting);
+  }
+  // Todo: data.auth_session_id_hash
+  client.sessions.currentSessionIdHash = data.auth_session_id_hash;
+
+  const installationId = data.apex_experiments?.installation ?? data.installation;
+  if (installationId && typeof client.rest.setInstallationId === 'function') {
+    client.rest.setInstallationId(installationId);
+  }
+
+  if (data.guilds.length) {
+    for (const subscriptions of buildSubscriptionChunks(data.guilds)) {
+      shard.send({
+        op: Opcodes.GUILD_SUBSCRIPTIONS_BULK,
+        d: {
+          subscriptions,
+        },
+      });
+    }
+  }
+
+  const dmChannels = Array.isArray(data.private_channels) ? data.private_channels : [];
+  const { DMChannelVoiceStatusSync } = client.options;
+
+  if (DMChannelVoiceStatusSync >= 1 && dmChannels.length) {
+    for (const c of dmChannels) {
+      shard.send({
+        op: Opcodes.DM_UPDATE,
+        d: {
+          channel_id: c.id,
+        },
+      });
+    }
+
+    client.sleep(DMChannelVoiceStatusSync * (dmChannels.length - 1)).then(() => shard.checkReady());
+  } else {
+    Promise.resolve().then(() => shard.checkReady());
+  }
+};

package/src/client/websocket/handlers/RELATIONSHIP_ADD.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  if (data.user) {
+    client.users._add(data.user);
+  }
+  client.relationships.cache.set(data.id, data.type);
+  client.relationships.friendNicknames.set(data.id, data.nickname);
+  client.relationships.sinceCache.set(data.id, new Date(data.since || 0));
+  /**
+   * Emitted when a relationship is created, relevant to the current user.
+   * @event Client#relationshipAdd
+   * @param {Snowflake} user Target userId
+   * @param {boolean} shouldNotify Whether the client should notify the user of this relationship's creation
+   */
+  client.emit(Events.RELATIONSHIP_ADD, data.id, Boolean(data.should_notify));
+};

package/src/client/websocket/handlers/RELATIONSHIP_REMOVE.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  client.relationships.cache.delete(data.id);
+  client.relationships.friendNicknames.delete(data.id);
+  client.relationships.sinceCache.delete(data.id);
+  /**
+   * Emitted when a relationship is removed, relevant to the current user.
+   * @event Client#relationshipRemove
+   * @param {Snowflake} user The userID that was updated
+   * @param {RelationshipType} type The type of the old relationship
+   * @param {string | null} nickname The nickname of the user in this relationship (1-32 characters)
+   */
+  client.emit(Events.RELATIONSHIP_REMOVE, data.id, data.type, data.nickname);
+};

package/src/client/websocket/handlers/RELATIONSHIP_UPDATE.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  /**
+   * @typedef {Object} RelationshipUpdateObject
+   * @property {RelationshipType} type The type of relationship
+   * @property {Date} since When the user requested a relationship
+   * @property {string | null} nickname The nickname of the user in this relationship (1-32 characters)
+   */
+  /**
+   * Emitted when a relationship is updated, relevant to the current user (e.g. friend nickname changed).
+   * <info>This is not sent when the type of a relationship changes; see {@link Client#relationshipAdd} and {@link Client#relationshipRemove} for that.</info>
+   * @event Client#relationshipUpdate
+   * @param {Snowflake} user The userID that was updated
+   * @param {RelationshipUpdateObject} oldData Old data
+   * @param {RelationshipUpdateObject} newData New data
+   */
+  const oldType = client.relationships.cache.get(data.id);
+  const oldSince = client.relationships.sinceCache.get(data.id);
+  const oldNickname = client.relationships.friendNicknames.get(data.id);
+  // Update
+  if (data.type) client.relationships.cache.set(data.id, data.type);
+  if (data.nickname) client.relationships.friendNicknames.set(data.id, data.nickname);
+  if (data.since) client.relationships.sinceCache.set(data.id, new Date(data.since || 0));
+  client.emit(
+    Events.RELATIONSHIP_UPDATE,
+    data.id,
+    {
+      type: oldType,
+      nickname: oldNickname,
+      since: oldSince,
+    },
+    {
+      type: data.type,
+      nickname: data.nickname,
+      since: new Date(data.since || 0),
+    },
+  );
+};

package/src/client/websocket/handlers/RESUMED.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, packet, shard) => {
+  const replayed = shard.sequence - shard.closeSequence;
+  /**
+   * Emitted when a shard resumes successfully.
+   * @event Client#shardResume
+   * @param {number} id The shard id that resumed
+   * @param {number} replayedEvents The amount of replayed events
+   */
+  client.emit(Events.SHARD_RESUME, shard.id, replayed);
+};

package/src/client/websocket/handlers/STAGE_INSTANCE_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.StageInstanceCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/STAGE_INSTANCE_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.StageInstanceDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/STAGE_INSTANCE_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.StageInstanceUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/THREAD_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ThreadCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/THREAD_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ThreadDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/THREAD_LIST_SYNC.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ThreadListSync.handle(packet.d);
+};

package/src/client/websocket/handlers/THREAD_MEMBERS_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ThreadMembersUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/THREAD_MEMBER_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ThreadMemberUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/THREAD_UPDATE.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, packet) => {
+  const { old, updated } = client.actions.ChannelUpdate.handle(packet.d);
+  if (old && updated) {
+    /**
+     * Emitted whenever a thread is updated - e.g. name change, archive state change, locked state change.
+     * @event Client#threadUpdate
+     * @param {ThreadChannel} oldThread The thread before the update
+     * @param {ThreadChannel} newThread The thread after the update
+     */
+    client.emit(Events.THREAD_UPDATE, old, updated);
+  }
+};

package/src/client/websocket/handlers/TYPING_START.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.TypingStart.handle(packet.d);
+};

package/src/client/websocket/handlers/USER_GUILD_SETTINGS_UPDATE.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (guild) guild?.settings._patch(data);
+};

package/src/client/websocket/handlers/USER_NOTE_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, { d: data }) => {
+  client.notes.cache.set(data.id, data.note);
+};

package/src/client/websocket/handlers/USER_REQUIRED_ACTION_UPDATE.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+const { hasListener } = require('../../../util/ListenerUtil');
+
+module.exports = (client, { d: data }) => {
+  const hasDebugListener = hasListener(client, Events.DEBUG);
+  const emitDebug = message => {
+    if (hasDebugListener) {
+      client.emit(Events.DEBUG, message);
+    }
+  };
+
+  let msg;
+  switch (data.required_action) {
+    case undefined:
+    case null: {
+      msg = 'All required actions have been completed.';
+      break;
+    }
+    case 'AGREEMENTS': {
+      msg = 'You need to accept the new Terms of Service and Privacy Policy.';
+      // https://discord.com/api/v9/users/@me/agreements
+      client.api
+        .users('@me')
+        .agreements.patch({
+          data: {
+            terms: true,
+            privacy: true,
+          },
+        })
+        .then(() => {
+          emitDebug('[USER_REQUIRED_ACTION] Successfully accepted the new Terms of Service and Privacy Policy.');
+        })
+        .catch(e => {
+          emitDebug(`[USER_REQUIRED_ACTION] Failed to accept the new Terms of Service and Privacy Policy: ${e}`);
+        });
+      break;
+    }
+    case 'REQUIRE_CAPTCHA': {
+      msg = 'You need to complete a captcha.';
+      break;
+    }
+    case 'REQUIRE_VERIFIED_EMAIL': {
+      msg = 'You need to verify your email.';
+      break;
+    }
+    case 'REQUIRE_REVERIFIED_EMAIL': {
+      msg = 'You need to reverify your email.';
+      break;
+    }
+    case 'REQUIRE_VERIFIED_PHONE': {
+      msg = 'You need to verify your phone number.';
+      break;
+    }
+    case 'REQUIRE_REVERIFIED_PHONE': {
+      msg = 'You need to reverify your phone number.';
+      break;
+    }
+    case 'REQUIRE_VERIFIED_EMAIL_OR_VERIFIED_PHONE': {
+      msg = 'You need to verify your email or verify your phone number.';
+      break;
+    }
+    case 'REQUIRE_REVERIFIED_EMAIL_OR_VERIFIED_PHONE': {
+      msg = 'You need to reverify your email or verify your phone number.';
+      break;
+    }
+    case 'REQUIRE_VERIFIED_EMAIL_OR_REVERIFIED_PHONE': {
+      msg = 'You need to verify your email or reverify your phone number.';
+      break;
+    }
+    case 'REQUIRE_REVERIFIED_EMAIL_OR_REVERIFIED_PHONE': {
+      msg = 'You need to reverify your email or reverify your phone number.';
+      break;
+    }
+    default: {
+      msg = `Unknown required action: ${data.required_action}`;
+      break;
+    }
+  }
+  emitDebug(`[USER_REQUIRED_ACTION] ${msg}`);
+};

package/src/client/websocket/handlers/USER_SETTINGS_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, { d: data }) => {
+  client.settings._patch(data);
+};

package/src/client/websocket/handlers/USER_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.UserUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/VOICE_CHANNEL_EFFECT_SEND.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const VoiceChannelEffect = require('../../../structures/VoiceChannelEffect');
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  /**
+   * Emmited when someone sends an effect, such as an emoji reaction, in a voice channel the client is connected to.
+   * @event Client#voiceChannelEffectSend
+   * @param {VoiceChannelEffect} voiceChannelEffect The sent voice channel effect
+   */
+  client.emit(Events.VOICE_CHANNEL_EFFECT_SEND, new VoiceChannelEffect(data, guild));
+};

package/src/client/websocket/handlers/VOICE_CHANNEL_STATUS_UPDATE.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.id);
+  if (channel) {
+    const old = channel._clone();
+    channel.status = data.status;
+    client.emit(Events.CHANNEL_UPDATE, old, channel);
+  }
+};

package/src/client/websocket/handlers/VOICE_SERVER_UPDATE.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+const { hasListener } = require('../../../util/ListenerUtil');
+
+module.exports = (client, packet) => {
+  const hasDebugListener = hasListener(client, Events.DEBUG);
+  if (hasDebugListener) {
+    client.emit(Events.DEBUG, `[VOICE] received voice server: ${JSON.stringify(packet)}`);
+  }
+  client.voice.onVoiceServer(packet.d);
+};

package/src/client/websocket/handlers/VOICE_STATE_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.VoiceStateUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/WEBHOOKS_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.WebhooksUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/index.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const handlers = Object.fromEntries([
+  ['READY', require('./READY')],
+  ['RESUMED', require('./RESUMED')],
+  ['APPLICATION_COMMAND_CREATE', require('./APPLICATION_COMMAND_CREATE')],
+  ['APPLICATION_COMMAND_DELETE', require('./APPLICATION_COMMAND_DELETE')],
+  ['APPLICATION_COMMAND_UPDATE', require('./APPLICATION_COMMAND_UPDATE')],
+  ['APPLICATION_COMMAND_PERMISSIONS_UPDATE', require('./APPLICATION_COMMAND_PERMISSIONS_UPDATE')],
+  ['AUTO_MODERATION_ACTION_EXECUTION', require('./AUTO_MODERATION_ACTION_EXECUTION')],
+  ['AUTO_MODERATION_RULE_CREATE', require('./AUTO_MODERATION_RULE_CREATE')],
+  ['AUTO_MODERATION_RULE_DELETE', require('./AUTO_MODERATION_RULE_DELETE')],
+  ['AUTO_MODERATION_RULE_UPDATE', require('./AUTO_MODERATION_RULE_UPDATE')],
+  ['GUILD_CREATE', require('./GUILD_CREATE')],
+  ['GUILD_DELETE', require('./GUILD_DELETE')],
+  ['GUILD_UPDATE', require('./GUILD_UPDATE')],
+  ['INVITE_CREATE', require('./INVITE_CREATE')],
+  ['INVITE_DELETE', require('./INVITE_DELETE')],
+  ['GUILD_MEMBER_ADD', require('./GUILD_MEMBER_ADD')],
+  ['GUILD_MEMBER_REMOVE', require('./GUILD_MEMBER_REMOVE')],
+  ['GUILD_MEMBER_UPDATE', require('./GUILD_MEMBER_UPDATE')],
+  ['GUILD_MEMBERS_CHUNK', require('./GUILD_MEMBERS_CHUNK')],
+  ['GUILD_INTEGRATIONS_UPDATE', require('./GUILD_INTEGRATIONS_UPDATE')],
+  ['GUILD_ROLE_CREATE', require('./GUILD_ROLE_CREATE')],
+  ['GUILD_ROLE_DELETE', require('./GUILD_ROLE_DELETE')],
+  ['GUILD_ROLE_UPDATE', require('./GUILD_ROLE_UPDATE')],
+  ['GUILD_BAN_ADD', require('./GUILD_BAN_ADD')],
+  ['GUILD_BAN_REMOVE', require('./GUILD_BAN_REMOVE')],
+  ['GUILD_EMOJIS_UPDATE', require('./GUILD_EMOJIS_UPDATE')],
+  ['CHANNEL_CREATE', require('./CHANNEL_CREATE')],
+  ['CHANNEL_DELETE', require('./CHANNEL_DELETE')],
+  ['CHANNEL_UPDATE', require('./CHANNEL_UPDATE')],
+  ['CHANNEL_PINS_UPDATE', require('./CHANNEL_PINS_UPDATE')],
+  ['MESSAGE_CREATE', require('./MESSAGE_CREATE')],
+  ['MESSAGE_DELETE', require('./MESSAGE_DELETE')],
+  ['MESSAGE_UPDATE', require('./MESSAGE_UPDATE')],
+  ['MESSAGE_DELETE_BULK', require('./MESSAGE_DELETE_BULK')],
+  ['MESSAGE_REACTION_ADD', require('./MESSAGE_REACTION_ADD')],
+  ['MESSAGE_REACTION_REMOVE', require('./MESSAGE_REACTION_REMOVE')],
+  ['MESSAGE_REACTION_REMOVE_ALL', require('./MESSAGE_REACTION_REMOVE_ALL')],
+  ['MESSAGE_REACTION_REMOVE_EMOJI', require('./MESSAGE_REACTION_REMOVE_EMOJI')],
+  ['THREAD_CREATE', require('./THREAD_CREATE')],
+  ['THREAD_UPDATE', require('./THREAD_UPDATE')],
+  ['THREAD_DELETE', require('./THREAD_DELETE')],
+  ['THREAD_LIST_SYNC', require('./THREAD_LIST_SYNC')],
+  ['THREAD_MEMBER_UPDATE', require('./THREAD_MEMBER_UPDATE')],
+  ['THREAD_MEMBERS_UPDATE', require('./THREAD_MEMBERS_UPDATE')],
+  ['USER_UPDATE', require('./USER_UPDATE')],
+  ['PRESENCE_UPDATE', require('./PRESENCE_UPDATE')],
+  ['TYPING_START', require('./TYPING_START')],
+  ['VOICE_CHANNEL_EFFECT_SEND', require('./VOICE_CHANNEL_EFFECT_SEND')],
+  ['VOICE_STATE_UPDATE', require('./VOICE_STATE_UPDATE')],
+  ['VOICE_SERVER_UPDATE', require('./VOICE_SERVER_UPDATE')],
+  ['WEBHOOKS_UPDATE', require('./WEBHOOKS_UPDATE')],
+  ['STAGE_INSTANCE_CREATE', require('./STAGE_INSTANCE_CREATE')],
+  ['STAGE_INSTANCE_UPDATE', require('./STAGE_INSTANCE_UPDATE')],
+  ['STAGE_INSTANCE_DELETE', require('./STAGE_INSTANCE_DELETE')],
+  ['GUILD_STICKERS_UPDATE', require('./GUILD_STICKERS_UPDATE')],
+  ['GUILD_SCHEDULED_EVENT_CREATE', require('./GUILD_SCHEDULED_EVENT_CREATE')],
+  ['GUILD_SCHEDULED_EVENT_UPDATE', require('./GUILD_SCHEDULED_EVENT_UPDATE')],
+  ['GUILD_SCHEDULED_EVENT_DELETE', require('./GUILD_SCHEDULED_EVENT_DELETE')],
+  ['GUILD_SCHEDULED_EVENT_USER_ADD', require('./GUILD_SCHEDULED_EVENT_USER_ADD')],
+  ['GUILD_SCHEDULED_EVENT_USER_REMOVE', require('./GUILD_SCHEDULED_EVENT_USER_REMOVE')],
+  ['GUILD_AUDIT_LOG_ENTRY_CREATE', require('./GUILD_AUDIT_LOG_ENTRY_CREATE')],
+  // Selfbot
+  ['RELATIONSHIP_ADD', require('./RELATIONSHIP_ADD')],
+  ['RELATIONSHIP_REMOVE', require('./RELATIONSHIP_REMOVE')],
+  ['RELATIONSHIP_UPDATE', require('./RELATIONSHIP_UPDATE')],
+  ['USER_NOTE_UPDATE', require('./USER_NOTE_UPDATE')],
+  ['CHANNEL_RECIPIENT_ADD', require('./CHANNEL_RECIPIENT_ADD')],
+  ['CHANNEL_RECIPIENT_REMOVE', require('./CHANNEL_RECIPIENT_REMOVE')],
+  ['INTERACTION_MODAL_CREATE', require('./INTERACTION_MODAL_CREATE')],
+  ['USER_REQUIRED_ACTION_UPDATE', require('./USER_REQUIRED_ACTION_UPDATE')],
+  ['CALL_CREATE', require('./CALL_CREATE')],
+  ['CALL_UPDATE', require('./CALL_UPDATE')],
+  ['CALL_DELETE', require('./CALL_DELETE')],
+  ['USER_SETTINGS_UPDATE', require('./USER_SETTINGS_UPDATE')],
+  ['USER_GUILD_SETTINGS_UPDATE', require('./USER_GUILD_SETTINGS_UPDATE')],
+  ['VOICE_CHANNEL_STATUS_UPDATE', require('./VOICE_CHANNEL_STATUS_UPDATE')],
+  ['MESSAGE_POLL_VOTE_ADD', require('./MESSAGE_POLL_VOTE_ADD')],
+  ['MESSAGE_POLL_VOTE_REMOVE', require('./MESSAGE_POLL_VOTE_REMOVE')],
+]);
+
+module.exports = handlers;

package/src/errors/DJSError.js

@@ -0,0 +1,61 @@
+'use strict';
+
+// Heavily inspired by node's `internal/errors` module
+
+const kCode = Symbol('code');
+const messages = new Map();
+
+/**
+ * Extend an error of some sort into a DiscordjsError.
+ * @param {Error} Base Base error to extend
+ * @returns {DiscordjsError}
+ */
+function makeDiscordjsError(Base) {
+  return class DiscordjsError extends Base {
+    constructor(key, ...args) {
+      super(message(key, args));
+      this[kCode] = key;
+      if (Error.captureStackTrace) Error.captureStackTrace(this, DiscordjsError);
+    }
+
+    get name() {
+      return `${super.name} [${this[kCode]}]`;
+    }
+
+    get code() {
+      return this[kCode];
+    }
+  };
+}
+
+/**
+ * Format the message for an error.
+ * @param {string} key Error key
+ * @param {Array<*>} args Arguments to pass for util format or as function args
+ * @returns {string} Formatted string
+ */
+function message(key, args) {
+  if (typeof key !== 'string') throw new Error('Error message key must be a string');
+  const msg = messages.get(key);
+  if (!msg) throw new Error(`An invalid error message key was used: ${key}.`);
+  if (typeof msg === 'function') return msg(...args);
+  if (!args?.length) return msg;
+  args.unshift(msg);
+  return String(...args);
+}
+
+/**
+ * Register an error code and message.
+ * @param {string} sym Unique name for the error
+ * @param {*} val Value of the error
+ */
+function register(sym, val) {
+  messages.set(sym, typeof val === 'function' ? val : String(val));
+}
+
+module.exports = {
+  register,
+  Error: makeDiscordjsError(Error),
+  TypeError: makeDiscordjsError(TypeError),
+  RangeError: makeDiscordjsError(RangeError),
+};