@ovencord/discord.js 14.16.3

package/src/client/actions/Action.ts

@@ -0,0 +1,141 @@
+import { Poll  } from '../../structures/Poll.js';
+import { PollAnswer  } from '../../structures/PollAnswer.js';
+import { Partials  } from '../../util/Partials.js';
+
+/*
+
+ABOUT ACTIONS
+
+Actions are similar to WebSocket Packet Handlers, but since introducing
+the REST API methods, in order to prevent rewriting code to handle data,
+"actions" have been introduced. They're basically what Packet Handlers
+used to be but they're strictly for manipulating data and making sure
+that WebSocket events don't clash with REST methods.
+
+*/
+
+export class Action {
+  public client: any;
+  constructor(client) {
+    this.client = client;
+  }
+
+  handle(data) {
+    return data;
+  }
+
+  getPayload(data, manager, id, partialType, cache) {
+    return this.client.options.partials.includes(partialType) ? manager._add(data, cache) : manager.cache.get(id);
+  }
+
+  getChannel(data) {
+    const payloadData = {};
+    const id = data.channel_id ?? data.id;
+
+    if (!('recipients' in data)) {
+      // Try to resolve the recipient, but do not add the client user.
+      const recipient = data.author ?? data.user ?? { id: data.user_id };
+      if (recipient.id !== this.client.user.id) payloadData.recipients = [recipient];
+    }
+
+    if (id !== undefined) payloadData.id = id;
+
+    return (
+      data[this.client.actions.injectedChannel] ??
+      this.getPayload({ ...data, ...payloadData }, this.client.channels, id, Partials.Channel)
+    );
+  }
+
+  getMessage(data, channel, cache) {
+    const id = data.message_id ?? data.id;
+    return (
+      data[this.client.actions.injectedMessage] ??
+      this.getPayload(
+        {
+          id,
+          channel_id: channel.id,
+          guild_id: data.guild_id ?? channel.guild?.id,
+        },
+        channel.messages,
+        id,
+        Partials.Message,
+        cache,
+      )
+    );
+  }
+
+  getPoll(data, message, channel) {
+    const includePollPartial = this.client.options.partials.includes(Partials.Poll);
+    const includePollAnswerPartial = this.client.options.partials.includes(Partials.PollAnswer);
+    if (message.partial && (!includePollPartial || !includePollAnswerPartial)) return null;
+
+    if (!message.poll && includePollPartial) {
+      message.poll = new Poll(this.client, data, message, channel);
+    }
+
+    if (message.poll && !message.poll.answers.has(data.answer_id) && includePollAnswerPartial) {
+      const pollAnswer = new PollAnswer(this.client, data, message.poll);
+      message.poll.answers.set(data.answer_id, pollAnswer);
+    }
+
+    return message.poll;
+  }
+
+  getReaction(data, message, user) {
+    const id = data.emoji.id ?? decodeURIComponent(data.emoji.name);
+    return this.getPayload(
+      {
+        emoji: data.emoji,
+        count: message.partial ? null : 0,
+        me: user?.id === this.client.user.id,
+      },
+      message.reactions,
+      id,
+      Partials.Reaction,
+    );
+  }
+
+  getMember(data, guild) {
+    return this.getPayload(data, guild.members, data.user.id, Partials.GuildMember);
+  }
+
+  getUser(data) {
+    const id = data.user_id;
+    return data[this.client.actions.injectedUser] ?? this.getPayload({ id }, this.client.users, id, Partials.User);
+  }
+
+  getUserFromMember(data) {
+    if (data.guild_id && data.member?.user) {
+      const guild = this.client.guilds.cache.get(data.guild_id);
+      if (guild) {
+        return guild.members._add(data.member).user;
+      } else {
+        return this.client.users._add(data.member.user);
+      }
+    }
+
+    return this.getUser(data);
+  }
+
+  getScheduledEvent(data, guild) {
+    const id = data.guild_scheduled_event_id ?? data.id;
+    return this.getPayload(
+      { id, guild_id: data.guild_id ?? guild.id },
+      guild.scheduledEvents,
+      id,
+      Partials.GuildScheduledEvent,
+    );
+  }
+
+  getThreadMember(id, manager) {
+    return this.getPayload({ user_id: id }, manager, id, Partials.ThreadMember, false);
+  }
+
+  getSoundboardSound(data, guild) {
+    return this.getPayload(data, guild.soundboardSounds, data.sound_id, Partials.SoundboardSound);
+  }
+
+  spreadInjectedData(data) {
+    return Object.fromEntries(Object.getOwnPropertySymbols(data).map(symbol => [symbol, data[symbol]]));
+  }
+}

