discord.js 15.0.0-dev.1745453588-abc5d99ce → 15.0.0-dev.1745626383-8f375275c

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "discord.js",
-  "version": "15.0.0-dev.1745453588-abc5d99ce",
+  "version": "15.0.0-dev.1745626383-8f375275c",
   "description": "A powerful library for interacting with the Discord API",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",
@@ -57,12 +57,13 @@
     "discord-api-types": "^0.38.1",
     "fast-deep-equal": "3.1.3",
     "lodash.snakecase": "4.1.1",
+    "magic-bytes.js": "^1.10.0",
     "tslib": "^2.8.1",
     "undici": "7.8.0",
-    "@discordjs/collection": "^2.1.1",
     "@discordjs/builders": "^1.9.0",
-    "@discordjs/rest": "^2.4.0",
     "@discordjs/formatters": "^0.5.0",
+    "@discordjs/rest": "^2.4.0",
+    "@discordjs/collection": "^2.1.1",
     "@discordjs/util": "^1.1.1",
     "@discordjs/ws": "^2.0.0"
   },

package/src/client/Client.js

@@ -19,6 +19,7 @@ const { ClientPresence } = require('../structures/ClientPresence.js');
 const { GuildPreview } = require('../structures/GuildPreview.js');
 const { GuildTemplate } = require('../structures/GuildTemplate.js');
 const { Invite } = require('../structures/Invite.js');
+const { SoundboardSound } = require('../structures/SoundboardSound.js');
 const { Sticker } = require('../structures/Sticker.js');
 const { StickerPack } = require('../structures/StickerPack.js');
 const { VoiceRegion } = require('../structures/VoiceRegion.js');
@@ -536,6 +537,19 @@ class Client extends BaseClient {
     return new Collection(data.sticker_packs.map(stickerPack => [stickerPack.id, new StickerPack(this, stickerPack)]));
   }
 
+  /**
+   * Obtains the list of default soundboard sounds.
+   * @returns {Promise<Collection<string, SoundboardSound>>}
+   * @example
+   * client.fetchDefaultSoundboardSounds()
+   *  .then(sounds => console.log(`Available soundboard sounds are: ${sounds.map(sound => sound.name).join(', ')}`))
+   *  .catch(console.error);
+   */
+  async fetchDefaultSoundboardSounds() {
+    const data = await this.rest.get(Routes.soundboardDefaultSounds());
+    return new Collection(data.map(sound => [sound.sound_id, new SoundboardSound(this, sound)]));
+  }
+
   /**
    * Obtains a guild preview from Discord, available for all guilds the bot is in and all Discoverable guilds.
    * @param {GuildResolvable} guild The guild to fetch the preview for

package/src/client/actions/Action.js

@@ -131,6 +131,10 @@ class Action {
     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.js

@@ -27,6 +27,7 @@ class ActionsManager {
     this.register(require('./GuildScheduledEventDelete.js').GuildScheduledEventDeleteAction);
     this.register(require('./GuildScheduledEventUserAdd.js').GuildScheduledEventUserAddAction);
     this.register(require('./GuildScheduledEventUserRemove.js').GuildScheduledEventUserRemoveAction);
+    this.register(require('./GuildSoundboardSoundDelete.js').GuildSoundboardSoundDeleteAction);
     this.register(require('./GuildStickerCreate.js').GuildStickerCreateAction);
     this.register(require('./GuildStickerDelete.js').GuildStickerDeleteAction);
     this.register(require('./GuildStickerUpdate.js').GuildStickerUpdateAction);

package/src/client/actions/GuildSoundboardSoundDelete.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { Action } = require('./Action.js');
+const { Events } = require('../../util/Events.js');
+
+class GuildSoundboardSoundDeleteAction extends Action {
+  handle(data) {
+    const guild = this.client.guilds.cache.get(data.guild_id);
+
+    if (!guild) return {};
+
+    const soundboardSound = this.getSoundboardSound(data, guild);
+
+    if (soundboardSound) {
+      guild.soundboardSounds.cache.delete(soundboardSound.soundId);
+
+      /**
+       * Emitted whenever a soundboard sound is deleted in a guild.
+       * @event Client#guildSoundboardSoundDelete
+       * @param {SoundboardSound} soundboardSound The soundboard sound that was deleted
+       */
+      this.client.emit(Events.GuildSoundboardSoundDelete, soundboardSound);
+    }
+
+    return { soundboardSound };
+  }
+}
+
+exports.GuildSoundboardSoundDeleteAction = GuildSoundboardSoundDeleteAction;

