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

package/dist/index.mjs

@@ -0,0 +1,849 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/api/applicationCommands.ts
+import { makeURLSearchParams } from "@discordjs/rest";
+import {
+  Routes
+} from "discord-api-types/v10";
+var ApplicationCommandsAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async getGlobalCommands(applicationId, options = {}) {
+    return this.rest.get(Routes.applicationCommands(applicationId), {
+      query: makeURLSearchParams(options)
+    });
+  }
+  async createGlobalCommand(applicationId, data) {
+    return this.rest.post(Routes.applicationCommands(applicationId), {
+      body: data
+    });
+  }
+  async getGlobalCommand(applicationId, commandId) {
+    return this.rest.get(
+      Routes.applicationCommand(applicationId, commandId)
+    );
+  }
+  async editGlobalCommand(applicationId, commandId, data) {
+    return this.rest.patch(Routes.applicationCommand(applicationId, commandId), {
+      body: data
+    });
+  }
+  async deleteGlobalCommand(applicationId, commandId) {
+    await this.rest.delete(Routes.applicationCommand(applicationId, commandId));
+  }
+  async bulkOverwriteGlobalCommands(applicationId, data) {
+    return this.rest.put(Routes.applicationCommands(applicationId), {
+      body: data
+    });
+  }
+  async getGuildCommands(applicationId, guildId, data = {}) {
+    return this.rest.get(Routes.applicationGuildCommands(applicationId, guildId), {
+      query: makeURLSearchParams(data)
+    });
+  }
+  async createGuildCommand(applicationId, guildId, data) {
+    return this.rest.post(Routes.applicationGuildCommands(applicationId, guildId), {
+      body: data
+    });
+  }
+  async getGuildCommand(applicationId, guildId, commandId) {
+    return this.rest.get(
+      Routes.applicationGuildCommand(applicationId, guildId, commandId)
+    );
+  }
+  async editGuildCommand(applicationId, guildId, commandId, data) {
+    return this.rest.patch(Routes.applicationGuildCommand(applicationId, guildId, commandId), {
+      body: data
+    });
+  }
+  async deleteGuildCommand(applicationId, guildId, commandId) {
+    await this.rest.delete(Routes.applicationGuildCommand(applicationId, guildId, commandId));
+  }
+  async bulkOverwriteGuildCommands(applicationId, guildId, data) {
+    return this.rest.put(Routes.applicationGuildCommands(applicationId, guildId), {
+      body: data
+    });
+  }
+  async getGuildCommandPermissions(applicationId, guildId, commandId) {
+    return this.rest.get(
+      Routes.applicationCommandPermissions(applicationId, guildId, commandId)
+    );
+  }
+  async getGuildCommandsPermissions(applicationId, guildId) {
+    return this.rest.get(
+      Routes.guildApplicationCommandsPermissions(applicationId, guildId)
+    );
+  }
+  async editGuildCommandPermissions(userToken, applicationId, guildId, commandId, data) {
+    return this.rest.put(Routes.applicationCommandPermissions(applicationId, guildId, commandId), {
+      headers: { Authorization: `Bearer ${userToken.replace("Bearer ", "")}` },
+      auth: false,
+      body: data
+    });
+  }
+};
+__name(ApplicationCommandsAPI, "ApplicationCommandsAPI");
+
+// src/api/channel.ts
+import { makeURLSearchParams as makeURLSearchParams2 } from "@discordjs/rest";
+import {
+  Routes as Routes2
+} from "discord-api-types/v10";
+var ChannelsAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async createMessage(channelId, { files, ...body }) {
+    return this.rest.post(Routes2.channelMessages(channelId), {
+      files,
+      body
+    });
+  }
+  async editMessage(channelId, messageId, { files, ...body }) {
+    return this.rest.patch(Routes2.channelMessage(channelId, messageId), {
+      files,
+      body
+    });
+  }
+  async getMessageReactions(channelId, messageId, emoji, options = {}) {
+    return this.rest.get(Routes2.channelMessageReaction(channelId, messageId, encodeURIComponent(emoji)), {
+      query: makeURLSearchParams2(options)
+    });
+  }
+  async deleteOwnMessageReaction(channelId, messageId, emoji) {
+    await this.rest.delete(Routes2.channelMessageOwnReaction(channelId, messageId, encodeURIComponent(emoji)));
+  }
+  async deleteUserMessageReaction(channelId, messageId, emoji, userId) {
+    await this.rest.delete(Routes2.channelMessageUserReaction(channelId, messageId, encodeURIComponent(emoji), userId));
+  }
+  async deleteAllMessageReactions(channelId, messageId) {
+    await this.rest.delete(Routes2.channelMessageAllReactions(channelId, messageId));
+  }
+  async deleteAllMessageReactionsForEmoji(channelId, messageId, emoji) {
+    await this.rest.delete(Routes2.channelMessageReaction(channelId, messageId, encodeURIComponent(emoji)));
+  }
+  async addMessageReaction(channelId, messageId, emoji) {
+    await this.rest.put(Routes2.channelMessageOwnReaction(channelId, messageId, encodeURIComponent(emoji)));
+  }
+  async get(channelId) {
+    return this.rest.get(Routes2.channel(channelId));
+  }
+  async edit(channelId, data) {
+    return this.rest.patch(Routes2.channel(channelId), { body: data });
+  }
+  async delete(channelId) {
+    return this.rest.delete(Routes2.channel(channelId));
+  }
+  async getMessages(channelId, options = {}) {
+    return this.rest.get(Routes2.channelMessages(channelId), {
+      query: makeURLSearchParams2(options)
+    });
+  }
+  async showTyping(channelId) {
+    await this.rest.post(Routes2.channelTyping(channelId));
+  }
+  async getPins(channelId) {
+    return this.rest.get(Routes2.channelPins(channelId));
+  }
+  async pinMessage(channelId, messageId, reason) {
+    await this.rest.put(Routes2.channelPin(channelId, messageId), { reason });
+  }
+  async deleteMessage(channelId, messageId, reason) {
+    await this.rest.delete(Routes2.channelMessage(channelId, messageId), { reason });
+  }
+  async bulkDeleteMessages(channelId, messageIds, reason) {
+    await this.rest.post(Routes2.channelBulkDelete(channelId), { reason, body: { messages: messageIds } });
+  }
+  async getMessage(channelId, messageId) {
+    return this.rest.get(Routes2.channelMessage(channelId, messageId));
+  }
+  async crosspostMessage(channelId, messageId) {
+    return this.rest.post(
+      Routes2.channelMessageCrosspost(channelId, messageId)
+    );
+  }
+  async unpinMessage(channelId, messageId, reason) {
+    await this.rest.delete(Routes2.channelPin(channelId, messageId), { reason });
+  }
+  async followAnnouncements(channelId, webhookChannelId) {
+    return this.rest.post(Routes2.channelFollowers(channelId), {
+      body: { webhook_channel_id: webhookChannelId }
+    });
+  }
+  async createInvite(channelId, data, reason) {
+    return this.rest.post(Routes2.channelInvites(channelId), {
+      reason,
+      body: data
+    });
+  }
+  async getInvites(channelId) {
+    return this.rest.get(Routes2.channelInvites(channelId));
+  }
+  async getArchivedThreads(channelId, archivedStatus, options = {}) {
+    return this.rest.get(Routes2.channelThreads(channelId, archivedStatus), {
+      query: makeURLSearchParams2(options)
+    });
+  }
+  async getJoinedPrivateArchivedThreads(channelId, options = {}) {
+    return this.rest.get(Routes2.channelJoinedArchivedThreads(channelId), {
+      query: makeURLSearchParams2(options)
+    });
+  }
+};
+__name(ChannelsAPI, "ChannelsAPI");
+
+// src/api/guild.ts
+import { makeURLSearchParams as makeURLSearchParams3 } from "@discordjs/rest";
+import {
+  Routes as Routes3
+} from "discord-api-types/v10";
+var GuildsAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(guildId) {
+    return this.rest.get(Routes3.guild(guildId));
+  }
+  async getPreview(guildId) {
+    return this.rest.get(Routes3.guildPreview(guildId));
+  }
+  async create(data) {
+    return this.rest.post(Routes3.guilds(), { body: data });
+  }
+  async edit(guildId, data, reason) {
+    return this.rest.patch(Routes3.guild(guildId), { reason, body: data });
+  }
+  async delete(guildId, reason) {
+    await this.rest.delete(Routes3.guild(guildId), { reason });
+  }
+  async getMembers(guildId, options = {}) {
+    return this.rest.get(Routes3.guildMembers(guildId), {
+      query: makeURLSearchParams3(options)
+    });
+  }
+  async getChannels(guildId) {
+    return this.rest.get(Routes3.guildChannels(guildId));
+  }
+  async createChannel(guildId, data, reason) {
+    return this.rest.post(Routes3.guildChannels(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async setChannelPositions(guildId, data, reason) {
+    await this.rest.patch(Routes3.guildChannels(guildId), { reason, body: data });
+  }
+  async getActiveThreads(guildId) {
+    return this.rest.get(Routes3.guildActiveThreads(guildId));
+  }
+  async getMemberBans(guildId) {
+    return this.rest.get(Routes3.guildBans(guildId));
+  }
+  async banUser(guildId, userId, options = {}, reason) {
+    await this.rest.put(Routes3.guildBan(guildId, userId), { reason, body: options });
+  }
+  async unbanUser(guildId, userId, reason) {
+    await this.rest.delete(Routes3.guildBan(guildId, userId), { reason });
+  }
+  async getRoles(guildId) {
+    return this.rest.get(Routes3.guildRoles(guildId));
+  }
+  async createRole(guildId, data, reason) {
+    return this.rest.post(Routes3.guildRoles(guildId), { reason, body: data });
+  }
+  async setRolePositions(guildId, data, reason) {
+    return this.rest.patch(Routes3.guildRoles(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async editRole(guildId, roleId, data, reason) {
+    return this.rest.patch(Routes3.guildRole(guildId, roleId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteRole(guildId, roleId, reason) {
+    await this.rest.delete(Routes3.guildRole(guildId, roleId), { reason });
+  }
+  async editMFALevel(guildId, level, reason) {
+    return this.rest.post(Routes3.guildMFA(guildId), {
+      reason,
+      body: { mfa_level: level }
+    });
+  }
+  async getPruneCount(guildId, options = {}) {
+    return this.rest.get(Routes3.guildPrune(guildId), {
+      query: makeURLSearchParams3(options)
+    });
+  }
+  async beginPrune(guildId, options = {}, reason) {
+    return this.rest.post(Routes3.guildPrune(guildId), {
+      body: options,
+      reason
+    });
+  }
+  async getVoiceRegions(guildId) {
+    return this.rest.get(Routes3.guildVoiceRegions(guildId));
+  }
+  async getInvites(guildId) {
+    return this.rest.get(Routes3.guildInvites(guildId));
+  }
+  async getIntegrations(guildId) {
+    return this.rest.get(Routes3.guildIntegrations(guildId));
+  }
+  async deleteIntegration(guildId, integrationId, reason) {
+    await this.rest.delete(Routes3.guildIntegration(guildId, integrationId), { reason });
+  }
+  async getWidgetSettings(guildId) {
+    return this.rest.get(Routes3.guildWidgetSettings(guildId));
+  }
+  async editWidgetSettings(guildId, data, reason) {
+    return this.rest.patch(Routes3.guildWidgetSettings(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async getWidget(guildId) {
+    return this.rest.get(Routes3.guildWidgetJSON(guildId));
+  }
+  async getVanityURL(guildId) {
+    return this.rest.get(Routes3.guildVanityUrl(guildId));
+  }
+  async getWidgetImage(guildId, style) {
+    return this.rest.get(Routes3.guildWidgetImage(guildId), {
+      query: makeURLSearchParams3({ style })
+    });
+  }
+  async getWelcomeScreen(guildId) {
+    return this.rest.get(Routes3.guildWelcomeScreen(guildId));
+  }
+  async editWelcomeScreen(guildId, data, reason) {
+    return this.rest.patch(Routes3.guildWelcomeScreen(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async editUserVoiceState(guildId, userId, data, reason) {
+    await this.rest.patch(Routes3.guildVoiceState(guildId, userId), { reason, body: data });
+  }
+  async getEmojis(guildId) {
+    return this.rest.get(Routes3.guildEmojis(guildId));
+  }
+  async getEmoji(guildId, emojiId) {
+    return this.rest.get(Routes3.guildEmoji(guildId, emojiId));
+  }
+  async createEmoji(guildId, data, reason) {
+    return this.rest.post(Routes3.guildEmojis(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async editEmoji(guildId, emojiId, data, reason) {
+    return this.rest.patch(Routes3.guildEmoji(guildId, emojiId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteEmoji(guildId, emojiId, reason) {
+    await this.rest.delete(Routes3.guildEmoji(guildId, emojiId), { reason });
+  }
+  async getScheduledEvents(guildId, options = {}) {
+    return this.rest.get(Routes3.guildScheduledEvents(guildId), {
+      query: makeURLSearchParams3(options)
+    });
+  }
+  async createScheduledEvent(guildId, data, reason) {
+    return this.rest.post(Routes3.guildScheduledEvents(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async getScheduledEvent(guildId, eventId, options = {}) {
+    return this.rest.get(Routes3.guildScheduledEvent(guildId, eventId), {
+      query: makeURLSearchParams3(options)
+    });
+  }
+  async editScheduledEvent(guildId, eventId, data, reason) {
+    return this.rest.patch(Routes3.guildScheduledEvent(guildId, eventId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteScheduledEvent(guildId, eventId, reason) {
+    await this.rest.delete(Routes3.guildScheduledEvent(guildId, eventId), { reason });
+  }
+  async getScheduledEventUsers(guildId, eventId, options = {}) {
+    return this.rest.get(Routes3.guildScheduledEventUsers(guildId, eventId), {
+      query: makeURLSearchParams3(options)
+    });
+  }
+  async getTemplates(guildId) {
+    return this.rest.get(Routes3.guildTemplates(guildId));
+  }
+  async syncTemplate(guildId, templateCode) {
+    return this.rest.put(Routes3.guildTemplate(guildId, templateCode));
+  }
+  async editTemplate(guildId, templateCode, data) {
+    return this.rest.patch(Routes3.guildTemplate(guildId, templateCode), {
+      body: data
+    });
+  }
+  async deleteTemplate(guildId, templateCode) {
+    await this.rest.delete(Routes3.guildTemplate(guildId, templateCode));
+  }
+  async getStickers(guildId) {
+    return this.rest.get(Routes3.guildStickers(guildId));
+  }
+  async getSticker(guildId, stickerId) {
+    return this.rest.get(Routes3.guildSticker(guildId, stickerId));
+  }
+  async createSticker(guildId, { file, ...body }, reason) {
+    const fileData = { ...file, key: "file" };
+    return this.rest.post(Routes3.guildStickers(guildId), {
+      appendToFormData: true,
+      body,
+      files: [fileData],
+      reason
+    });
+  }
+  async editSticker(guildId, stickerId, data, reason) {
+    return this.rest.patch(Routes3.guildSticker(guildId, stickerId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteSticker(guildId, stickerId, reason) {
+    await this.rest.delete(Routes3.guildSticker(guildId, stickerId), { reason });
+  }
+  async getAuditLogs(guildId, options = {}) {
+    return this.rest.get(Routes3.guildAuditLog(guildId), {
+      query: makeURLSearchParams3(options)
+    });
+  }
+  async getAutoModerationRules(guildId) {
+    return this.rest.get(Routes3.guildAutoModerationRules(guildId));
+  }
+  async getAutoModerationRule(guildId, ruleId) {
+    return this.rest.get(
+      Routes3.guildAutoModerationRule(guildId, ruleId)
+    );
+  }
+  async createAutoModerationRule(guildId, data, reason) {
+    return this.rest.post(Routes3.guildAutoModerationRules(guildId), {
+      reason,
+      body: data
+    });
+  }
+  async editAutoModerationRule(guildId, ruleId, data, reason) {
+    return this.rest.patch(Routes3.guildAutoModerationRule(guildId, ruleId), {
+      reason,
+      body: data
+    });
+  }
+  async deleteAutoModerationRule(guildId, ruleId, reason) {
+    await this.rest.delete(Routes3.guildAutoModerationRule(guildId, ruleId), { reason });
+  }
+  async getMember(guildId, userId) {
+    return this.rest.get(Routes3.guildMember(guildId, userId));
+  }
+  async searchForMembers(guildId, options) {
+    return this.rest.get(Routes3.guildMembersSearch(guildId), {
+      query: makeURLSearchParams3(options)
+    });
+  }
+  async editMember(guildId, userId, data = {}, reason) {
+    return this.rest.patch(Routes3.guildMember(guildId, userId), {
+      reason,
+      body: data
+    });
+  }
+  async addRoleToMember(guildId, userId, roleId, reason) {
+    await this.rest.put(Routes3.guildMemberRole(guildId, userId, roleId), { reason });
+  }
+  async removeRoleFromMember(guildId, userId, roleId, reason) {
+    await this.rest.delete(Routes3.guildMemberRole(guildId, userId, roleId), { reason });
+  }
+  async getTemplate(templateCode) {
+    return this.rest.get(Routes3.template(templateCode));
+  }
+  async createTemplate(templateCode, data) {
+    return this.rest.post(Routes3.template(templateCode), { body: data });
+  }
+};
+__name(GuildsAPI, "GuildsAPI");
+
+// src/api/interactions.ts
+import {
+  InteractionResponseType,
+  Routes as Routes4
+} from "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(Routes4.interactionCallback(interactionId, interactionToken), {
+      files,
+      body: {
+        type: InteractionResponseType.ChannelMessageWithSource,
+        data
+      }
+    });
+  }
+  async defer(interactionId, interactionToken) {
+    await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
+      body: {
+        type: InteractionResponseType.DeferredChannelMessageWithSource
+      }
+    });
+  }
+  async deferMessageUpdate(interactionId, interactionToken) {
+    await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
+      body: {
+        type: 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(Routes4.interactionCallback(interactionId, interactionToken), {
+      files,
+      body: {
+        type: InteractionResponseType.UpdateMessage,
+        data
+      }
+    });
+  }
+  async createAutocompleteResponse(interactionId, interactionToken, data) {
+    await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
+      body: {
+        type: InteractionResponseType.ApplicationCommandAutocompleteResult,
+        data
+      }
+    });
+  }
+  async createModal(interactionId, interactionToken, data) {
+    await this.rest.post(Routes4.interactionCallback(interactionId, interactionToken), {
+      body: {
+        type: InteractionResponseType.Modal,
+        data
+      }
+    });
+  }
+};
+__name(InteractionsAPI, "InteractionsAPI");
+
+// src/api/invite.ts
+import { makeURLSearchParams as makeURLSearchParams4 } from "@discordjs/rest";
+import { Routes as Routes5 } from "discord-api-types/v10";
+var InvitesAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(code, options = {}) {
+    return this.rest.get(Routes5.invite(code), {
+      query: makeURLSearchParams4(options)
+    });
+  }
+  async delete(code, reason) {
+    await this.rest.delete(Routes5.invite(code), { reason });
+  }
+};
+__name(InvitesAPI, "InvitesAPI");
+
+// src/api/sticker.ts
+import {
+  Routes as Routes6
+} from "discord-api-types/v10";
+var StickersAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async getNitroStickers() {
+    return this.rest.get(Routes6.nitroStickerPacks());
+  }
+  async get(stickerId) {
+    return this.rest.get(Routes6.sticker(stickerId));
+  }
+};
+__name(StickersAPI, "StickersAPI");
+
+// src/api/thread.ts
+import {
+  Routes as Routes7
+} from "discord-api-types/v10";
+var ThreadsAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(channelId, threadId) {
+    return this.rest.get(Routes7.threads(channelId, threadId));
+  }
+  async create(channelId, { message_id, ...body }) {
+    return this.rest.post(Routes7.threads(channelId, message_id), { body });
+  }
+  async createForumThread(channelId, { message, ...optionsBody }) {
+    const { files, ...messageBody } = message;
+    const body = {
+      ...optionsBody,
+      message: messageBody
+    };
+    return this.rest.post(Routes7.threads(channelId), { files, body });
+  }
+  async join(threadId) {
+    await this.rest.put(Routes7.threadMembers(threadId, "@me"));
+  }
+  async addMember(threadId, userId) {
+    await this.rest.put(Routes7.threadMembers(threadId, userId));
+  }
+  async leave(threadId) {
+    await this.rest.delete(Routes7.threadMembers(threadId, "@me"));
+  }
+  async removeMember(threadId, userId) {
+    await this.rest.delete(Routes7.threadMembers(threadId, userId));
+  }
+  async getMember(threadId, userId) {
+    return this.rest.get(Routes7.threadMembers(threadId, userId));
+  }
+  async getAllMembers(threadId) {
+    return this.rest.get(Routes7.threadMembers(threadId));
+  }
+};
+__name(ThreadsAPI, "ThreadsAPI");
+
+// src/api/user.ts
+import { makeURLSearchParams as makeURLSearchParams5 } from "@discordjs/rest";
+import {
+  Routes as Routes8
+} from "discord-api-types/v10";
+var UsersAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(userId) {
+    return this.rest.get(Routes8.user(userId));
+  }
+  async getCurrent() {
+    return this.rest.get(Routes8.user("@me"));
+  }
+  async getGuilds(options = {}) {
+    return this.rest.get(Routes8.userGuilds(), {
+      query: makeURLSearchParams5(options)
+    });
+  }
+  async leaveGuild(guildId) {
+    await this.rest.delete(Routes8.userGuild(guildId));
+  }
+  async edit(user) {
+    return this.rest.patch(Routes8.user("@me"), { body: user });
+  }
+  async getGuildMember(guildId) {
+    return this.rest.get(Routes8.userGuildMember(guildId));
+  }
+  async editGuildMember(guildId, member = {}, reason) {
+    return this.rest.patch(Routes8.guildMember(guildId, "@me"), {
+      reason,
+      body: member
+    });
+  }
+  async setVoiceState(guildId, options = {}) {
+    return this.rest.patch(Routes8.guildVoiceState(guildId, "@me"), {
+      body: options
+    });
+  }
+  async createDM(userId) {
+    return this.rest.post(Routes8.userChannels(), {
+      body: { recipient_id: userId }
+    });
+  }
+};
+__name(UsersAPI, "UsersAPI");
+
+// src/api/voice.ts
+import { Routes as Routes9 } from "discord-api-types/v10";
+var VoiceAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async getVoiceRegions() {
+    return this.rest.get(Routes9.voiceRegions());
+  }
+};
+__name(VoiceAPI, "VoiceAPI");
+
+// src/api/webhook.ts
+import { makeURLSearchParams as makeURLSearchParams6 } from "@discordjs/rest";
+import {
+  Routes as Routes10
+} from "discord-api-types/v10";
+var WebhooksAPI = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  async get(id, token) {
+    return this.rest.get(Routes10.webhook(id, token));
+  }
+  async create(channelId, data, reason) {
+    return this.rest.post(Routes10.channelWebhooks(channelId), {
+      reason,
+      body: data
+    });
+  }
+  async edit(id, webhook, { token, reason } = {}) {
+    return this.rest.patch(Routes10.webhook(id, token), { reason, body: webhook });
+  }
+  async delete(id, { token, reason } = {}) {
+    await this.rest.delete(Routes10.webhook(id, token), { reason });
+  }
+  async execute(id, token, {
+    wait,
+    thread_id,
+    files,
+    ...body
+  }) {
+    return this.rest.post(Routes10.webhook(id, token), {
+      query: makeURLSearchParams6({ wait, thread_id }),
+      files,
+      body,
+      auth: false
+    });
+  }
+  async executeSlack(id, token, body, options = {}) {
+    await this.rest.post(Routes10.webhookPlatform(id, token, "slack"), {
+      query: makeURLSearchParams6(options),
+      body,
+      auth: false
+    });
+  }
+  async executeGitHub(id, token, body, options = {}) {
+    await this.rest.post(Routes10.webhookPlatform(id, token, "github"), {
+      query: makeURLSearchParams6(options),
+      body,
+      auth: false
+    });
+  }
+  async getMessage(id, token, messageId, options = {}) {
+    return this.rest.get(Routes10.webhookMessage(id, token, messageId), {
+      query: makeURLSearchParams6(options),
+      auth: false
+    });
+  }
+  async editMessage(id, token, messageId, { thread_id, ...body }) {
+    return this.rest.patch(Routes10.webhookMessage(id, token, messageId), {
+      query: makeURLSearchParams6({ thread_id }),
+      auth: false,
+      body
+    });
+  }
+  async deleteMessage(id, token, messageId, options = {}) {
+    await this.rest.delete(Routes10.webhookMessage(id, token, messageId), {
+      query: makeURLSearchParams6(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
+import { WebSocketShardEvents } from "@discordjs/ws";
+import { AsyncEventEmitter } from "@vladfrangu/async_event_emitter";
+function createClient({ rest, ws }) {
+  const api = new API(rest);
+  const emitter = new AsyncEventEmitter();
+  function wrapIntrinsicProps(obj, shardId) {
+    return {
+      api,
+      shardId,
+      data: obj
+    };
+  }
+  __name(wrapIntrinsicProps, "wrapIntrinsicProps");
+  ws.on(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
+export * from "discord-api-types/v10";
+export {
+  API,
+  ApplicationCommandsAPI,
+  ChannelsAPI,
+  GuildsAPI,
+  InteractionsAPI,
+  InvitesAPI,
+  StickersAPI,
+  ThreadsAPI,
+  UsersAPI,
+  VoiceAPI,
+  WebhooksAPI,
+  createClient,
+  withFiles
+};
+//# sourceMappingURL=index.mjs.map