package/src/client/actions/ActionsManager.ts

@@ -0,0 +1,138 @@
+import { Action } from './Action.js';
+import { ChannelCreateAction } from './ChannelCreate.js';
+import { ChannelDeleteAction } from './ChannelDelete.js';
+import { ChannelUpdateAction } from './ChannelUpdate.js';
+import { GuildChannelsPositionUpdateAction } from './GuildChannelsPositionUpdate.js';
+import { GuildEmojiCreateAction } from './GuildEmojiCreate.js';
+import { GuildEmojiDeleteAction } from './GuildEmojiDelete.js';
+import { GuildEmojiUpdateAction } from './GuildEmojiUpdate.js';
+import { GuildEmojisUpdateAction } from './GuildEmojisUpdate.js';
+import { GuildMemberRemoveAction } from './GuildMemberRemove.js';
+import { GuildMemberUpdateAction } from './GuildMemberUpdate.js';
+import { GuildRoleCreateAction } from './GuildRoleCreate.js';
+import { GuildRoleDeleteAction } from './GuildRoleDelete.js';
+import { GuildRolesPositionUpdateAction } from './GuildRolesPositionUpdate.js';
+import { GuildScheduledEventDeleteAction } from './GuildScheduledEventDelete.js';
+import { GuildScheduledEventUserAddAction } from './GuildScheduledEventUserAdd.js';
+import { GuildScheduledEventUserRemoveAction } from './GuildScheduledEventUserRemove.js';
+import { GuildSoundboardSoundDeleteAction } from './GuildSoundboardSoundDelete.js';
+import { GuildStickerCreateAction } from './GuildStickerCreate.js';
+import { GuildStickerDeleteAction } from './GuildStickerDelete.js';
+import { GuildStickerUpdateAction } from './GuildStickerUpdate.js';
+import { GuildStickersUpdateAction } from './GuildStickersUpdate.js';
+import { GuildUpdateAction } from './GuildUpdate.js';
+import { InteractionCreateAction } from './InteractionCreate.js';
+import { MessageCreateAction } from './MessageCreate.js';
+import { MessageDeleteAction } from './MessageDelete.js';
+import { MessageDeleteBulkAction } from './MessageDeleteBulk.js';
+import { MessagePollVoteAddAction } from './MessagePollVoteAdd.js';
+import { MessagePollVoteRemoveAction } from './MessagePollVoteRemove.js';
+import { MessageReactionAddAction } from './MessageReactionAdd.js';
+import { MessageReactionRemoveAction } from './MessageReactionRemove.js';
+import { MessageReactionRemoveAllAction } from './MessageReactionRemoveAll.js';
+import { MessageReactionRemoveEmojiAction } from './MessageReactionRemoveEmoji.js';
+import { MessageUpdateAction } from './MessageUpdate.js';
+import { StageInstanceCreateAction } from './StageInstanceCreate.js';
+import { StageInstanceDeleteAction } from './StageInstanceDelete.js';
+import { StageInstanceUpdateAction } from './StageInstanceUpdate.js';
+import { ThreadCreateAction } from './ThreadCreate.js';
+import { ThreadMembersUpdateAction } from './ThreadMembersUpdate.js';
+import { TypingStartAction } from './TypingStart.js';
+import { UserUpdateAction } from './UserUpdate.js';
+
+export class ActionsManager {
+  public ChannelCreate: ChannelCreateAction;
+  public ChannelDelete: ChannelDeleteAction;
+  public ChannelUpdate: ChannelUpdateAction;
+  public GuildChannelsPositionUpdate: GuildChannelsPositionUpdateAction;
+  public GuildEmojiCreate: GuildEmojiCreateAction;
+  public GuildEmojiDelete: GuildEmojiDeleteAction;
+  public GuildEmojiUpdate: GuildEmojiUpdateAction;
+  public GuildEmojisUpdate: GuildEmojisUpdateAction;
+  public GuildMemberRemove: GuildMemberRemoveAction;
+  public GuildMemberUpdate: GuildMemberUpdateAction;
+  public GuildRoleCreate: GuildRoleCreateAction;
+  public GuildRoleDelete: GuildRoleDeleteAction;
+  public GuildRolesPositionUpdate: GuildRolesPositionUpdateAction;
+  public GuildScheduledEventDelete: GuildScheduledEventDeleteAction;
+  public GuildScheduledEventUserAdd: GuildScheduledEventUserAddAction;
+  public GuildScheduledEventUserRemove: GuildScheduledEventUserRemoveAction;
+  public GuildSoundboardSoundDelete: GuildSoundboardSoundDeleteAction;
+  public GuildStickerCreate: GuildStickerCreateAction;
+  public GuildStickerDelete: GuildStickerDeleteAction;
+  public GuildStickerUpdate: GuildStickerUpdateAction;
+  public GuildStickersUpdate: GuildStickersUpdateAction;
+  public GuildUpdate: GuildUpdateAction;
+  public InteractionCreate: InteractionCreateAction;
+  public MessageCreate: MessageCreateAction;
+  public MessageDelete: MessageDeleteAction;
+  public MessageDeleteBulk: MessageDeleteBulkAction;
+  public MessagePollVoteAdd: MessagePollVoteAddAction;
+  public MessagePollVoteRemove: MessagePollVoteRemoveAction;
+  public MessageReactionAdd: MessageReactionAddAction;
+  public MessageReactionRemove: MessageReactionRemoveAction;
+  public MessageReactionRemoveAll: MessageReactionRemoveAllAction;
+  public MessageReactionRemoveEmoji: MessageReactionRemoveEmojiAction;
+  public MessageUpdate: MessageUpdateAction;
+  public StageInstanceCreate: StageInstanceCreateAction;
+  public StageInstanceDelete: StageInstanceDeleteAction;
+  public StageInstanceUpdate: StageInstanceUpdateAction;
+  public ThreadCreate: ThreadCreateAction;
+  public ThreadMembersUpdate: ThreadMembersUpdateAction;
+  public TypingStart: TypingStartAction;
+  public UserUpdate: UserUpdateAction;
+  public client: any;
+  // These symbols represent fully built data that we inject at times when calling actions manually.
+  // Action#getUser, for example, will return the injected data (which is assumed to be a built structure)
+  // instead of trying to make it from provided data
+  injectedUser = Symbol('djs.actions.injectedUser');
+
+  injectedChannel = Symbol('djs.actions.injectedChannel');
+
+  injectedMessage = Symbol('djs.actions.injectedMessage');
+
+  constructor(client: any) {
+    this.client = client;
+
+    this.ChannelCreate = new ChannelCreateAction(this.client);
+    this.ChannelDelete = new ChannelDeleteAction(this.client);
+    this.ChannelUpdate = new ChannelUpdateAction(this.client);
+    this.GuildChannelsPositionUpdate = new GuildChannelsPositionUpdateAction(this.client);
+    this.GuildEmojiCreate = new GuildEmojiCreateAction(this.client);
+    this.GuildEmojiDelete = new GuildEmojiDeleteAction(this.client);
+    this.GuildEmojiUpdate = new GuildEmojiUpdateAction(this.client);
+    this.GuildEmojisUpdate = new GuildEmojisUpdateAction(this.client);
+    this.GuildMemberRemove = new GuildMemberRemoveAction(this.client);
+    this.GuildMemberUpdate = new GuildMemberUpdateAction(this.client);
+    this.GuildRoleCreate = new GuildRoleCreateAction(this.client);
+    this.GuildRoleDelete = new GuildRoleDeleteAction(this.client);
+    this.GuildRolesPositionUpdate = new GuildRolesPositionUpdateAction(this.client);
+    this.GuildScheduledEventDelete = new GuildScheduledEventDeleteAction(this.client);
+    this.GuildScheduledEventUserAdd = new GuildScheduledEventUserAddAction(this.client);
+    this.GuildScheduledEventUserRemove = new GuildScheduledEventUserRemoveAction(this.client);
+    this.GuildSoundboardSoundDelete = new GuildSoundboardSoundDeleteAction(this.client);
+    this.GuildStickerCreate = new GuildStickerCreateAction(this.client);
+    this.GuildStickerDelete = new GuildStickerDeleteAction(this.client);
+    this.GuildStickerUpdate = new GuildStickerUpdateAction(this.client);
+    this.GuildStickersUpdate = new GuildStickersUpdateAction(this.client);
+    this.GuildUpdate = new GuildUpdateAction(this.client);
+    this.InteractionCreate = new InteractionCreateAction(this.client);
+    this.MessageCreate = new MessageCreateAction(this.client);
+    this.MessageDelete = new MessageDeleteAction(this.client);
+    this.MessageDeleteBulk = new MessageDeleteBulkAction(this.client);
+    this.MessagePollVoteAdd = new MessagePollVoteAddAction(this.client);
+    this.MessagePollVoteRemove = new MessagePollVoteRemoveAction(this.client);
+    this.MessageReactionAdd = new MessageReactionAddAction(this.client);
+    this.MessageReactionRemove = new MessageReactionRemoveAction(this.client);
+    this.MessageReactionRemoveAll = new MessageReactionRemoveAllAction(this.client);
+    this.MessageReactionRemoveEmoji = new MessageReactionRemoveEmojiAction(this.client);
+    this.MessageUpdate = new MessageUpdateAction(this.client);
+    this.StageInstanceCreate = new StageInstanceCreateAction(this.client);
+    this.StageInstanceDelete = new StageInstanceDeleteAction(this.client);
+    this.StageInstanceUpdate = new StageInstanceUpdateAction(this.client);
+    this.ThreadCreate = new ThreadCreateAction(this.client);
+    this.ThreadMembersUpdate = new ThreadMembersUpdateAction(this.client);
+    this.TypingStart = new TypingStartAction(this.client);
+    this.UserUpdate = new UserUpdateAction(this.client);
+  }
+}