package/src/client/actions/InteractionCreate.js

@@ -9,6 +9,7 @@ const { ChatInputCommandInteraction } = require('../../structures/ChatInputComma
 const { MentionableSelectMenuInteraction } = require('../../structures/MentionableSelectMenuInteraction.js');
 const { MessageContextMenuCommandInteraction } = require('../../structures/MessageContextMenuCommandInteraction.js');
 const { ModalSubmitInteraction } = require('../../structures/ModalSubmitInteraction.js');
+const { PrimaryEntryPointCommandInteraction } = require('../../structures/PrimaryEntryPointCommandInteraction.js');
 const { RoleSelectMenuInteraction } = require('../../structures/RoleSelectMenuInteraction.js');
 const { StringSelectMenuInteraction } = require('../../structures/StringSelectMenuInteraction.js');
 const { UserContextMenuCommandInteraction } = require('../../structures/UserContextMenuCommandInteraction.js');
@@ -38,6 +39,9 @@ class InteractionCreateAction extends Action {
             if (channel && !channel.isTextBased()) return;
             InteractionClass = MessageContextMenuCommandInteraction;
             break;
+          case ApplicationCommandType.PrimaryEntryPoint:
+            InteractionClass = PrimaryEntryPointCommandInteraction;
+            break;
           default:
             client.emit(
               Events.Debug,

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

@@ -0,0 +1,24 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { Events } = require('../../../util/Events.js');
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+
+  if (!guild) return;
+
+  const soundboardSounds = new Collection();
+
+  for (const soundboardSound of data.soundboard_sounds) {
+    soundboardSounds.set(soundboardSound.sound_id, guild.soundboardSounds._add(soundboardSound));
+  }
+
+  /**
+   * Emitted whenever multiple guild soundboard sounds are updated.
+   * @event Client#guildSoundboardSoundsUpdate
+   * @param {Collection<Snowflake, SoundboardSound>} soundboardSounds The updated soundboard sounds
+   * @param {Guild} guild The guild that the soundboard sounds are from
+   */
+  client.emit(Events.GuildSoundboardSoundsUpdate, soundboardSounds, guild);
+};

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

@@ -0,0 +1,18 @@
+'use strict';
+
+const { Events } = require('../../../util/Events.js');
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+
+  if (!guild) return;
+
+  const soundboardSound = guild.soundboardSounds._add(data);
+
+  /**
+   * Emitted whenever a guild soundboard sound is created.
+   * @event Client#guildSoundboardSoundCreate
+   * @param {SoundboardSound} soundboardSound The created guild soundboard sound
+   */
+  client.emit(Events.GuildSoundboardSoundCreate, soundboardSound);
+};

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

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

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

@@ -0,0 +1,20 @@
+'use strict';
+
+const { Events } = require('../../../util/Events.js');
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+
+  if (!guild) return;
+
+  const oldGuildSoundboardSound = guild.soundboardSounds.cache.get(data.sound_id)?._clone() ?? null;
+  const newGuildSoundboardSound = guild.soundboardSounds._add(data);
+
+  /**
+   * Emitted whenever a guild soundboard sound is updated.
+   * @event Client#guildSoundboardSoundUpdate
+   * @param {?SoundboardSound} oldGuildSoundboardSound The guild soundboard sound before the update
+   * @param {SoundboardSound} newGuildSoundboardSound The guild soundboard sound after the update
+   */
+  client.emit(Events.GuildSoundboardSoundUpdate, oldGuildSoundboardSound, newGuildSoundboardSound);
+};

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

@@ -0,0 +1,24 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { Events } = require('../../../util/Events.js');
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+
+  if (!guild) return;
+
+  const soundboardSounds = new Collection();
+
+  for (const soundboardSound of data.soundboard_sounds) {
+    soundboardSounds.set(soundboardSound.sound_id, guild.soundboardSounds._add(soundboardSound));
+  }
+
+  /**
+   * Emitted whenever soundboard sounds are received (all soundboard sounds come from the same guild).
+   * @event Client#soundboardSounds
+   * @param {Collection<Snowflake, SoundboardSound>} soundboardSounds The sounds received
+   * @param {Guild} guild The guild that the soundboard sounds are from
+   */
+  client.emit(Events.SoundboardSounds, soundboardSounds, guild);
+};

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

