@velliajs/discord 1.0.0

package/src/errors/Messages.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const DjsErrorCodes = require('./ErrorCodes');
+
+const Messages = {
+  [DjsErrorCodes.ClientInvalidOption]: (prop, must) => `The ${prop} option must be ${must}`,
+  [DjsErrorCodes.ClientInvalidProvidedShards]: 'None of the provided shards were valid.',
+  [DjsErrorCodes.ClientMissingIntents]: 'Valid intents must be provided for the Client.',
+  [DjsErrorCodes.ClientNotReady]: action => `The client needs to be logged in to ${action}.`,
+
+  [DjsErrorCodes.TokenInvalid]: 'An invalid token was provided.',
+  [DjsErrorCodes.TokenMissing]: 'Request to use token, but token was unavailable to the client.',
+  [DjsErrorCodes.ApplicationCommandPermissionsTokenMissing]:
+    'Editing application command permissions requires an OAuth2 bearer token, but none was provided.',
+
+  [DjsErrorCodes.WSCloseRequested]: 'WebSocket closed due to user request.',
+  [DjsErrorCodes.WSConnectionExists]: 'There is already an existing WebSocket connection.',
+  [DjsErrorCodes.WSNotOpen]: (data = 'data') => `WebSocket not open to send ${data}`,
+  [DjsErrorCodes.ManagerDestroyed]: 'Manager was destroyed.',
+
+  [DjsErrorCodes.BitFieldInvalid]: bit => `Invalid bitfield flag or number: ${bit}.`,
+
+  [DjsErrorCodes.ShardingInvalid]: 'Invalid shard settings were provided.',
+  [DjsErrorCodes.ShardingRequired]: 'This session would have handled too many guilds - Sharding is required.',
+  [DjsErrorCodes.InvalidIntents]: 'Invalid intent provided for WebSocket intents.',
+  [DjsErrorCodes.DisallowedIntents]: 'Privileged intent provided is not enabled or whitelisted.',
+  [DjsErrorCodes.ShardingNoShards]: 'No shards have been spawned.',
+  [DjsErrorCodes.ShardingInProcess]: 'Shards are still being spawned.',
+  [DjsErrorCodes.ShardingInvalidEvalBroadcast]: 'Script to evaluate must be a function',
+  [DjsErrorCodes.ShardingShardNotFound]: id => `Shard ${id} could not be found.`,
+  [DjsErrorCodes.ShardingAlreadySpawned]: count => `Already spawned ${count} shards.`,
+  [DjsErrorCodes.ShardingProcessExists]: id => `Shard ${id} already has an active process.`,
+  [DjsErrorCodes.ShardingWorkerExists]: id => `Shard ${id} already has an active worker.`,
+  [DjsErrorCodes.ShardingReadyTimeout]: id => `Shard ${id}'s Client took too long to become ready.`,
+  [DjsErrorCodes.ShardingReadyDisconnected]: id => `Shard ${id}'s Client disconnected before becoming ready.`,
+  [DjsErrorCodes.ShardingReadyDied]: id => `Shard ${id}'s process exited before its Client became ready.`,
+  [DjsErrorCodes.ShardingNoChildExists]: id => `Shard ${id} has no active process or worker.`,
+  [DjsErrorCodes.ShardingShardMiscalculation]: (shard, guild, count) =>
+    `Calculated invalid shard ${shard} for guild ${guild} with ${count} shards.`,
+
+  [DjsErrorCodes.ColorRange]: 'Color must be within the range 0 - 16777215 (0xFFFFFF).',
+  [DjsErrorCodes.ColorConvert]: 'Unable to convert color to a number.',
+
+  [DjsErrorCodes.InviteOptionsMissingChannel]:
+    'A valid guild channel must be provided when GuildScheduledEvent is EXTERNAL.',
+
+  [DjsErrorCodes.ButtonLabel]: 'MessageButton label must be a string',
+  [DjsErrorCodes.ButtonURL]: 'MessageButton URL must be a string',
+  [DjsErrorCodes.ButtonCustomId]: 'MessageButton customId must be a string',
+
+  [DjsErrorCodes.SelectMenuCustomId]: 'MessageSelectMenu customId must be a string',
+  [DjsErrorCodes.SelectMenuPlaceholder]: 'MessageSelectMenu placeholder must be a string',
+  [DjsErrorCodes.SelectOptionLabel]: 'MessageSelectOption label must be a string',
+  [DjsErrorCodes.SelectOptionValue]: 'MessageSelectOption value must be a string',
+  [DjsErrorCodes.SelectOptionDescription]: 'MessageSelectOption description must be a string',
+
+  [DjsErrorCodes.InteractionCollectorError]: reason =>
+    `Collector received no interactions before ending with reason: ${reason}`,
+
+  [DjsErrorCodes.FileNotFound]: file => `File could not be found: ${file}`,
+
+  [DjsErrorCodes.UserBannerNotFetched]: "You must fetch this user's banner before trying to generate its URL!",
+  [DjsErrorCodes.UserNoDMChannel]: 'No DM Channel exists!',
+
+  [DjsErrorCodes.VoiceNotStageChannel]: 'You are only allowed to do this in stage channels.',
+
+  [DjsErrorCodes.VoiceStateNotOwn]:
+    'You cannot self-deafen/mute/request to speak on VoiceStates that do not belong to the ClientUser.',
+  [DjsErrorCodes.VoiceStateInvalidType]: name => `${name} must be a boolean.`,
+
+  [DjsErrorCodes.ReqResourceType]: 'The resource must be a string, Buffer or a valid file stream.',
+
+  [DjsErrorCodes.ImageFormat]: format => `Invalid image format: ${format}`,
+  [DjsErrorCodes.ImageSize]: size => `Invalid image size: ${size}`,
+
+  [DjsErrorCodes.MessageBulkDeleteType]: 'The messages must be an Array, Collection, or number.',
+  [DjsErrorCodes.MessageNonceType]: 'Message nonce must be an integer or a string.',
+  [DjsErrorCodes.MessageContentType]: 'Message content must be a string.',
+
+  [DjsErrorCodes.SplitMaxLen]: 'Chunk exceeds the max length and contains no split characters.',
+
+  [DjsErrorCodes.BanResolveId]: (ban = false) => `Couldn't resolve the user id to ${ban ? 'ban' : 'unban'}.`,
+  [DjsErrorCodes.FetchBanResolveId]: "Couldn't resolve the user id to fetch the ban.",
+
+  [DjsErrorCodes.PruneDaysType]: 'Days must be a number',
+
+  [DjsErrorCodes.GuildChannelResolve]: 'Could not resolve channel to a guild channel.',
+  [DjsErrorCodes.GuildVoiceChannelResolve]: 'Could not resolve channel to a guild voice channel.',
+  [DjsErrorCodes.GuildChannelOrphan]: 'Could not find a parent to this guild channel.',
+  [DjsErrorCodes.GuildChannelUnowned]: "The fetched channel does not belong to this manager's guild.",
+  [DjsErrorCodes.GuildOwned]: 'Guild is owned by the client.',
+  [DjsErrorCodes.GuildMembersTimeout]: "Members didn't arrive in time.",
+  [DjsErrorCodes.GuildUncachedMe]: 'The client user as a member of this guild is uncached.',
+  [DjsErrorCodes.ChannelNotCached]: 'Could not find the channel where this message came from in the cache!',
+  [DjsErrorCodes.StageChannelResolve]: 'Could not resolve channel to a stage channel.',
+  [DjsErrorCodes.GuildScheduledEventResolve]: 'Could not resolve the guild scheduled event.',
+  [DjsErrorCodes.FetchOwnerId]: "Couldn't resolve the guild ownerId to fetch the member.",
+
+  [DjsErrorCodes.InvalidType]: (name, expected, an = false) => `Supplied ${name} is not a${an ? 'n' : ''} ${expected}.`,
+  [DjsErrorCodes.InvalidElement]: (type, name, elem) => `Supplied ${type} ${name} includes an invalid element: ${elem}`,
+
+  [DjsErrorCodes.MessageThreadParent]: 'The message was not sent in a guild text or news channel',
+  [DjsErrorCodes.MessageExistingThread]: 'The message already has a thread',
+  [DjsErrorCodes.ThreadInvitableType]: type => `Invitable cannot be edited on ${type}`,
+
+  [DjsErrorCodes.WebhookMessage]: 'The message was not sent by a webhook.',
+  [DjsErrorCodes.WebhookTokenUnavailable]: 'This action requires a webhook token, but none is available.',
+  [DjsErrorCodes.WebhookURLInvalid]: 'The provided webhook URL is not valid.',
+  [DjsErrorCodes.WebhookApplication]: 'This message webhook belongs to an application and cannot be fetched.',
+  [DjsErrorCodes.MessageReferenceMissing]: 'The message does not reference another message',
+
+  [DjsErrorCodes.EmojiType]: 'Emoji must be a string or GuildEmoji/ReactionEmoji',
+  [DjsErrorCodes.EmojiManaged]: 'Emoji is managed and has no Author.',
+  [DjsErrorCodes.MissingManageGuildExpressionsPermission]: guild =>
+    `Client must have Manage Guild Expressions permission in guild ${guild} to see emoji authors.`,
+  [DjsErrorCodes.MissingManageEmojisAndStickersPermission]: guild =>
+    `Client must have Manage Emojis and Stickers permission in guild ${guild} to see emoji authors.`,
+
+  [DjsErrorCodes.NotGuildSticker]: 'Sticker is a standard (non-guild) sticker and has no author.',
+
+  [DjsErrorCodes.ReactionResolveUser]: "Couldn't resolve the user id to remove from the reaction.",
+
+  [DjsErrorCodes.VanityURL]: 'This guild does not have the vanity URL feature enabled.',
+
+  [DjsErrorCodes.InviteResolveCode]: 'Could not resolve the code to fetch the invite.',
+
+  [DjsErrorCodes.InviteNotFound]: 'Could not find the requested invite.',
+
+  [DjsErrorCodes.DeleteGroupDMChannel]: "Bots don't have access to Group DM Channels and cannot delete them",
+  [DjsErrorCodes.FetchGroupDMChannel]: "Bots don't have access to Group DM Channels and cannot fetch them",
+
+  [DjsErrorCodes.MemberFetchNonceLength]: 'Nonce length must not exceed 32 characters.',
+
+  [DjsErrorCodes.GlobalCommandPermissions]:
+    'Permissions for global commands may only be fetched or modified by providing a GuildResolvable ' +
+    "or from a guild's application command manager.",
+  [DjsErrorCodes.GuildUncachedEntityResolve]: type =>
+    `Cannot resolve ${type} from an arbitrary guild, provide an id instead`,
+
+  [DjsErrorCodes.InteractionAlreadyReplied]: 'The reply to this interaction has already been sent or deferred.',
+  [DjsErrorCodes.InteractionNotReplied]: 'The reply to this interaction has not been sent or deferred.',
+  [DjsErrorCodes.InteractionEphemeralReplied]: 'Ephemeral responses cannot be deleted.',
+
+  [DjsErrorCodes.CommandInteractionOptionNotFound]: name => `Required option "${name}" not found.`,
+  [DjsErrorCodes.CommandInteractionOptionType]: (name, type, expected) =>
+    `Option "${name}" is of type: ${type}; expected ${expected}.`,
+  [DjsErrorCodes.CommandInteractionOptionEmpty]: (name, type) =>
+    `Required option "${name}" is of type: ${type}; expected a non-empty value.`,
+  [DjsErrorCodes.CommandInteractionOptionNoSubcommand]: 'No subcommand specified for interaction.',
+  [DjsErrorCodes.CommandInteractionOptionNoSubcommandGroup]: 'No subcommand group specified for interaction.',
+  [DjsErrorCodes.CommandInteractionOptionInvalidChannelType]: (name, type, expected) =>
+    `The type of channel of the option "${name}" is: ${type}; expected ${expected}.`,
+  [DjsErrorCodes.AutocompleteInteractionOptionNoFocusedOption]: 'No focused option for autocomplete interaction.',
+
+  [DjsErrorCodes.ModalSubmitInteractionFieldNotFound]: customId =>
+    `Required field with custom id "${customId}" not found.`,
+  [DjsErrorCodes.ModalSubmitInteractionFieldType]: (customId, type, expected) =>
+    `Field with custom id "${customId}" is of type: ${type}; expected ${expected}.`,
+
+  [DjsErrorCodes.InvalidMissingScopes]: 'At least one valid scope must be provided for the invite',
+  [DjsErrorCodes.InvalidScopesWithPermissions]: 'Permissions cannot be set without the bot scope.',
+
+  [DjsErrorCodes.NotImplemented]: (what, name) => `Method ${what} not implemented on ${name}.`,
+
+  [DjsErrorCodes.SweepFilterReturn]: 'The return value of the sweepFilter function was not false or a Function',
+
+  [DjsErrorCodes.GuildForumMessageRequired]: 'You must provide a message to create a guild forum thread',
+};
+
+module.exports = Messages;