package/src/client/actions/ChannelCreate.ts

@@ -0,0 +1,21 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class ChannelCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const existing = client.channels.cache.has(data.id);
+    const channel = client.channels._add(data);
+    if (!existing && channel) {
+      /**
+       * Emitted whenever a guild channel is created.
+       *
+       * @event Client#channelCreate
+       * @param {GuildChannel} channel The channel that was created
+       */
+      client.emit(Events.ChannelCreate, channel);
+    }
+
+    return { channel };
+  }
+}

package/src/client/actions/ChannelDelete.ts

@@ -0,0 +1,20 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class ChannelDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.id);
+
+    if (channel) {
+      client.channels._remove(channel.id);
+      /**
+       * Emitted whenever a channel is deleted.
+       *
+       * @event Client#channelDelete
+       * @param {DMChannel|GuildChannel} channel The channel that was deleted
+       */
+      client.emit(Events.ChannelDelete, channel);
+    }
+  }
+}

package/src/client/actions/ChannelUpdate.ts

@@ -0,0 +1,38 @@
+import { createChannel  } from '../../util/Channels.js';
+import { Action  } from './Action.js';
+
+export class ChannelUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    let channel = client.channels.cache.get(data.id);
+
+    if (channel) {
+      const old = channel._update(data);
+
+      if (channel.type !== data.type) {
+        const newChannel = createChannel(this.client, data, channel.guild);
+
+        if (!newChannel) {
+          this.client.channels.cache.delete(channel.id);
+          return {};
+        }
+
+        if (channel.isTextBased() && newChannel.isTextBased()) {
+          for (const [id, message] of channel.messages.cache) newChannel.messages.cache.set(id, message);
+        }
+
+        channel = newChannel;
+        this.client.channels.cache.set(channel.id, channel);
+      }
+
+      return {
+        old,
+        updated: channel,
+      };
+    } else {
+      client.channels._add(data);
+    }
+
+    return {};
+  }
+}

