@discordjs/core 0.1.1-dev.1669637061-8376e2d.0

package/dist/index.js

@@ -0,0 +1,870 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  API: () => API,
+  ApplicationCommandsAPI: () => ApplicationCommandsAPI,
+  ChannelsAPI: () => ChannelsAPI,
+  GuildsAPI: () => GuildsAPI,
+  InteractionsAPI: () => InteractionsAPI,
+  InvitesAPI: () => InvitesAPI,
+  StickersAPI: () => StickersAPI,
+  ThreadsAPI: () => ThreadsAPI,
+  UsersAPI: () => UsersAPI,
+  VoiceAPI: () => VoiceAPI,
+  WebhooksAPI: () => WebhooksAPI,
+  createClient: () => createClient,
+  withFiles: () => withFiles
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/api/applicationCommands.ts
+var import_rest = require("@discordjs/rest");
+var import_v10 = require("discord-api-types/v10");
+var ApplicationCommandsAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async getGlobalCommands(applicationId, options = {}) {
+    return this.rest.get(import_v10.Routes.applicationCommands(applicationId), {
+      query: (0, import_rest.makeURLSearchParams)(options)
+    });
+  }
+  async createGlobalCommand(applicationId, data) {
+    return this.rest.post(import_v10.Routes.applicationCommands(applicationId), {
+      body: data
+    });
+  }
+  async getGlobalCommand(applicationId, commandId) {
+    return this.rest.get(
+      import_v10.Routes.applicationCommand(applicationId, commandId)
+    );
+  }
+  async editGlobalCommand(applicationId, commandId, data) {
+    return this.rest.patch(import_v10.Routes.applicationCommand(applicationId, commandId), {
+      body: data
+    });
+  }
+  async deleteGlobalCommand(applicationId, commandId) {
+    await this.rest.delete(import_v10.Routes.applicationCommand(applicationId, commandId));
+  }
+  async bulkOverwriteGlobalCommands(applicationId, data) {
+    return this.rest.put(import_v10.Routes.applicationCommands(applicationId), {
+      body: data
+    });
+  }
+  async getGuildCommands(applicationId, guildId, data = {}) {
+    return this.rest.get(import_v10.Routes.applicationGuildCommands(applicationId, guildId), {
+      query: (0, import_rest.makeURLSearchParams)(data)
+    });
+  }
+  async createGuildCommand(applicationId, guildId, data) {
+    return this.rest.post(import_v10.Routes.applicationGuildCommands(applicationId, guildId), {
+      body: data
+    });
+  }
+  async getGuildCommand(applicationId, guildId, commandId) {
+    return this.rest.get(
+      import_v10.Routes.applicationGuildCommand(applicationId, guildId, commandId)
+    );
+  }
+  async editGuildCommand(applicationId, guildId, commandId, data) {
+    return this.rest.patch(import_v10.Routes.applicationGuildCommand(applicationId, guildId, commandId), {
+      body: data
+    });
+  }
+  async deleteGuildCommand(applicationId, guildId, commandId) {
+    await this.rest.delete(import_v10.Routes.applicationGuildCommand(applicationId, guildId, commandId));
+  }
+  async bulkOverwriteGuildCommands(applicationId, guildId, data) {
+    return this.rest.put(import_v10.Routes.applicationGuildCommands(applicationId, guildId), {
+      body: data
+    });
+  }
+  async getGuildCommandPermissions(applicationId, guildId, commandId) {
+    return this.rest.get(
+      import_v10.Routes.applicationCommandPermissions(applicationId, guildId, commandId)
+    );
+  }
+  async getGuildCommandsPermissions(applicationId, guildId) {
+    return this.rest.get(
+      import_v10.Routes.guildApplicationCommandsPermissions(applicationId, guildId)
+    );
+  }
+  async editGuildCommandPermissions(userToken, applicationId, guildId, commandId, data) {
+    return this.rest.put(import_v10.Routes.applicationCommandPermissions(applicationId, guildId, commandId), {
+      headers: { Authorization: `Bearer ${userToken.replace("Bearer ", "")}` },
+      auth: false,
+      body: data
+    });
+  }
+};
+__name(ApplicationCommandsAPI, "ApplicationCommandsAPI");
+
+// src/api/channel.ts
+var import_rest2 = require("@discordjs/rest");
+var import_v102 = require("discord-api-types/v10");
+var ChannelsAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async createMessage(channelId, { files, ...body }) {
+    return this.rest.post(import_v102.Routes.channelMessages(channelId), {
+      files,
+      body
+    });
+  }
+  async editMessage(channelId, messageId, { files, ...body }) {
+    return this.rest.patch(import_v102.Routes.channelMessage(channelId, messageId), {
+      files,
+      body
+    });
+  }
+  async getMessageReactions(channelId, messageId, emoji, options = {}) {
+    return this.rest.get(import_v102.Routes.channelMessageReaction(channelId, messageId, encodeURIComponent(emoji)), {
+      query: (0, import_rest2.makeURLSearchParams)(options)
+    });
+  }
+  async deleteOwnMessageReaction(channelId, messageId, emoji) {
+    await this.rest.delete(import_v102.Routes.channelMessageOwnReaction(channelId, messageId, encodeURIComponent(emoji)));
+  }
+  async deleteUserMessageReaction(channelId, messageId, emoji, userId) {
+    await this.rest.delete(import_v102.Routes.channelMessageUserReaction(channelId, messageId, encodeURIComponent(emoji), userId));
+  }
+  async deleteAllMessageReactions(channelId, messageId) {
+    await this.rest.delete(import_v102.Routes.channelMessageAllReactions(channelId, messageId));
+  }
+  async deleteAllMessageReactionsForEmoji(channelId, messageId, emoji) {
+    await this.rest.delete(import_v102.Routes.channelMessageReaction(channelId, messageId, encodeURIComponent(emoji)));
+  }
+  async addMessageReaction(channelId, messageId, emoji) {
+    await this.rest.put(import_v102.Routes.channelMessageOwnReaction(channelId, messageId, encodeURIComponent(emoji)));
+  }
+  async get(channelId) {
+    return this.rest.get(import_v102.Routes.channel(channelId));
+  }
+  async edit(channelId, data) {
+    return this.rest.patch(import_v102.Routes.channel(channelId), { body: data });
+  }
+  async delete(channelId) {
+    return this.rest.delete(import_v102.Routes.channel(channelId));
+  }
+  async getMessages(channelId, options = {}) {
+    return this.rest.get(import_v102.Routes.channelMessages(channelId), {
+      query: (0, import_rest2.makeURLSearchParams)(options)
+    });
+  }
+  async showTyping(channelId) {
+    await this.rest.post(import_v102.Routes.channelTyping(channelId));
+  }
+  async getPins(channelId) {
+    return this.rest.get(import_v102.Routes.channelPins(channelId));
+  }
+  async pinMessage(channelId, messageId, reason) {
+    await this.rest.put(import_v102.Routes.channelPin(channelId, messageId), { reason });
+  }
+  async deleteMessage(channelId, messageId, reason) {
+    await this.rest.delete(import_v102.Routes.channelMessage(channelId, messageId), { reason });
+  }
+  async bulkDeleteMessages(channelId, messageIds, reason) {
+    await this.rest.post(import_v102.Routes.channelBulkDelete(channelId), { reason, body: { messages: messageIds } });
+  }
+  async getMessage(channelId, messageId) {
+    return this.rest.get(import_v102.Routes.channelMessage(channelId, messageId));
+  }
+  async crosspostMessage(channelId, messageId) {
+    return this.rest.post(
+      import_v102.Routes.channelMessageCrosspost(channelId, messageId)
+    );
+  }
+  async unpinMessage(channelId, messageId, reason) {
+    await this.rest.delete(import_v102.Routes.channelPin(channelId, messageId), { reason });
+  }
+  async followAnnouncements(channelId, webhookChannelId) {
+    return this.rest.post(import_v102.Routes.channelFollowers(channelId), {
+      body: { webhook_channel_id: webhookChannelId }
+    });
+  }
+  async createInvite(channelId, data, reason) {
+    return this.rest.post(import_v102.Routes.channelInvites(channelId), {
+      reason,
+      body: data
+    });
+  }
+  async getInvites(channelId) {
+    return this.rest.get(import_v102.Routes.channelInvites(channelId));
+  }
+  async getArchivedThreads(channelId, archivedStatus, options = {}) {
+    return this.rest.get(import_v102.Routes.channelThreads(channelId, archivedStatus), {
+      query: (0, import_rest2.makeURLSearchParams)(options)
+    });
+  }
+  async getJoinedPrivateArchivedThreads(channelId, options = {}) {
+    return this.rest.get(import_v102.Routes.channelJoinedArchivedThreads(channelId), {
+      query: (0, import_rest2.makeURLSearchParams)(options)
+    });
+  }
+};
+__name(ChannelsAPI, "ChannelsAPI");
+
+// src/api/guild.ts
+var import_rest3 = require("@discordjs/rest");
+var import_v103 = require("discord-api-types/v10");
+var GuildsAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(guildId) {
+    return this.rest.get(import_v103.Routes.guild(guildId));
+  }
+  async getPreview(guildId) {
+    return this.rest.get(import_v103.Routes.guildPreview(guildId));
+  }
+  async create(data) {
+    return this.rest.post(import_v103.Routes.guilds(), { body: data });
+  }
+  async edit(guildId, data, reason) {
+    return this.rest.patch(import_v103.Routes.guild(guildId), { reason, body: data });
+  }
+  async delete(guildId, reason) {
+    await this.rest.delete(import_v103.Routes.guild(guildId), { reason });
+  }
+  async getMembers(guildId, options = {}) {
+    return this.rest.get(import_v103.Routes.guildMembers(guildId), {
+      query: (0, import_rest3.makeURLSearchParams)(options)
+    });
+  }
+  async getChannels(guildId) {
+    return this.rest.get(import_v103.Routes.guildChannels(guildId));
+  }
+  async createChannel(guildId, data, reason) {
+    return this.rest.post(import_v103.Routes.guildChannels(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async setChannelPositions(guildId, data, reason) {
+    await this.rest.patch(import_v103.Routes.guildChannels(guildId), { reason, body: data });
+  }
+  async getActiveThreads(guildId) {
+    return this.rest.get(import_v103.Routes.guildActiveThreads(guildId));
+  }
+  async getMemberBans(guildId) {
+    return this.rest.get(import_v103.Routes.guildBans(guildId));
+  }
+  async banUser(guildId, userId, options = {}, reason) {
+    await this.rest.put(import_v103.Routes.guildBan(guildId, userId), { reason, body: options });
+  }
+  async unbanUser(guildId, userId, reason) {
+    await this.rest.delete(import_v103.Routes.guildBan(guildId, userId), { reason });
+  }
+  async getRoles(guildId) {
+    return this.rest.get(import_v103.Routes.guildRoles(guildId));
+  }
+  async createRole(guildId, data, reason) {
+    return this.rest.post(import_v103.Routes.guildRoles(guildId), { reason, body: data });
+  }
+  async setRolePositions(guildId, data, reason) {
+    return this.rest.patch(import_v103.Routes.guildRoles(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async editRole(guildId, roleId, data, reason) {
+    return this.rest.patch(import_v103.Routes.guildRole(guildId, roleId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteRole(guildId, roleId, reason) {
+    await this.rest.delete(import_v103.Routes.guildRole(guildId, roleId), { reason });
+  }
+  async editMFALevel(guildId, level, reason) {
+    return this.rest.post(import_v103.Routes.guildMFA(guildId), {
+      reason,
+      body: { mfa_level: level }
+    });
+  }
+  async getPruneCount(guildId, options = {}) {
+    return this.rest.get(import_v103.Routes.guildPrune(guildId), {
+      query: (0, import_rest3.makeURLSearchParams)(options)
+    });
+  }
+  async beginPrune(guildId, options = {}, reason) {
+    return this.rest.post(import_v103.Routes.guildPrune(guildId), {
+      body: options,
+      reason
+    });
+  }
+  async getVoiceRegions(guildId) {
+    return this.rest.get(import_v103.Routes.guildVoiceRegions(guildId));
+  }
+  async getInvites(guildId) {
+    return this.rest.get(import_v103.Routes.guildInvites(guildId));
+  }
+  async getIntegrations(guildId) {
+    return this.rest.get(import_v103.Routes.guildIntegrations(guildId));
+  }
+  async deleteIntegration(guildId, integrationId, reason) {
+    await this.rest.delete(import_v103.Routes.guildIntegration(guildId, integrationId), { reason });
+  }
+  async getWidgetSettings(guildId) {
+    return this.rest.get(import_v103.Routes.guildWidgetSettings(guildId));
+  }
+  async editWidgetSettings(guildId, data, reason) {
+    return this.rest.patch(import_v103.Routes.guildWidgetSettings(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async getWidget(guildId) {
+    return this.rest.get(import_v103.Routes.guildWidgetJSON(guildId));
+  }
+  async getVanityURL(guildId) {
+    return this.rest.get(import_v103.Routes.guildVanityUrl(guildId));
+  }
+  async getWidgetImage(guildId, style) {
+    return this.rest.get(import_v103.Routes.guildWidgetImage(guildId), {
+      query: (0, import_rest3.makeURLSearchParams)({ style })
+    });
+  }
+  async getWelcomeScreen(guildId) {
+    return this.rest.get(import_v103.Routes.guildWelcomeScreen(guildId));
+  }
+  async editWelcomeScreen(guildId, data, reason) {
+    return this.rest.patch(import_v103.Routes.guildWelcomeScreen(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async editUserVoiceState(guildId, userId, data, reason) {
+    await this.rest.patch(import_v103.Routes.guildVoiceState(guildId, userId), { reason, body: data });
+  }
+  async getEmojis(guildId) {
+    return this.rest.get(import_v103.Routes.guildEmojis(guildId));
+  }
+  async getEmoji(guildId, emojiId) {
+    return this.rest.get(import_v103.Routes.guildEmoji(guildId, emojiId));
+  }
+  async createEmoji(guildId, data, reason) {
+    return this.rest.post(import_v103.Routes.guildEmojis(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async editEmoji(guildId, emojiId, data, reason) {
+    return this.rest.patch(import_v103.Routes.guildEmoji(guildId, emojiId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteEmoji(guildId, emojiId, reason) {
+    await this.rest.delete(import_v103.Routes.guildEmoji(guildId, emojiId), { reason });
+  }
+  async getScheduledEvents(guildId, options = {}) {
+    return this.rest.get(import_v103.Routes.guildScheduledEvents(guildId), {
+      query: (0, import_rest3.makeURLSearchParams)(options)
+    });
+  }
+  async createScheduledEvent(guildId, data, reason) {
+    return this.rest.post(import_v103.Routes.guildScheduledEvents(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async getScheduledEvent(guildId, eventId, options = {}) {
+    return this.rest.get(import_v103.Routes.guildScheduledEvent(guildId, eventId), {
+      query: (0, import_rest3.makeURLSearchParams)(options)
+    });
+  }
+  async editScheduledEvent(guildId, eventId, data, reason) {
+    return this.rest.patch(import_v103.Routes.guildScheduledEvent(guildId, eventId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteScheduledEvent(guildId, eventId, reason) {
+    await this.rest.delete(import_v103.Routes.guildScheduledEvent(guildId, eventId), { reason });
+  }
+  async getScheduledEventUsers(guildId, eventId, options = {}) {
+    return this.rest.get(import_v103.Routes.guildScheduledEventUsers(guildId, eventId), {
+      query: (0, import_rest3.makeURLSearchParams)(options)
+    });
+  }
+  async getTemplates(guildId) {
+    return this.rest.get(import_v103.Routes.guildTemplates(guildId));
+  }
+  async syncTemplate(guildId, templateCode) {
+    return this.rest.put(import_v103.Routes.guildTemplate(guildId, templateCode));
+  }
+  async editTemplate(guildId, templateCode, data) {
+    return this.rest.patch(import_v103.Routes.guildTemplate(guildId, templateCode), {
+      body: data
+    });
+  }
+  async deleteTemplate(guildId, templateCode) {
+    await this.rest.delete(import_v103.Routes.guildTemplate(guildId, templateCode));
+  }
+  async getStickers(guildId) {
+    return this.rest.get(import_v103.Routes.guildStickers(guildId));
+  }
+  async getSticker(guildId, stickerId) {
+    return this.rest.get(import_v103.Routes.guildSticker(guildId, stickerId));
+  }
+  async createSticker(guildId, { file, ...body }, reason) {
+    const fileData = { ...file, key: "file" };
+    return this.rest.post(import_v103.Routes.guildStickers(guildId), {
+      appendToFormData: true,
+      body,
+      files: [fileData],
+      reason
+    });
+  }
+  async editSticker(guildId, stickerId, data, reason) {
+    return this.rest.patch(import_v103.Routes.guildSticker(guildId, stickerId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteSticker(guildId, stickerId, reason) {
+    await this.rest.delete(import_v103.Routes.guildSticker(guildId, stickerId), { reason });
+  }
+  async getAuditLogs(guildId, options = {}) {
+    return this.rest.get(import_v103.Routes.guildAuditLog(guildId), {
+      query: (0, import_rest3.makeURLSearchParams)(options)
+    });
+  }
+  async getAutoModerationRules(guildId) {
+    return this.rest.get(import_v103.Routes.guildAutoModerationRules(guildId));
+  }
+  async getAutoModerationRule(guildId, ruleId) {
+    return this.rest.get(
+      import_v103.Routes.guildAutoModerationRule(guildId, ruleId)
+    );
+  }
+  async createAutoModerationRule(guildId, data, reason) {
+    return this.rest.post(import_v103.Routes.guildAutoModerationRules(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async editAutoModerationRule(guildId, ruleId, data, reason) {
+    return this.rest.patch(import_v103.Routes.guildAutoModerationRule(guildId, ruleId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteAutoModerationRule(guildId, ruleId, reason) {
+    await this.rest.delete(import_v103.Routes.guildAutoModerationRule(guildId, ruleId), { reason });
+  }
+  async getMember(guildId, userId) {
+    return this.rest.get(import_v103.Routes.guildMember(guildId, userId));
+  }
+  async searchForMembers(guildId, options) {
+    return this.rest.get(import_v103.Routes.guildMembersSearch(guildId), {
+      query: (0, import_rest3.makeURLSearchParams)(options)
+    });
+  }
+  async editMember(guildId, userId, data = {}, reason) {
+    return this.rest.patch(import_v103.Routes.guildMember(guildId, userId), {
+      reason,
+      body: data
+    });
+  }
+  async addRoleToMember(guildId, userId, roleId, reason) {
+    await this.rest.put(import_v103.Routes.guildMemberRole(guildId, userId, roleId), { reason });
+  }
+  async removeRoleFromMember(guildId, userId, roleId, reason) {
+    await this.rest.delete(import_v103.Routes.guildMemberRole(guildId, userId, roleId), { reason });
+  }
+  async getTemplate(templateCode) {
+    return this.rest.get(import_v103.Routes.template(templateCode));
+  }
+  async createTemplate(templateCode, data) {
+    return this.rest.post(import_v103.Routes.template(templateCode), { body: data });
+  }
+};
+__name(GuildsAPI, "GuildsAPI");
+
+// src/api/interactions.ts
+var import_v104 = require("discord-api-types/v10");
+var InteractionsAPI = class {
+  constructor(rest, webhooks) {
+    this.rest = rest;
+    this.webhooks = webhooks;
+  }
+  async reply(interactionId, interactionToken, { files, ...data }) {
+    await this.rest.post(import_v104.Routes.interactionCallback(interactionId, interactionToken), {
+      files,
+      body: {
+        type: import_v104.InteractionResponseType.ChannelMessageWithSource,
+        data
+      }
+    });
+  }
+  async defer(interactionId, interactionToken) {
+    await this.rest.post(import_v104.Routes.interactionCallback(interactionId, interactionToken), {
+      body: {
+        type: import_v104.InteractionResponseType.DeferredChannelMessageWithSource
+      }
+    });
+  }
+  async deferMessageUpdate(interactionId, interactionToken) {
+    await this.rest.post(import_v104.Routes.interactionCallback(interactionId, interactionToken), {
+      body: {
+        type: import_v104.InteractionResponseType.DeferredMessageUpdate
+      }
+    });
+  }
+  async followUp(applicationId, interactionToken, data) {
+    await this.webhooks.execute(applicationId, interactionToken, data);
+  }
+  async editReply(applicationId, interactionToken, data, messageId) {
+    return this.webhooks.editMessage(applicationId, interactionToken, messageId ?? "@original", data);
+  }
+  async getOriginalReply(applicationId, interactionToken) {
+    return this.webhooks.getMessage(
+      applicationId,
+      interactionToken,
+      "@original"
+    );
+  }
+  async deleteReply(applicationId, interactionToken) {
+    await this.webhooks.deleteMessage(applicationId, interactionToken, "@original");
+  }
+  async updateMessage(interactionId, interactionToken, { files, ...data }) {
+    await this.rest.post(import_v104.Routes.interactionCallback(interactionId, interactionToken), {
+      files,
+      body: {
+        type: import_v104.InteractionResponseType.UpdateMessage,
+        data
+      }
+    });
+  }
+  async createAutocompleteResponse(interactionId, interactionToken, data) {
+    await this.rest.post(import_v104.Routes.interactionCallback(interactionId, interactionToken), {
+      body: {
+        type: import_v104.InteractionResponseType.ApplicationCommandAutocompleteResult,
+        data
+      }
+    });
+  }
+  async createModal(interactionId, interactionToken, data) {
+    await this.rest.post(import_v104.Routes.interactionCallback(interactionId, interactionToken), {
+      body: {
+        type: import_v104.InteractionResponseType.Modal,
+        data
+      }
+    });
+  }
+};
+__name(InteractionsAPI, "InteractionsAPI");
+
+// src/api/invite.ts
+var import_rest4 = require("@discordjs/rest");
+var import_v105 = require("discord-api-types/v10");
+var InvitesAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(code, options = {}) {
+    return this.rest.get(import_v105.Routes.invite(code), {
+      query: (0, import_rest4.makeURLSearchParams)(options)
+    });
+  }
+  async delete(code, reason) {
+    await this.rest.delete(import_v105.Routes.invite(code), { reason });
+  }
+};
+__name(InvitesAPI, "InvitesAPI");
+
+// src/api/sticker.ts
+var import_v106 = require("discord-api-types/v10");
+var StickersAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async getNitroStickers() {
+    return this.rest.get(import_v106.Routes.nitroStickerPacks());
+  }
+  async get(stickerId) {
+    return this.rest.get(import_v106.Routes.sticker(stickerId));
+  }
+};
+__name(StickersAPI, "StickersAPI");
+
+// src/api/thread.ts
+var import_v107 = require("discord-api-types/v10");
+var ThreadsAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(channelId, threadId) {
+    return this.rest.get(import_v107.Routes.threads(channelId, threadId));
+  }
+  async create(channelId, { message_id, ...body }) {
+    return this.rest.post(import_v107.Routes.threads(channelId, message_id), { body });
+  }
+  async createForumThread(channelId, { message, ...optionsBody }) {
+    const { files, ...messageBody } = message;
+    const body = {
+      ...optionsBody,
+      message: messageBody
+    };
+    return this.rest.post(import_v107.Routes.threads(channelId), { files, body });
+  }
+  async join(threadId) {
+    await this.rest.put(import_v107.Routes.threadMembers(threadId, "@me"));
+  }
+  async addMember(threadId, userId) {
+    await this.rest.put(import_v107.Routes.threadMembers(threadId, userId));
+  }
+  async leave(threadId) {
+    await this.rest.delete(import_v107.Routes.threadMembers(threadId, "@me"));
+  }
+  async removeMember(threadId, userId) {
+    await this.rest.delete(import_v107.Routes.threadMembers(threadId, userId));
+  }
+  async getMember(threadId, userId) {
+    return this.rest.get(import_v107.Routes.threadMembers(threadId, userId));
+  }
+  async getAllMembers(threadId) {
+    return this.rest.get(import_v107.Routes.threadMembers(threadId));
+  }
+};
+__name(ThreadsAPI, "ThreadsAPI");
+
+// src/api/user.ts
+var import_rest5 = require("@discordjs/rest");
+var import_v108 = require("discord-api-types/v10");
+var UsersAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(userId) {
+    return this.rest.get(import_v108.Routes.user(userId));
+  }
+  async getCurrent() {
+    return this.rest.get(import_v108.Routes.user("@me"));
+  }
+  async getGuilds(options = {}) {
+    return this.rest.get(import_v108.Routes.userGuilds(), {
+      query: (0, import_rest5.makeURLSearchParams)(options)
+    });
+  }
+  async leaveGuild(guildId) {
+    await this.rest.delete(import_v108.Routes.userGuild(guildId));
+  }
+  async edit(user) {
+    return this.rest.patch(import_v108.Routes.user("@me"), { body: user });
+  }
+  async getGuildMember(guildId) {
+    return this.rest.get(import_v108.Routes.userGuildMember(guildId));
+  }
+  async editGuildMember(guildId, member = {}, reason) {
+    return this.rest.patch(import_v108.Routes.guildMember(guildId, "@me"), {
+      reason,
+      body: member
+    });
+  }
+  async setVoiceState(guildId, options = {}) {
+    return this.rest.patch(import_v108.Routes.guildVoiceState(guildId, "@me"), {
+      body: options
+    });
+  }
+  async createDM(userId) {
+    return this.rest.post(import_v108.Routes.userChannels(), {
+      body: { recipient_id: userId }
+    });
+  }
+};
+__name(UsersAPI, "UsersAPI");
+
+// src/api/voice.ts
+var import_v109 = require("discord-api-types/v10");
+var VoiceAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async getVoiceRegions() {
+    return this.rest.get(import_v109.Routes.voiceRegions());
+  }
+};
+__name(VoiceAPI, "VoiceAPI");
+
+// src/api/webhook.ts
+var import_rest6 = require("@discordjs/rest");
+var import_v1010 = require("discord-api-types/v10");
+var WebhooksAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(id, token) {
+    return this.rest.get(import_v1010.Routes.webhook(id, token));
+  }
+  async create(channelId, data, reason) {
+    return this.rest.post(import_v1010.Routes.channelWebhooks(channelId), {
+      reason,
+      body: data
+    });
+  }
+  async edit(id, webhook, { token, reason } = {}) {
+    return this.rest.patch(import_v1010.Routes.webhook(id, token), { reason, body: webhook });
+  }
+  async delete(id, { token, reason } = {}) {
+    await this.rest.delete(import_v1010.Routes.webhook(id, token), { reason });
+  }
+  async execute(id, token, {
+    wait,
+    thread_id,
+    files,
+    ...body
+  }) {
+    return this.rest.post(import_v1010.Routes.webhook(id, token), {
+      query: (0, import_rest6.makeURLSearchParams)({ wait, thread_id }),
+      files,
+      body,
+      auth: false
+    });
+  }
+  async executeSlack(id, token, body, options = {}) {
+    await this.rest.post(import_v1010.Routes.webhookPlatform(id, token, "slack"), {
+      query: (0, import_rest6.makeURLSearchParams)(options),
+      body,
+      auth: false
+    });
+  }
+  async executeGitHub(id, token, body, options = {}) {
+    await this.rest.post(import_v1010.Routes.webhookPlatform(id, token, "github"), {
+      query: (0, import_rest6.makeURLSearchParams)(options),
+      body,
+      auth: false
+    });
+  }
+  async getMessage(id, token, messageId, options = {}) {
+    return this.rest.get(import_v1010.Routes.webhookMessage(id, token, messageId), {
+      query: (0, import_rest6.makeURLSearchParams)(options),
+      auth: false
+    });
+  }
+  async editMessage(id, token, messageId, { thread_id, ...body }) {
+    return this.rest.patch(import_v1010.Routes.webhookMessage(id, token, messageId), {
+      query: (0, import_rest6.makeURLSearchParams)({ thread_id }),
+      auth: false,
+      body
+    });
+  }
+  async deleteMessage(id, token, messageId, options = {}) {
+    await this.rest.delete(import_v1010.Routes.webhookMessage(id, token, messageId), {
+      query: (0, import_rest6.makeURLSearchParams)(options),
+      auth: false
+    });
+  }
+};
+__name(WebhooksAPI, "WebhooksAPI");
+
+// src/api/index.ts
+var API = class {
+  constructor(rest) {
+    this.rest = rest;
+    this.applicationCommands = new ApplicationCommandsAPI(rest);
+    this.channels = new ChannelsAPI(rest);
+    this.guilds = new GuildsAPI(rest);
+    this.invites = new InvitesAPI(rest);
+    this.stickers = new StickersAPI(rest);
+    this.threads = new ThreadsAPI(rest);
+    this.users = new UsersAPI(rest);
+    this.voice = new VoiceAPI(rest);
+    this.webhooks = new WebhooksAPI(rest);
+    this.interactions = new InteractionsAPI(rest, this.webhooks);
+  }
+  applicationCommands;
+  channels;
+  guilds;
+  interactions;
+  invites;
+  stickers;
+  threads;
+  users;
+  voice;
+  webhooks;
+};
+__name(API, "API");
+
+// src/client.ts
+var import_ws = require("@discordjs/ws");
+var import_async_event_emitter = require("@vladfrangu/async_event_emitter");
+function createClient({ rest, ws }) {
+  const api = new API(rest);
+  const emitter = new import_async_event_emitter.AsyncEventEmitter();
+  function wrapIntrinsicProps(obj, shardId) {
+    return {
+      api,
+      shardId,
+      data: obj
+    };
+  }
+  __name(wrapIntrinsicProps, "wrapIntrinsicProps");
+  ws.on(import_ws.WebSocketShardEvents.Dispatch, ({ data: dispatch, shardId }) => {
+    emitter.emit(dispatch.t, wrapIntrinsicProps(dispatch.d, shardId));
+  });
+  return emitter;
+}
+__name(createClient, "createClient");
+
+// src/util/files.ts
+function withFiles(files, options) {
+  const body = {
+    ...options,
+    attachments: files.map((file, index) => ({
+      id: index.toString(),
+      description: file.description
+    }))
+  };
+  const outputFiles = files.map((file, index) => ({
+    name: file.name ?? index.toString(),
+    data: file.data
+  }));
+  return { body, files: outputFiles };
+}
+__name(withFiles, "withFiles");
+
+// src/index.ts
+__reExport(src_exports, require("discord-api-types/v10"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API,
+  ApplicationCommandsAPI,
+  ChannelsAPI,
+  GuildsAPI,
+  InteractionsAPI,
+  InvitesAPI,
+  StickersAPI,
+  ThreadsAPI,
+  UsersAPI,
+  VoiceAPI,
+  WebhooksAPI,
+  createClient,
+  withFiles
+});
+//# sourceMappingURL=index.js.map