@@ -32,6 +32,10 @@ const PacketHandlers = Object.fromEntries([
   ['GUILD_SCHEDULED_EVENT_UPDATE', require('./GUILD_SCHEDULED_EVENT_UPDATE.js')],
   ['GUILD_SCHEDULED_EVENT_USER_ADD', require('./GUILD_SCHEDULED_EVENT_USER_ADD.js')],
   ['GUILD_SCHEDULED_EVENT_USER_REMOVE', require('./GUILD_SCHEDULED_EVENT_USER_REMOVE.js')],
+  ['GUILD_SOUNDBOARD_SOUNDS_UPDATE', require('./GUILD_SOUNDBOARD_SOUNDS_UPDATE.js')],
+  ['GUILD_SOUNDBOARD_SOUND_CREATE', require('./GUILD_SOUNDBOARD_SOUND_CREATE.js')],
+  ['GUILD_SOUNDBOARD_SOUND_DELETE', require('./GUILD_SOUNDBOARD_SOUND_DELETE.js')],
+  ['GUILD_SOUNDBOARD_SOUND_UPDATE', require('./GUILD_SOUNDBOARD_SOUND_UPDATE.js')],
   ['GUILD_STICKERS_UPDATE', require('./GUILD_STICKERS_UPDATE.js')],
   ['GUILD_UPDATE', require('./GUILD_UPDATE.js')],
   ['INTERACTION_CREATE', require('./INTERACTION_CREATE.js')],
@@ -49,6 +53,7 @@ const PacketHandlers = Object.fromEntries([
   ['MESSAGE_UPDATE', require('./MESSAGE_UPDATE.js')],
   ['PRESENCE_UPDATE', require('./PRESENCE_UPDATE.js')],
   ['READY', require('./READY.js')],
+  ['SOUNDBOARD_SOUNDS', require('./SOUNDBOARD_SOUNDS.js')],
   ['STAGE_INSTANCE_CREATE', require('./STAGE_INSTANCE_CREATE.js')],
   ['STAGE_INSTANCE_DELETE', require('./STAGE_INSTANCE_DELETE.js')],
   ['STAGE_INSTANCE_UPDATE', require('./STAGE_INSTANCE_UPDATE.js')],

package/src/errors/ErrorCodes.js

@@ -61,6 +61,7 @@
  * @property {'GuildChannelUnowned'} GuildChannelUnowned
  * @property {'GuildOwned'} GuildOwned
  * @property {'GuildMembersTimeout'} GuildMembersTimeout
+ * @property {'GuildSoundboardSoundsTimeout'} GuildSoundboardSoundsTimeout
  * @property {'GuildUncachedMe'} GuildUncachedMe
  * @property {'ChannelNotCached'} ChannelNotCached
  * @property {'StageChannelResolve'} StageChannelResolve
@@ -85,6 +86,8 @@
  * @property {'EmojiManaged'} EmojiManaged
  * @property {'MissingManageGuildExpressionsPermission'} MissingManageGuildExpressionsPermission
  *
+
+ * @property {'NotGuildSoundboardSound'} NotGuildSoundboardSound
  * @property {'NotGuildSticker'} NotGuildSticker
 
  * @property {'ReactionResolveUser'} ReactionResolveUser
@@ -193,6 +196,7 @@ const keys = [
   'GuildChannelUnowned',
   'GuildOwned',
   'GuildMembersTimeout',
+  'GuildSoundboardSoundsTimeout',
   'GuildUncachedMe',
   'ChannelNotCached',
   'StageChannelResolve',
@@ -217,6 +221,7 @@ const keys = [
   'EmojiManaged',
   'MissingManageGuildExpressionsPermission',
 
+  'NotGuildSoundboardSound',
   'NotGuildSticker',
 
   'ReactionResolveUser',

package/src/errors/Messages.js

@@ -66,6 +66,7 @@ const Messages = {
   [ErrorCodes.GuildChannelUnowned]: "The fetched channel does not belong to this manager's guild.",
   [ErrorCodes.GuildOwned]: 'Guild is owned by the client.',
   [ErrorCodes.GuildMembersTimeout]: "Members didn't arrive in time.",
+  [ErrorCodes.GuildSoundboardSoundsTimeout]: "Soundboard sounds didn't arrive in time.",
   [ErrorCodes.GuildUncachedMe]: 'The client user as a member of this guild is uncached.',
   [ErrorCodes.ChannelNotCached]: 'Could not find the channel where this message came from in the cache!',
   [ErrorCodes.StageChannelResolve]: 'Could not resolve channel to a stage channel.',
@@ -91,6 +92,8 @@ const Messages = {
   [ErrorCodes.MissingManageGuildExpressionsPermission]: guild =>
     `Client must have Manage Guild Expressions permission in guild ${guild} to see emoji authors.`,
 
+  [ErrorCodes.NotGuildSoundboardSound]: action =>
+    `Soundboard sound is a default (non-guild) soundboard sound and can't be ${action}.`,
   [ErrorCodes.NotGuildSticker]: 'Sticker is a standard (non-guild) sticker and has no author.',
 
   [ErrorCodes.ReactionResolveUser]: "Couldn't resolve the user id to remove from the reaction.",

package/src/index.js

@@ -74,6 +74,7 @@ exports.GuildMemberManager = require('./managers/GuildMemberManager.js').GuildMe
 exports.GuildMemberRoleManager = require('./managers/GuildMemberRoleManager.js').GuildMemberRoleManager;
 exports.GuildMessageManager = require('./managers/GuildMessageManager.js').GuildMessageManager;
 exports.GuildScheduledEventManager = require('./managers/GuildScheduledEventManager.js').GuildScheduledEventManager;
+exports.GuildSoundboardSoundManager = require('./managers/GuildSoundboardSoundManager.js').GuildSoundboardSoundManager;
 exports.GuildStickerManager = require('./managers/GuildStickerManager.js').GuildStickerManager;
 exports.GuildTextThreadManager = require('./managers/GuildTextThreadManager.js').GuildTextThreadManager;
 exports.MessageManager = require('./managers/MessageManager.js').MessageManager;
@@ -186,6 +187,8 @@ exports.PartialGroupDMChannel = require('./structures/PartialGroupDMChannel.js')
 exports.PermissionOverwrites = require('./structures/PermissionOverwrites.js').PermissionOverwrites;
 exports.Poll = require('./structures/Poll.js').Poll;
 exports.PollAnswer = require('./structures/PollAnswer.js').PollAnswer;
+exports.PrimaryEntryPointCommandInteraction =
+  require('./structures/PrimaryEntryPointCommandInteraction.js').PrimaryEntryPointCommandInteraction;
 exports.Presence = require('./structures/Presence.js').Presence;
 exports.ReactionCollector = require('./structures/ReactionCollector.js').ReactionCollector;
 exports.ReactionEmoji = require('./structures/ReactionEmoji.js').ReactionEmoji;
@@ -194,6 +197,7 @@ exports.Role = require('./structures/Role.js').Role;
 exports.RoleSelectMenuComponent = require('./structures/RoleSelectMenuComponent.js').RoleSelectMenuComponent;
 exports.RoleSelectMenuInteraction = require('./structures/RoleSelectMenuInteraction.js').RoleSelectMenuInteraction;
 exports.SKU = require('./structures/SKU.js').SKU;
+exports.SoundboardSound = require('./structures/SoundboardSound.js').SoundboardSound;
 exports.StageChannel = require('./structures/StageChannel.js').StageChannel;
 exports.StageInstance = require('./structures/StageInstance.js').StageInstance;
 exports.Sticker = require('./structures/Sticker.js').Sticker;

package/src/managers/ApplicationCommandManager.js

@@ -282,6 +282,7 @@ class ApplicationCommandManager extends CachedManager {
       default_member_permissions,
       integration_types: command.integrationTypes ?? command.integration_types,
       contexts: command.contexts,
+      handler: command.handler,
     };
   }
 }

package/src/managers/GuildManager.js

@@ -4,8 +4,9 @@ const process = require('node:process');
 const { setTimeout, clearTimeout } = require('node:timers');
 const { Collection } = require('@discordjs/collection');
 const { makeURLSearchParams } = require('@discordjs/rest');
-const { Routes, RouteBases } = require('discord-api-types/v10');
+const { GatewayOpcodes, Routes, RouteBases } = require('discord-api-types/v10');
 const { CachedManager } = require('./CachedManager.js');
+const { DiscordjsError, ErrorCodes } = require('../errors/index.js');
 const { ShardClientUtil } = require('../sharding/ShardClientUtil.js');
 const { Guild } = require('../structures/Guild.js');
 const { GuildChannel } = require('../structures/GuildChannel.js');
@@ -282,6 +283,71 @@ class GuildManager extends CachedManager {
     return data.reduce((coll, guild) => coll.set(guild.id, new OAuth2Guild(this.client, guild)), new Collection());
   }
 
+  /**
+   * @typedef {Object} FetchSoundboardSoundsOptions
+   * @param {Snowflake[]} guildIds The ids of the guilds to fetch soundboard sounds for
+   * @param {number} [time=10_000] The timeout for receipt of the soundboard sounds
+   */
+
+  /**
+   * Fetches soundboard sounds for the specified guilds.
+   * @param {FetchSoundboardSoundsOptions} options The options for fetching soundboard sounds
+   * @returns {Promise<Collection<Snowflake, Collection<Snowflake, SoundboardSound>>>}
+   * @example
+   * // Fetch soundboard sounds for multiple guilds
+   * const soundboardSounds = await client.guilds.fetchSoundboardSounds({
+   *  guildIds: ['123456789012345678', '987654321098765432'],
+   * })
+   *
+   * console.log(soundboardSounds.get('123456789012345678'));
+   */
+  async fetchSoundboardSounds({ guildIds, time = 10_000 }) {
+    const shardCount = await this.client.ws.getShardCount();
+    const shardIds = Map.groupBy(guildIds, guildId => ShardClientUtil.shardIdForGuildId(guildId, shardCount));
+
+    for (const [shardId, shardGuildIds] of shardIds) {
+      this.client.ws.send(shardId, {
+        op: GatewayOpcodes.RequestSoundboardSounds,
+        d: {
+          guild_ids: shardGuildIds,
+        },
+      });
+    }
+
+    return new Promise((resolve, reject) => {
+      const remainingGuildIds = new Set(guildIds);
+
+      const fetchedSoundboardSounds = new Collection();
+
+      const handler = (soundboardSounds, guild) => {
+        timeout.refresh();
+
+        if (!remainingGuildIds.has(guild.id)) return;
+
+        fetchedSoundboardSounds.set(guild.id, soundboardSounds);
+
+        remainingGuildIds.delete(guild.id);
+
+        if (remainingGuildIds.size === 0) {
+          clearTimeout(timeout);
+          this.client.removeListener(Events.SoundboardSounds, handler);
+          this.client.decrementMaxListeners();
+
+          resolve(fetchedSoundboardSounds);
+        }
+      };
+
+      const timeout = setTimeout(() => {
+        this.client.removeListener(Events.SoundboardSounds, handler);
+        this.client.decrementMaxListeners();
+        reject(new DiscordjsError(ErrorCodes.GuildSoundboardSoundsTimeout));
+      }, time).unref();
+
+      this.client.incrementMaxListeners();
+      this.client.on(Events.SoundboardSounds, handler);
+    });
+  }
+
   /**
    * Options used to set incident actions. Supplying `null` to any option will disable the action.
    * @typedef {Object} IncidentActionsEditOptions

package/src/managers/GuildSoundboardSoundManager.js

@@ -0,0 +1,192 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { lazy } = require('@discordjs/util');
+const { Routes } = require('discord-api-types/v10');
+const { CachedManager } = require('./CachedManager.js');
+const { DiscordjsTypeError, ErrorCodes } = require('../errors/index.js');
+const { SoundboardSound } = require('../structures/SoundboardSound.js');
+const { resolveBase64, resolveFile } = require('../util/DataResolver.js');
+
+const fileTypeMime = lazy(() => require('magic-bytes.js').filetypemime);
+
+/**
+ * Manages API methods for Soundboard Sounds and stores their cache.
+ * @extends {CachedManager}
+ */
+class GuildSoundboardSoundManager extends CachedManager {
+  constructor(guild, iterable) {
+    super(guild.client, SoundboardSound, iterable);
+
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of Soundboard Sounds
+   * @type {Collection<Snowflake, SoundboardSound>}
+   * @name GuildSoundboardSoundManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { extras: [this.guild], id: data.sound_id });
+  }
+
+  /**
+   * Data that resolves to give a SoundboardSound object. This can be:
+   * * A SoundboardSound object
+   * * A Snowflake
+   * @typedef {SoundboardSound|Snowflake} SoundboardSoundResolvable
+   */
+
+  /**
+   * Resolves a SoundboardSoundResolvable to a SoundboardSound object.
+   * @method resolve
+   * @memberof GuildSoundboardSoundManager
+   * @instance
+   * @param {SoundboardSoundResolvable} soundboardSound The SoundboardSound resolvable to identify
+   * @returns {?SoundboardSound}
+   */
+
+  /**
+   * Resolves a {@link SoundboardSoundResolvable} to a {@link SoundboardSound} id.
+   * @param {SoundboardSoundResolvable} soundboardSound The soundboard sound resolvable to resolve
+   * @returns {?Snowflake}
+   */
+  resolveId(soundboardSound) {
+    if (soundboardSound instanceof this.holds) return soundboardSound.soundId;
+    if (typeof soundboardSound === 'string') return soundboardSound;
+    return null;
+  }
+
+  /**
+   * Options used to create a soundboard sound in a guild.
+   * @typedef {Object} GuildSoundboardSoundCreateOptions
+   * @property {BufferResolvable|Stream} file The file for the soundboard sound
+   * @property {string} name The name for the soundboard sound
+   * @property {string} [contentType] The content type for the soundboard sound file
+   * @property {number} [volume] The volume (a double) for the soundboard sound, from 0 (inclusive) to 1. Defaults to 1
+   * @property {Snowflake} [emojiId] The emoji id for the soundboard sound
+   * @property {string} [emojiName] The emoji name for the soundboard sound
+   * @property {string} [reason] The reason for creating the soundboard sound
+   */
+
+  /**
+   * Creates a new guild soundboard sound.
+   * @param {GuildSoundboardSoundCreateOptions} options Options for creating a guild soundboard sound
+   * @returns {Promise<SoundboardSound>} The created soundboard sound
+   * @example
+   * // Create a new soundboard sound from a file on your computer
+   * guild.soundboardSounds.create({ file: './sound.mp3', name: 'sound' })
+   *   .then(sound => console.log(`Created new soundboard sound with name ${sound.name}!`))
+   *   .catch(console.error);
+   */
+  async create({ contentType, emojiId, emojiName, file, name, reason, volume }) {
+    const resolvedFile = await resolveFile(file);
+
+    const resolvedContentType = contentType ?? resolvedFile.contentType ?? fileTypeMime()(resolvedFile.data)[0];
+
+    const sound = resolveBase64(resolvedFile.data, resolvedContentType);
+
+    const body = { emoji_id: emojiId, emoji_name: emojiName, name, sound, volume };
+
+    const soundboardSound = await this.client.rest.post(Routes.guildSoundboardSounds(this.guild.id), {
+      body,
+      reason,
+    });
+
+    return this._add(soundboardSound);
+  }
+
+  /**
+   * Data for editing a soundboard sound.
+   * @typedef {Object} GuildSoundboardSoundEditOptions
+   * @property {string} [name] The name of the soundboard sound
+   * @property {?number} [volume] The volume of the soundboard sound, from 0 to 1
+   * @property {?Snowflake} [emojiId] The emoji id of the soundboard sound
+   * @property {?string} [emojiName] The emoji name of the soundboard sound
+   * @property {string} [reason] The reason for editing the soundboard sound
+   */
+
+  /**
+   * Edits a soundboard sound.
+   * @param {SoundboardSoundResolvable} soundboardSound The soundboard sound to edit
+   * @param {GuildSoundboardSoundEditOptions} [options={}] The new data for the soundboard sound
+   * @returns {Promise<SoundboardSound>}
+   */
+  async edit(soundboardSound, options = {}) {
+    const soundId = this.resolveId(soundboardSound);
+
+    if (!soundId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'soundboardSound', 'SoundboardSoundResolvable');
+
+    const { emojiId, emojiName, name, reason, volume } = options;
+
+    const body = { emoji_id: emojiId, emoji_name: emojiName, name, volume };
+
+    const data = await this.client.rest.patch(Routes.guildSoundboardSound(this.guild.id, soundId), {
+      body,
+      reason,
+    });
+
+    const existing = this.cache.get(soundId);
+
+    if (existing) {
+      const clone = existing._clone();
+
+      clone._patch(data);
+      return clone;
+    }
+
+    return this._add(data);
+  }
+
+  /**
+   * Deletes a soundboard sound.
+   * @param {SoundboardSoundResolvable} soundboardSound The soundboard sound to delete
+   * @param {string} [reason] Reason for deleting this soundboard sound
+   * @returns {Promise<void>}
+   */
+  async delete(soundboardSound, reason) {
+    const soundId = this.resolveId(soundboardSound);
+
+    if (!soundId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'soundboardSound', 'SoundboardSoundResolvable');
+
+    await this.client.rest.delete(Routes.guildSoundboardSound(this.guild.id, soundId), { reason });
+  }
+
+  /**
+   * Obtains one or more soundboard sounds from Discord, or the soundboard sound cache if they're already available.
+   * @param {Snowflake} [id] The soundboard sound's id
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<SoundboardSound|Collection<Snowflake, SoundboardSound>>}
+   * @example
+   * // Fetch all soundboard sounds from the guild
+   * guild.soundboardSounds.fetch()
+   *   .then(sounds => console.log(`There are ${sounds.size} soundboard sounds.`))
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single soundboard sound
+   * guild.soundboardSounds.fetch('222078108977594368')
+   *   .then(sound => console.log(`The soundboard sound name is: ${sound.name}`))
+   *   .catch(console.error);
+   */
+  async fetch(id, { cache = true, force = false } = {}) {
+    if (id) {
+      if (!force) {
+        const existing = this.cache.get(id);
+        if (existing) return existing;
+      }
+
+      const sound = await this.client.rest.get(Routes.guildSoundboardSound(this.guild.id, id));
+      return this._add(sound, cache);
+    }
+
+    const data = await this.client.rest.get(Routes.guildSoundboardSounds(this.guild.id));
+    return new Collection(data.map(sound => [sound.sound_id, this._add(sound, cache)]));
+  }
+}
+
+exports.GuildSoundboardSoundManager = GuildSoundboardSoundManager;

package/src/structures/ApplicationCommand.js

@@ -162,6 +162,18 @@ class ApplicationCommand extends Base {
       this.contexts ??= null;
     }
 
+    if ('handler' in data) {
+      /**
+       * Determines whether the interaction is handled by the app's interactions handler or by Discord.
+       * <info>Only available for {@link ApplicationCommandType.PrimaryEntryPoint} commands on
+       * applications with the {@link ApplicationFlags.Embedded} flag (i.e, those that have an Activity)</info>
+       * @type {?EntryPointCommandHandlerType}
+       */
+      this.handler = data.handler;
+    } else {
+      this.handler ??= null;
+    }
+
     if ('version' in data) {
       /**
        * Autoincrementing version identifier updated during substantial record changes
@@ -204,14 +216,19 @@ class ApplicationCommand extends Base {
    * @property {string} name The name of the command, must be in all lowercase if type is
    * {@link ApplicationCommandType.ChatInput}
    * @property {Object<Locale, string>} [nameLocalizations] The localizations for the command name
-   * @property {string} description The description of the command, if type is {@link ApplicationCommandType.ChatInput}
+   * @property {string} description The description of the command,
+   * if type is {@link ApplicationCommandType.ChatInput} or {@link ApplicationCommandType.PrimaryEntryPoint}
    * @property {boolean} [nsfw] Whether the command is age-restricted
    * @property {Object<Locale, string>} [descriptionLocalizations] The localizations for the command description,
-   * if type is {@link ApplicationCommandType.ChatInput}
+   * if type is {@link ApplicationCommandType.ChatInput} or {@link ApplicationCommandType.PrimaryEntryPoint}
    * @property {ApplicationCommandType} [type=ApplicationCommandType.ChatInput] The type of the command
    * @property {ApplicationCommandOptionData[]} [options] Options for the command
    * @property {?PermissionResolvable} [defaultMemberPermissions] The bitfield used to determine the default permissions
    * a member needs in order to run the command
+   * @property {ApplicationIntegrationType[]} [integrationTypes] Installation contexts where the command is available
+   * @property {InteractionContextType[]} [contexts] Interaction contexts where the command can be used
+   * @property {EntryPointCommandHandlerType} [handler] Whether the interaction is handled by the app's
+   * interactions handler or by Discord.
    */
 
   /**
@@ -395,7 +412,8 @@ class ApplicationCommand extends Base {
         this.descriptionLocalizations ?? {},
       ) ||
       !isEqual(command.integrationTypes ?? command.integration_types ?? [], this.integrationTypes ?? []) ||
-      !isEqual(command.contexts ?? [], this.contexts ?? [])
+      !isEqual(command.contexts ?? [], this.contexts ?? []) ||
+      ('handler' in command && command.handler !== this.handler)
     ) {
       return false;
     }