package/src/client/actions/GuildChannelsPositionUpdate.ts

@@ -0,0 +1,17 @@
+import { Action  } from './Action.js';
+
+export class GuildChannelsPositionUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      for (const partialChannel of data.channels) {
+        const channel = guild.channels.cache.get(partialChannel.id);
+        if (channel) channel.rawPosition = partialChannel.position;
+      }
+    }
+
+    return { guild };
+  }
+}

package/src/client/actions/GuildEmojiCreate.ts

@@ -0,0 +1,17 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildEmojiCreateAction extends Action {
+  handle(guild, createdEmoji) {
+    const already = guild.emojis.cache.has(createdEmoji.id);
+    const emoji = guild.emojis._add(createdEmoji);
+    /**
+     * Emitted whenever a custom emoji is created in a guild.
+     *
+     * @event Client#emojiCreate
+     * @param {GuildEmoji} emoji The emoji that was created
+     */
+    if (!already) this.client.emit(Events.GuildEmojiCreate, emoji);
+    return { emoji };
+  }
+}

package/src/client/actions/GuildEmojiDelete.ts

@@ -0,0 +1,16 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildEmojiDeleteAction extends Action {
+  handle(emoji) {
+    emoji.guild.emojis.cache.delete(emoji.id);
+    /**
+     * Emitted whenever a custom emoji is deleted in a guild.
+     *
+     * @event Client#emojiDelete
+     * @param {GuildEmoji} emoji The emoji that was deleted
+     */
+    this.client.emit(Events.GuildEmojiDelete, emoji);
+    return { emoji };
+  }
+}