package/src/errors/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = require('./DJSError');
+module.exports.ErrorCodes = require('./ErrorCodes');
+module.exports.Messages = require('./Messages');

package/src/index.js

@@ -0,0 +1,213 @@
+'use strict';
+
+const { __exportStar } = require('tslib');
+
+// "Root" classes (starting points)
+exports.BaseClient = require('./client/BaseClient');
+exports.Client = require('./client/Client');
+exports.Shard = require('./sharding/Shard');
+exports.ShardClientUtil = require('./sharding/ShardClientUtil');
+exports.ShardingManager = require('./sharding/ShardingManager');
+exports.WebhookClient = require('./client/WebhookClient');
+
+// Errors
+exports.DiscordjsError = require('./errors/DJSError').DiscordjsError;
+exports.DiscordjsTypeError = require('./errors/DJSError').DiscordjsTypeError;
+exports.DiscordjsRangeError = require('./errors/DJSError').DiscordjsRangeError;
+exports.DiscordjsErrorCodes = require('./errors/ErrorCodes');
+
+// Utilities
+exports.ActivityFlagsBitField = require('./util/ActivityFlagsBitField');
+exports.ApplicationFlagsBitField = require('./util/ApplicationFlagsBitField');
+exports.BaseManager = require('./managers/BaseManager');
+exports.BitField = require('./util/BitField');
+exports.ChannelFlagsBitField = require('./util/ChannelFlagsBitField');
+exports.Collection = require('@discordjs/collection').Collection;
+exports.Constants = require('./util/Constants');
+exports.Colors = require('./util/Colors');
+exports.DataResolver = require('./util/DataResolver');
+exports.Events = require('./util/Events');
+exports.Formatters = require('./util/Formatters');
+exports.GuildMemberFlagsBitField = require('./util/GuildMemberFlagsBitField').GuildMemberFlagsBitField;
+exports.IntentsBitField = require('./util/IntentsBitField');
+exports.LimitedCollection = require('./util/LimitedCollection');
+exports.MessageFlagsBitField = require('./util/MessageFlagsBitField');
+exports.Options = require('./util/Options');
+exports.Partials = require('./util/Partials');
+exports.PermissionsBitField = require('./util/PermissionsBitField');
+exports.ShardEvents = require('./util/ShardEvents');
+exports.Status = require('./util/Status');
+exports.SnowflakeUtil = require('@sapphire/snowflake').DiscordSnowflake;
+exports.Sweepers = require('./util/Sweepers');
+exports.SystemChannelFlagsBitField = require('./util/SystemChannelFlagsBitField');
+exports.ThreadMemberFlagsBitField = require('./util/ThreadMemberFlagsBitField');
+exports.UserFlagsBitField = require('./util/UserFlagsBitField');
+__exportStar(require('./util/Util.js'), exports);
+exports.WebSocketShardEvents = require('./util/WebSocketShardEvents');
+exports.version = require('../package.json').version;
+
+// Managers
+exports.ApplicationCommandManager = require('./managers/ApplicationCommandManager');
+exports.ApplicationCommandPermissionsManager = require('./managers/ApplicationCommandPermissionsManager');
+exports.AutoModerationRuleManager = require('./managers/AutoModerationRuleManager');
+exports.BaseGuildEmojiManager = require('./managers/BaseGuildEmojiManager');
+exports.CachedManager = require('./managers/CachedManager');
+exports.ChannelManager = require('./managers/ChannelManager');
+exports.ClientVoiceManager = require('./client/voice/ClientVoiceManager');
+exports.DataManager = require('./managers/DataManager');
+exports.GuildApplicationCommandManager = require('./managers/GuildApplicationCommandManager');
+exports.GuildBanManager = require('./managers/GuildBanManager');
+exports.GuildChannelManager = require('./managers/GuildChannelManager');
+exports.GuildEmojiManager = require('./managers/GuildEmojiManager');
+exports.GuildEmojiRoleManager = require('./managers/GuildEmojiRoleManager');
+exports.GuildForumThreadManager = require('./managers/GuildForumThreadManager');
+exports.GuildInviteManager = require('./managers/GuildInviteManager');
+exports.GuildManager = require('./managers/GuildManager');
+exports.GuildMemberManager = require('./managers/GuildMemberManager');
+exports.GuildMemberRoleManager = require('./managers/GuildMemberRoleManager');
+exports.GuildScheduledEventManager = require('./managers/GuildScheduledEventManager');
+exports.GuildStickerManager = require('./managers/GuildStickerManager');
+exports.GuildTextThreadManager = require('./managers/GuildTextThreadManager');
+exports.MessageManager = require('./managers/MessageManager');
+exports.PermissionOverwriteManager = require('./managers/PermissionOverwriteManager');
+exports.PresenceManager = require('./managers/PresenceManager');
+exports.ReactionManager = require('./managers/ReactionManager');
+exports.ReactionUserManager = require('./managers/ReactionUserManager');
+exports.RoleManager = require('./managers/RoleManager');
+exports.StageInstanceManager = require('./managers/StageInstanceManager');
+exports.ThreadManager = require('./managers/ThreadManager');
+exports.ThreadMemberManager = require('./managers/ThreadMemberManager');
+exports.UserManager = require('./managers/UserManager');
+exports.VoiceStateManager = require('./managers/VoiceStateManager');
+exports.WebSocketManager = require('./client/websocket/WebSocketManager');
+exports.WebSocketShard = require('./client/websocket/WebSocketShard');
+
+// Structures
+exports.ActionRow = require('./structures/ActionRow');
+exports.ActionRowBuilder = require('./structures/ActionRowBuilder');
+exports.Activity = require('./structures/Presence').Activity;
+exports.AnonymousGuild = require('./structures/AnonymousGuild');
+exports.Application = require('./structures/interfaces/Application');
+exports.ApplicationCommand = require('./structures/ApplicationCommand');
+exports.ApplicationRoleConnectionMetadata =
+  require('./structures/ApplicationRoleConnectionMetadata').ApplicationRoleConnectionMetadata;
+exports.AutocompleteInteraction = require('./structures/AutocompleteInteraction');
+exports.AutoModerationActionExecution = require('./structures/AutoModerationActionExecution');
+exports.AutoModerationRule = require('./structures/AutoModerationRule');
+exports.Base = require('./structures/Base');
+exports.BaseGuild = require('./structures/BaseGuild');
+exports.BaseGuildEmoji = require('./structures/BaseGuildEmoji');
+exports.BaseGuildTextChannel = require('./structures/BaseGuildTextChannel');
+exports.BaseGuildVoiceChannel = require('./structures/BaseGuildVoiceChannel');
+exports.ButtonBuilder = require('./structures/ButtonBuilder');
+exports.ButtonComponent = require('./structures/ButtonComponent');
+exports.ButtonInteraction = require('./structures/ButtonInteraction');
+exports.CategoryChannel = require('./structures/CategoryChannel');
+exports.BaseChannel = require('./structures/BaseChannel').BaseChannel;
+exports.ChatInputCommandInteraction = require('./structures/ChatInputCommandInteraction');
+exports.ClientApplication = require('./structures/ClientApplication');
+exports.ClientPresence = require('./structures/ClientPresence');
+exports.ClientUser = require('./structures/ClientUser');
+exports.CommandInteraction = require('./structures/CommandInteraction');
+exports.Collector = require('./structures/interfaces/Collector');
+exports.CommandInteractionOptionResolver = require('./structures/CommandInteractionOptionResolver');
+exports.Component = require('./structures/Component');
+exports.ContextMenuCommandInteraction = require('./structures/ContextMenuCommandInteraction');
+exports.DMChannel = require('./structures/DMChannel');
+exports.Embed = require('./structures/Embed');
+exports.EmbedBuilder = require('./structures/EmbedBuilder');
+exports.Emoji = require('./structures/Emoji').Emoji;
+exports.ForumChannel = require('./structures/ForumChannel');
+exports.Guild = require('./structures/Guild').Guild;
+exports.GuildAuditLogs = require('./structures/GuildAuditLogs');
+exports.GuildAuditLogsEntry = require('./structures/GuildAuditLogsEntry');
+exports.GuildBan = require('./structures/GuildBan');
+exports.GuildChannel = require('./structures/GuildChannel');
+exports.GuildEmoji = require('./structures/GuildEmoji');
+exports.GuildMember = require('./structures/GuildMember').GuildMember;
+exports.GuildPreview = require('./structures/GuildPreview');
+exports.GuildPreviewEmoji = require('./structures/GuildPreviewEmoji');
+exports.GuildScheduledEvent = require('./structures/GuildScheduledEvent').GuildScheduledEvent;
+exports.GuildTemplate = require('./structures/GuildTemplate');
+exports.Integration = require('./structures/Integration');
+exports.IntegrationApplication = require('./structures/IntegrationApplication');
+exports.BaseInteraction = require('./structures/BaseInteraction');
+exports.InteractionCollector = require('./structures/InteractionCollector');
+exports.InteractionResponse = require('./structures/InteractionResponse');
+exports.InteractionWebhook = require('./structures/InteractionWebhook');
+exports.Invite = require('./structures/Invite');
+exports.InviteStageInstance = require('./structures/InviteStageInstance');
+exports.InviteGuild = require('./structures/InviteGuild');
+exports.Message = require('./structures/Message').Message;
+exports.Attachment = require('./structures/Attachment');
+exports.AttachmentBuilder = require('./structures/AttachmentBuilder');
+exports.ModalBuilder = require('./structures/ModalBuilder');
+exports.MessageCollector = require('./structures/MessageCollector');
+exports.MessageComponentInteraction = require('./structures/MessageComponentInteraction');
+exports.MessageContextMenuCommandInteraction = require('./structures/MessageContextMenuCommandInteraction');
+exports.MessageMentions = require('./structures/MessageMentions');
+exports.MessagePayload = require('./structures/MessagePayload');
+exports.MessageReaction = require('./structures/MessageReaction');
+exports.ModalSubmitInteraction = require('./structures/ModalSubmitInteraction');
+exports.ModalSubmitFields = require('./structures/ModalSubmitFields');
+exports.NewsChannel = require('./structures/NewsChannel');
+exports.OAuth2Guild = require('./structures/OAuth2Guild');
+exports.PartialGroupDMChannel = require('./structures/PartialGroupDMChannel');
+exports.PermissionOverwrites = require('./structures/PermissionOverwrites');
+exports.Presence = require('./structures/Presence').Presence;
+exports.ReactionCollector = require('./structures/ReactionCollector');
+exports.ReactionEmoji = require('./structures/ReactionEmoji');
+exports.RichPresenceAssets = require('./structures/Presence').RichPresenceAssets;
+exports.Role = require('./structures/Role').Role;
+exports.SelectMenuBuilder = require('./structures/SelectMenuBuilder');
+exports.ChannelSelectMenuBuilder = require('./structures/ChannelSelectMenuBuilder');
+exports.MentionableSelectMenuBuilder = require('./structures/MentionableSelectMenuBuilder');
+exports.RoleSelectMenuBuilder = require('./structures/RoleSelectMenuBuilder');
+exports.StringSelectMenuBuilder = require('./structures/StringSelectMenuBuilder');
+exports.UserSelectMenuBuilder = require('./structures/UserSelectMenuBuilder');
+exports.BaseSelectMenuComponent = require('./structures/BaseSelectMenuComponent');
+exports.SelectMenuComponent = require('./structures/SelectMenuComponent');
+exports.ChannelSelectMenuComponent = require('./structures/ChannelSelectMenuComponent');
+exports.MentionableSelectMenuComponent = require('./structures/MentionableSelectMenuComponent');
+exports.RoleSelectMenuComponent = require('./structures/RoleSelectMenuComponent');
+exports.StringSelectMenuComponent = require('./structures/StringSelectMenuComponent');
+exports.UserSelectMenuComponent = require('./structures/UserSelectMenuComponent');
+exports.SelectMenuInteraction = require('./structures/SelectMenuInteraction');
+exports.ChannelSelectMenuInteraction = require('./structures/ChannelSelectMenuInteraction');
+exports.MentionableSelectMenuInteraction = require('./structures/MentionableSelectMenuInteraction');
+exports.MentionableSelectMenuInteraction = require('./structures/MentionableSelectMenuInteraction');
+exports.RoleSelectMenuInteraction = require('./structures/RoleSelectMenuInteraction');
+exports.StringSelectMenuInteraction = require('./structures/StringSelectMenuInteraction');
+exports.UserSelectMenuInteraction = require('./structures/UserSelectMenuInteraction');
+exports.SelectMenuOptionBuilder = require('./structures/SelectMenuOptionBuilder');
+exports.StringSelectMenuOptionBuilder = require('./structures/StringSelectMenuOptionBuilder');
+exports.StageChannel = require('./structures/StageChannel');
+exports.StageInstance = require('./structures/StageInstance').StageInstance;
+exports.Sticker = require('./structures/Sticker').Sticker;
+exports.StickerPack = require('./structures/StickerPack');
+exports.Team = require('./structures/Team');
+exports.TeamMember = require('./structures/TeamMember');
+exports.TextChannel = require('./structures/TextChannel');
+exports.TextInputBuilder = require('./structures/TextInputBuilder');
+exports.TextInputComponent = require('./structures/TextInputComponent');
+exports.ThreadChannel = require('./structures/ThreadChannel');
+exports.ThreadMember = require('./structures/ThreadMember');
+exports.Typing = require('./structures/Typing');
+exports.User = require('./structures/User');
+exports.UserContextMenuCommandInteraction = require('./structures/UserContextMenuCommandInteraction');
+exports.VoiceChannel = require('./structures/VoiceChannel');
+exports.VoiceRegion = require('./structures/VoiceRegion');
+exports.VoiceState = require('./structures/VoiceState');
+exports.Webhook = require('./structures/Webhook');
+exports.Widget = require('./structures/Widget');
+exports.WidgetMember = require('./structures/WidgetMember');
+exports.WelcomeChannel = require('./structures/WelcomeChannel');
+exports.WelcomeScreen = require('./structures/WelcomeScreen');
+
+// External
+__exportStar(require('discord-api-types/v10'), exports);
+__exportStar(require('@discordjs/builders'), exports);
+__exportStar(require('@discordjs/formatters'), exports);
+__exportStar(require('@discordjs/rest'), exports);
+__exportStar(require('@discordjs/util'), exports);
+__exportStar(require('@discordjs/ws'), exports);