package/src/client/actions/GuildEmojiUpdate.ts

@@ -0,0 +1,17 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildEmojiUpdateAction extends Action {
+  handle(current, data) {
+    const old = current._update(data);
+    /**
+     * Emitted whenever a custom emoji is updated in a guild.
+     *
+     * @event Client#emojiUpdate
+     * @param {GuildEmoji} oldEmoji The old emoji
+     * @param {GuildEmoji} newEmoji The new emoji
+     */
+    this.client.emit(Events.GuildEmojiUpdate, old, current);
+    return { emoji: current };
+  }
+}

package/src/client/actions/GuildEmojisUpdate.ts

@@ -0,0 +1,30 @@
+import { Action  } from './Action.js';
+
+export class GuildEmojisUpdateAction extends Action {
+  handle(data) {
+    const guild = this.client.guilds.cache.get(data.guild_id);
+    if (!guild?.emojis) return;
+
+    const deletions = new Map(guild.emojis.cache);
+
+    for (const emoji of data.emojis) {
+      // Determine type of emoji event
+      const cachedEmoji = guild.emojis.cache.get(emoji.id);
+      if (cachedEmoji) {
+        deletions.delete(emoji.id);
+        if (!cachedEmoji.equals(emoji)) {
+          // Emoji updated
+          this.client.actions.GuildEmojiUpdate.handle(cachedEmoji, emoji);
+        }
+      } else {
+        // Emoji added
+        this.client.actions.GuildEmojiCreate.handle(guild, emoji);
+      }
+    }
+
+    for (const emoji of deletions.values()) {
+      // Emoji deleted
+      this.client.actions.GuildEmojiDelete.handle(emoji);
+    }
+  }
+}

package/src/client/actions/GuildMemberRemove.ts

@@ -0,0 +1,29 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildMemberRemoveAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    let member = null;
+    if (guild) {
+      member = this.getMember({ user: data.user }, guild);
+      guild.memberCount--;
+      if (member) {
+        guild.members.cache.delete(member.id);
+        /**
+         * Emitted whenever a member leaves a guild, or is kicked.
+         *
+         * @event Client#guildMemberRemove
+         * @param {GuildMember} member The member that has left/been kicked from the guild
+         */
+        client.emit(Events.GuildMemberRemove, member);
+      }
+
+      guild.presences.cache.delete(data.user.id);
+      guild.voiceStates.cache.delete(data.user.id);
+    }
+
+    return { guild, member };
+  }
+}

package/src/client/actions/GuildMemberUpdate.ts

@@ -0,0 +1,41 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildMemberUpdateAction extends Action {
+  handle(data) {
+    const { client } = this;
+    if (data.user.username) {
+      const user = client.users.cache.get(data.user.id);
+      if (!user) {
+        client.users._add(data.user);
+      } else if (!user._equals(data.user)) {
+        client.actions.UserUpdate.handle(data.user);
+      }
+    }
+
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      const member = this.getMember({ user: data.user }, guild);
+      if (member) {
+        const old = member._update(data);
+        /**
+         * Emitted whenever a guild member changes - i.e. new role, removed role, nickname.
+         *
+         * @event Client#guildMemberUpdate
+         * @param {GuildMember} oldMember The member before the update
+         * @param {GuildMember} newMember The member after the update
+         */
+        if (!member.equals(old)) client.emit(Events.GuildMemberUpdate, old, member);
+      } else {
+        const newMember = guild.members._add(data);
+        /**
+         * Emitted whenever a member becomes available.
+         *
+         * @event Client#guildMemberAvailable
+         * @param {GuildMember} member The member that became available
+         */
+        this.client.emit(Events.GuildMemberAvailable, newMember);
+      }
+    }
+  }
+}

package/src/client/actions/GuildRoleCreate.ts

@@ -0,0 +1,23 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildRoleCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    let role;
+    if (guild) {
+      const already = guild.roles.cache.has(data.role.id);
+      role = guild.roles._add(data.role);
+      /**
+       * Emitted whenever a role is created.
+       *
+       * @event Client#roleCreate
+       * @param {Role} role The role that was created
+       */
+      if (!already) client.emit(Events.GuildRoleCreate, role);
+    }
+
+    return { role };
+  }
+}

package/src/client/actions/GuildRoleDelete.ts

@@ -0,0 +1,26 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildRoleDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    let role;
+
+    if (guild) {
+      role = guild.roles.cache.get(data.role_id);
+      if (role) {
+        guild.roles.cache.delete(data.role_id);
+        /**
+         * Emitted whenever a guild role is deleted.
+         *
+         * @event Client#roleDelete
+         * @param {Role} role The role that was deleted
+         */
+        client.emit(Events.GuildRoleDelete, role);
+      }
+    }
+
+    return { role };
+  }
+}

package/src/client/actions/GuildRolesPositionUpdate.ts

@@ -0,0 +1,17 @@
+import { Action  } from './Action.js';
+
+export class GuildRolesPositionUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      for (const partialRole of data.roles) {
+        const role = guild.roles.cache.get(partialRole.id);
+        if (role) role.rawPosition = partialRole.position;
+      }
+    }
+
+    return { guild };
+  }
+}

package/src/client/actions/GuildScheduledEventDelete.ts

@@ -0,0 +1,28 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildScheduledEventDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const guildScheduledEvent = this.getScheduledEvent(data, guild);
+      if (guildScheduledEvent) {
+        guild.scheduledEvents.cache.delete(guildScheduledEvent.id);
+
+        /**
+         * Emitted whenever a guild scheduled event is deleted.
+         *
+         * @event Client#guildScheduledEventDelete
+         * @param {GuildScheduledEvent} guildScheduledEvent The deleted guild scheduled event
+         */
+        client.emit(Events.GuildScheduledEventDelete, guildScheduledEvent);
+
+        return { guildScheduledEvent };
+      }
+    }
+
+    return {};
+  }
+}

package/src/client/actions/GuildScheduledEventUserAdd.ts

@@ -0,0 +1,29 @@
+import { Events  } from '../../util/Events.js';
+import { Action  } from './Action.js';
+
+export class GuildScheduledEventUserAddAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const guildScheduledEvent = this.getScheduledEvent(data, guild);
+      const user = this.getUser(data);
+
+      if (guildScheduledEvent && user) {
+        /**
+         * Emitted whenever a user subscribes to a guild scheduled event
+         *
+         * @event Client#guildScheduledEventUserAdd
+         * @param {GuildScheduledEvent} guildScheduledEvent The guild scheduled event
+         * @param {User} user The user who subscribed
+         */
+        client.emit(Events.GuildScheduledEventUserAdd, guildScheduledEvent, user);
+
+        return { guildScheduledEvent, user };
+      }
+    }
+
+    return {};
+  }
+}