package/src/managers/ApplicationCommandManager.js

@@ -0,0 +1,263 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { makeURLSearchParams } = require('@discordjs/rest');
+const { isJSONEncodable } = require('@discordjs/util');
+const { Routes } = require('discord-api-types/v10');
+const ApplicationCommandPermissionsManager = require('./ApplicationCommandPermissionsManager');
+const CachedManager = require('./CachedManager');
+const { DiscordjsTypeError, ErrorCodes } = require('../errors');
+const ApplicationCommand = require('../structures/ApplicationCommand');
+const PermissionsBitField = require('../util/PermissionsBitField');
+
+/**
+ * Manages API methods for application commands and stores their cache.
+ * @extends {CachedManager}
+ */
+class ApplicationCommandManager extends CachedManager {
+  constructor(client, iterable) {
+    super(client, ApplicationCommand, iterable);
+
+    /**
+     * The manager for permissions of arbitrary commands on arbitrary guilds
+     * @type {ApplicationCommandPermissionsManager}
+     */
+    this.permissions = new ApplicationCommandPermissionsManager(this);
+  }
+
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, ApplicationCommand>}
+   * @name ApplicationCommandManager#cache
+   */
+
+  _add(data, cache, guildId) {
+    return super._add(data, cache, { extras: [this.guild, guildId] });
+  }
+
+  /**
+   * The APIRouter path to the commands
+   * @param {Snowflake} [options.id] The application command's id
+   * @param {Snowflake} [options.guildId] The guild's id to use in the path,
+   * ignored when using a {@link GuildApplicationCommandManager}
+   * @returns {string}
+   * @private
+   */
+  commandPath({ id, guildId } = {}) {
+    if (this.guild ?? guildId) {
+      if (id) {
+        return Routes.applicationGuildCommand(this.client.application.id, this.guild?.id ?? guildId, id);
+      }
+
+      return Routes.applicationGuildCommands(this.client.application.id, this.guild?.id ?? guildId);
+    }
+
+    if (id) {
+      return Routes.applicationCommand(this.client.application.id, id);
+    }
+
+    return Routes.applicationCommands(this.client.application.id);
+  }
+
+  /**
+   * Data that resolves to give an ApplicationCommand object. This can be:
+   * * An ApplicationCommand object
+   * * A Snowflake
+   * @typedef {ApplicationCommand|Snowflake} ApplicationCommandResolvable
+   */
+
+  /**
+   * Data that resolves to the data of an ApplicationCommand
+   * @typedef {ApplicationCommandData|APIApplicationCommand} ApplicationCommandDataResolvable
+   */
+
+  /**
+   * Options used to fetch data from Discord
+   * @typedef {Object} BaseFetchOptions
+   * @property {boolean} [cache=true] Whether to cache the fetched data if it wasn't already
+   * @property {boolean} [force=false] Whether to skip the cache check and request the API
+   */
+
+  /**
+   * Options used to fetch Application Commands from Discord
+   * @typedef {BaseFetchOptions} FetchApplicationCommandOptions
+   * @property {Snowflake} [guildId] The guild's id to fetch commands for, for when the guild is not cached
+   * @property {LocaleString} [locale] The locale to use when fetching this command
+   * @property {boolean} [withLocalizations] Whether to fetch all localization data
+   */
+
+  /**
+   * Obtains one or multiple application commands from Discord, or the cache if it's already available.
+   * @param {Snowflake} [id] The application command's id
+   * @param {FetchApplicationCommandOptions} [options] Additional options for this fetch
+   * @returns {Promise<ApplicationCommand|Collection<Snowflake, ApplicationCommand>>}
+   * @example
+   * // Fetch a single command
+   * client.application.commands.fetch('123456789012345678')
+   *   .then(command => console.log(`Fetched command ${command.name}`))
+   *   .catch(console.error);
+   * @example
+   * // Fetch all commands
+   * guild.commands.fetch()
+   *   .then(commands => console.log(`Fetched ${commands.size} commands`))
+   *   .catch(console.error);
+   */
+  async fetch(id, { guildId, cache = true, force = false, locale, withLocalizations } = {}) {
+    if (typeof id === 'object') {
+      ({ guildId, cache = true, locale, withLocalizations } = id);
+    } else if (id) {
+      if (!force) {
+        const existing = this.cache.get(id);
+        if (existing) return existing;
+      }
+      const command = await this.client.rest.get(this.commandPath({ id, guildId }));
+      return this._add(command, cache);
+    }
+
+    const data = await this.client.rest.get(this.commandPath({ guildId }), {
+      headers: {
+        'X-Discord-Locale': locale,
+      },
+      query: makeURLSearchParams({ with_localizations: withLocalizations }),
+    });
+    return data.reduce((coll, command) => coll.set(command.id, this._add(command, cache, guildId)), new Collection());
+  }
+
+  /**
+   * Creates an application command.
+   * @param {ApplicationCommandDataResolvable} command The command
+   * @param {Snowflake} [guildId] The guild's id to create this command in,
+   * ignored when using a {@link GuildApplicationCommandManager}
+   * @returns {Promise<ApplicationCommand>}
+   * @example
+   * // Create a new command
+   * client.application.commands.create({
+   *   name: 'test',
+   *   description: 'A test command',
+   * })
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async create(command, guildId) {
+    const data = await this.client.rest.post(this.commandPath({ guildId }), {
+      body: this.constructor.transformCommand(command),
+    });
+    return this._add(data, true, guildId);
+  }
+
+  /**
+   * Sets all the commands for this application or guild.
+   * @param {ApplicationCommandDataResolvable[]} commands The commands
+   * @param {Snowflake} [guildId] The guild's id to create the commands in,
+   * ignored when using a {@link GuildApplicationCommandManager}
+   * @returns {Promise<Collection<Snowflake, ApplicationCommand>>}
+   * @example
+   * // Set all commands to just this one
+   * client.application.commands.set([
+   *   {
+   *     name: 'test',
+   *     description: 'A test command',
+   *   },
+   * ])
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Remove all commands
+   * guild.commands.set([])
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async set(commands, guildId) {
+    const data = await this.client.rest.put(this.commandPath({ guildId }), {
+      body: commands.map(c => this.constructor.transformCommand(c)),
+    });
+    return data.reduce((coll, command) => coll.set(command.id, this._add(command, true, guildId)), new Collection());
+  }
+
+  /**
+   * Edits an application command.
+   * @param {ApplicationCommandResolvable} command The command to edit
+   * @param {Partial<ApplicationCommandDataResolvable>} data The data to update the command with
+   * @param {Snowflake} [guildId] The guild's id where the command registered,
+   * ignored when using a {@link GuildApplicationCommandManager}
+   * @returns {Promise<ApplicationCommand>}
+   * @example
+   * // Edit an existing command
+   * client.application.commands.edit('123456789012345678', {
+   *   description: 'New description',
+   * })
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async edit(command, data, guildId) {
+    const id = this.resolveId(command);
+    if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'command', 'ApplicationCommandResolvable');
+
+    const patched = await this.client.rest.patch(this.commandPath({ id, guildId }), {
+      body: this.constructor.transformCommand(data),
+    });
+    return this._add(patched, true, guildId);
+  }
+
+  /**
+   * Deletes an application command.
+   * @param {ApplicationCommandResolvable} command The command to delete
+   * @param {Snowflake} [guildId] The guild's id where the command is registered,
+   * ignored when using a {@link GuildApplicationCommandManager}
+   * @returns {Promise<?ApplicationCommand>}
+   * @example
+   * // Delete a command
+   * guild.commands.delete('123456789012345678')
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async delete(command, guildId) {
+    const id = this.resolveId(command);
+    if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'command', 'ApplicationCommandResolvable');
+
+    await this.client.rest.delete(this.commandPath({ id, guildId }));
+
+    const cached = this.cache.get(id);
+    this.cache.delete(id);
+    return cached ?? null;
+  }
+
+  /**
+   * Transforms an {@link ApplicationCommandData} object into something that can be used with the API.
+   * @param {ApplicationCommandDataResolvable} command The command to transform
+   * @returns {APIApplicationCommand}
+   * @private
+   */
+  static transformCommand(command) {
+    if (isJSONEncodable(command)) return command.toJSON();
+
+    let default_member_permissions;
+
+    if ('default_member_permissions' in command) {
+      default_member_permissions = command.default_member_permissions
+        ? new PermissionsBitField(BigInt(command.default_member_permissions)).bitfield.toString()
+        : command.default_member_permissions;
+    }
+
+    if ('defaultMemberPermissions' in command) {
+      default_member_permissions =
+        command.defaultMemberPermissions !== null
+          ? new PermissionsBitField(command.defaultMemberPermissions).bitfield.toString()
+          : command.defaultMemberPermissions;
+    }
+
+    return {
+      name: command.name,
+      name_localizations: command.nameLocalizations ?? command.name_localizations,
+      description: command.description,
+      nsfw: command.nsfw,
+      description_localizations: command.descriptionLocalizations ?? command.description_localizations,
+      type: command.type,
+      options: command.options?.map(o => ApplicationCommand.transformOption(o)),
+      default_member_permissions,
+      dm_permission: command.dmPermission ?? command.dm_permission,
+    };
+  }
+}
+
+module.exports = ApplicationCommandManager;