dfx 0.9.8 → 0.9.9

package/types.js

@@ -0,0 +1,1796 @@
+export var ActionType;
+(function (ActionType) {
+    /** blocks the content of a message according to the rule */
+    ActionType[ActionType["BLOCK_MESSAGE"] = 1] = "BLOCK_MESSAGE";
+    /** logs user content to a specified channel */
+    ActionType[ActionType["SEND_ALERT_MESSAGE"] = 2] = "SEND_ALERT_MESSAGE";
+    /** timeout user for a specified duration * */
+    ActionType[ActionType["TIMEOUT"] = 3] = "TIMEOUT";
+})(ActionType || (ActionType = {}));
+export const ActivityFlag = {
+    INSTANCE: 1 << 0,
+    JOIN: 1 << 1,
+    SPECTATE: 1 << 2,
+    JOIN_REQUEST: 1 << 3,
+    SYNC: 1 << 4,
+    PLAY: 1 << 5,
+    PARTY_PRIVACY_FRIENDS: 1 << 6,
+    PARTY_PRIVACY_VOICE_CHANNEL: 1 << 7,
+    EMBEDDED: 1 << 8,
+};
+export var ActivityType;
+(function (ActivityType) {
+    ActivityType[ActivityType["GAME"] = 0] = "GAME";
+    ActivityType[ActivityType["STREAMING"] = 1] = "STREAMING";
+    ActivityType[ActivityType["LISTENING"] = 2] = "LISTENING";
+    ActivityType[ActivityType["WATCHING"] = 3] = "WATCHING";
+    ActivityType[ActivityType["CUSTOM"] = 4] = "CUSTOM";
+    ActivityType[ActivityType["COMPETING"] = 5] = "COMPETING";
+})(ActivityType || (ActivityType = {}));
+export var AllowedMentionType;
+(function (AllowedMentionType) {
+    /** Controls role mentions */
+    AllowedMentionType["ROLE_MENTIONS"] = "roles";
+    /** Controls user mentions */
+    AllowedMentionType["USER_MENTIONS"] = "users";
+    /** Controls @everyone and @here mentions */
+    AllowedMentionType["EVERYONE_MENTIONS"] = "everyone";
+})(AllowedMentionType || (AllowedMentionType = {}));
+export var ApplicationCommandOptionType;
+(function (ApplicationCommandOptionType) {
+    ApplicationCommandOptionType[ApplicationCommandOptionType["SUB_COMMAND"] = 1] = "SUB_COMMAND";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["SUB_COMMAND_GROUP"] = 2] = "SUB_COMMAND_GROUP";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["STRING"] = 3] = "STRING";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["INTEGER"] = 4] = "INTEGER";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["BOOLEAN"] = 5] = "BOOLEAN";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["USER"] = 6] = "USER";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["CHANNEL"] = 7] = "CHANNEL";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["ROLE"] = 8] = "ROLE";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["MENTIONABLE"] = 9] = "MENTIONABLE";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["NUMBER"] = 10] = "NUMBER";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["ATTACHMENT"] = 11] = "ATTACHMENT";
+})(ApplicationCommandOptionType || (ApplicationCommandOptionType = {}));
+export var ApplicationCommandPermissionType;
+(function (ApplicationCommandPermissionType) {
+    ApplicationCommandPermissionType[ApplicationCommandPermissionType["ROLE"] = 1] = "ROLE";
+    ApplicationCommandPermissionType[ApplicationCommandPermissionType["USER"] = 2] = "USER";
+    ApplicationCommandPermissionType[ApplicationCommandPermissionType["CHANNEL"] = 3] = "CHANNEL";
+})(ApplicationCommandPermissionType || (ApplicationCommandPermissionType = {}));
+export var ApplicationCommandType;
+(function (ApplicationCommandType) {
+    /** Slash commands; a text-based command that shows up when a user types / */
+    ApplicationCommandType[ApplicationCommandType["CHAT_INPUT"] = 1] = "CHAT_INPUT";
+    /** A UI-based command that shows up when you right click or tap on a user */
+    ApplicationCommandType[ApplicationCommandType["USER"] = 2] = "USER";
+    /** A UI-based command that shows up when you right click or tap on a message */
+    ApplicationCommandType[ApplicationCommandType["MESSAGE"] = 3] = "MESSAGE";
+})(ApplicationCommandType || (ApplicationCommandType = {}));
+export const ApplicationFlag = {
+    /** Intent required for bots in 100 or more servers to receive presence_update events */
+    GATEWAY_PRESENCE: 1 << 12,
+    /** Intent required for bots in under 100 servers to receive presence_update events, found in Bot Settings */
+    GATEWAY_PRESENCE_LIMITED: 1 << 13,
+    /** Intent required for bots in 100 or more servers to receive member-related events like guild_member_add. See list of member-related events under GUILD_MEMBERS */
+    GATEWAY_GUILD_MEMBERS: 1 << 14,
+    /** Intent required for bots in under 100 servers to receive member-related events like guild_member_add, found in Bot Settings. See list of member-related events under GUILD_MEMBERS */
+    GATEWAY_GUILD_MEMBERS_LIMITED: 1 << 15,
+    /** Indicates unusual growth of an app that prevents verification */
+    VERIFICATION_PENDING_GUILD_LIMIT: 1 << 16,
+    /** Indicates if an app is embedded within the Discord client (currently unavailable publicly) */
+    EMBEDDED: 1 << 17,
+    /** Intent required for bots in 100 or more servers to receive message content */
+    GATEWAY_MESSAGE_CONTENT: 1 << 18,
+    /** Intent required for bots in under 100 servers to receive message content, found in Bot Settings */
+    GATEWAY_MESSAGE_CONTENT_LIMITED: 1 << 19,
+    /** Indicates if an app has registered global application commands */
+    APPLICATION_COMMAND_BADGE: 1 << 23,
+};
+export var AuditLogEvent;
+(function (AuditLogEvent) {
+    /** Server settings were updated */
+    AuditLogEvent[AuditLogEvent["GUILD_UPDATE"] = 1] = "GUILD_UPDATE";
+    /** Channel was created */
+    AuditLogEvent[AuditLogEvent["CHANNEL_CREATE"] = 10] = "CHANNEL_CREATE";
+    /** Channel settings were updated */
+    AuditLogEvent[AuditLogEvent["CHANNEL_UPDATE"] = 11] = "CHANNEL_UPDATE";
+    /** Channel was deleted */
+    AuditLogEvent[AuditLogEvent["CHANNEL_DELETE"] = 12] = "CHANNEL_DELETE";
+    /** Permission overwrite was added to a channel */
+    AuditLogEvent[AuditLogEvent["CHANNEL_OVERWRITE_CREATE"] = 13] = "CHANNEL_OVERWRITE_CREATE";
+    /** Permission overwrite was updated for a channel */
+    AuditLogEvent[AuditLogEvent["CHANNEL_OVERWRITE_UPDATE"] = 14] = "CHANNEL_OVERWRITE_UPDATE";
+    /** Permission overwrite was deleted from a channel */
+    AuditLogEvent[AuditLogEvent["CHANNEL_OVERWRITE_DELETE"] = 15] = "CHANNEL_OVERWRITE_DELETE";
+    /** Member was removed from server */
+    AuditLogEvent[AuditLogEvent["MEMBER_KICK"] = 20] = "MEMBER_KICK";
+    /** Members were pruned from server */
+    AuditLogEvent[AuditLogEvent["MEMBER_PRUNE"] = 21] = "MEMBER_PRUNE";
+    /** Member was banned from server */
+    AuditLogEvent[AuditLogEvent["MEMBER_BAN_ADD"] = 22] = "MEMBER_BAN_ADD";
+    /** Server ban was lifted for a member */
+    AuditLogEvent[AuditLogEvent["MEMBER_BAN_REMOVE"] = 23] = "MEMBER_BAN_REMOVE";
+    /** Member was updated in server */
+    AuditLogEvent[AuditLogEvent["MEMBER_UPDATE"] = 24] = "MEMBER_UPDATE";
+    /** Member was added or removed from a role */
+    AuditLogEvent[AuditLogEvent["MEMBER_ROLE_UPDATE"] = 25] = "MEMBER_ROLE_UPDATE";
+    /** Member was moved to a different voice channel */
+    AuditLogEvent[AuditLogEvent["MEMBER_MOVE"] = 26] = "MEMBER_MOVE";
+    /** Member was disconnected from a voice channel */
+    AuditLogEvent[AuditLogEvent["MEMBER_DISCONNECT"] = 27] = "MEMBER_DISCONNECT";
+    /** Bot user was added to server */
+    AuditLogEvent[AuditLogEvent["BOT_ADD"] = 28] = "BOT_ADD";
+    /** Role was created */
+    AuditLogEvent[AuditLogEvent["ROLE_CREATE"] = 30] = "ROLE_CREATE";
+    /** Role was edited */
+    AuditLogEvent[AuditLogEvent["ROLE_UPDATE"] = 31] = "ROLE_UPDATE";
+    /** Role was deleted */
+    AuditLogEvent[AuditLogEvent["ROLE_DELETE"] = 32] = "ROLE_DELETE";
+    /** Server invite was created */
+    AuditLogEvent[AuditLogEvent["INVITE_CREATE"] = 40] = "INVITE_CREATE";
+    /** Server invite was updated */
+    AuditLogEvent[AuditLogEvent["INVITE_UPDATE"] = 41] = "INVITE_UPDATE";
+    /** Server invite was deleted */
+    AuditLogEvent[AuditLogEvent["INVITE_DELETE"] = 42] = "INVITE_DELETE";
+    /** Webhook was created */
+    AuditLogEvent[AuditLogEvent["WEBHOOK_CREATE"] = 50] = "WEBHOOK_CREATE";
+    /** Webhook properties or channel were updated */
+    AuditLogEvent[AuditLogEvent["WEBHOOK_UPDATE"] = 51] = "WEBHOOK_UPDATE";
+    /** Webhook was deleted */
+    AuditLogEvent[AuditLogEvent["WEBHOOK_DELETE"] = 52] = "WEBHOOK_DELETE";
+    /** Emoji was created */
+    AuditLogEvent[AuditLogEvent["EMOJI_CREATE"] = 60] = "EMOJI_CREATE";
+    /** Emoji name was updated */
+    AuditLogEvent[AuditLogEvent["EMOJI_UPDATE"] = 61] = "EMOJI_UPDATE";
+    /** Emoji was deleted */
+    AuditLogEvent[AuditLogEvent["EMOJI_DELETE"] = 62] = "EMOJI_DELETE";
+    /** Single message was deleted */
+    AuditLogEvent[AuditLogEvent["MESSAGE_DELETE"] = 72] = "MESSAGE_DELETE";
+    /** Multiple messages were deleted */
+    AuditLogEvent[AuditLogEvent["MESSAGE_BULK_DELETE"] = 73] = "MESSAGE_BULK_DELETE";
+    /** Message was pinned to a channel */
+    AuditLogEvent[AuditLogEvent["MESSAGE_PIN"] = 74] = "MESSAGE_PIN";
+    /** Message was unpinned from a channel */
+    AuditLogEvent[AuditLogEvent["MESSAGE_UNPIN"] = 75] = "MESSAGE_UNPIN";
+    /** App was added to server */
+    AuditLogEvent[AuditLogEvent["INTEGRATION_CREATE"] = 80] = "INTEGRATION_CREATE";
+    /** App was updated (as an example, its scopes were updated) */
+    AuditLogEvent[AuditLogEvent["INTEGRATION_UPDATE"] = 81] = "INTEGRATION_UPDATE";
+    /** App was removed from server */
+    AuditLogEvent[AuditLogEvent["INTEGRATION_DELETE"] = 82] = "INTEGRATION_DELETE";
+    /** Stage instance was created (stage channel becomes live) */
+    AuditLogEvent[AuditLogEvent["STAGE_INSTANCE_CREATE"] = 83] = "STAGE_INSTANCE_CREATE";
+    /** Stage instance details were updated */
+    AuditLogEvent[AuditLogEvent["STAGE_INSTANCE_UPDATE"] = 84] = "STAGE_INSTANCE_UPDATE";
+    /** Stage instance was deleted (stage channel no longer live) */
+    AuditLogEvent[AuditLogEvent["STAGE_INSTANCE_DELETE"] = 85] = "STAGE_INSTANCE_DELETE";
+    /** Sticker was created */
+    AuditLogEvent[AuditLogEvent["STICKER_CREATE"] = 90] = "STICKER_CREATE";
+    /** Sticker details were updated */
+    AuditLogEvent[AuditLogEvent["STICKER_UPDATE"] = 91] = "STICKER_UPDATE";
+    /** Sticker was deleted */
+    AuditLogEvent[AuditLogEvent["STICKER_DELETE"] = 92] = "STICKER_DELETE";
+    /** Event was created */
+    AuditLogEvent[AuditLogEvent["GUILD_SCHEDULED_EVENT_CREATE"] = 100] = "GUILD_SCHEDULED_EVENT_CREATE";
+    /** Event was updated */
+    AuditLogEvent[AuditLogEvent["GUILD_SCHEDULED_EVENT_UPDATE"] = 101] = "GUILD_SCHEDULED_EVENT_UPDATE";
+    /** Event was cancelled */
+    AuditLogEvent[AuditLogEvent["GUILD_SCHEDULED_EVENT_DELETE"] = 102] = "GUILD_SCHEDULED_EVENT_DELETE";
+    /** Thread was created in a channel */
+    AuditLogEvent[AuditLogEvent["THREAD_CREATE"] = 110] = "THREAD_CREATE";
+    /** Thread was updated */
+    AuditLogEvent[AuditLogEvent["THREAD_UPDATE"] = 111] = "THREAD_UPDATE";
+    /** Thread was deleted */
+    AuditLogEvent[AuditLogEvent["THREAD_DELETE"] = 112] = "THREAD_DELETE";
+    /** Permissions were updated for a command */
+    AuditLogEvent[AuditLogEvent["APPLICATION_COMMAND_PERMISSION_UPDATE"] = 121] = "APPLICATION_COMMAND_PERMISSION_UPDATE";
+    /** Auto Moderation rule was created */
+    AuditLogEvent[AuditLogEvent["AUTO_MODERATION_RULE_CREATE"] = 140] = "AUTO_MODERATION_RULE_CREATE";
+    /** Auto Moderation rule was updated */
+    AuditLogEvent[AuditLogEvent["AUTO_MODERATION_RULE_UPDATE"] = 141] = "AUTO_MODERATION_RULE_UPDATE";
+    /** Auto Moderation rule was deleted */
+    AuditLogEvent[AuditLogEvent["AUTO_MODERATION_RULE_DELETE"] = 142] = "AUTO_MODERATION_RULE_DELETE";
+    /** Message was blocked by Auto Moderation */
+    AuditLogEvent[AuditLogEvent["AUTO_MODERATION_BLOCK_MESSAGE"] = 143] = "AUTO_MODERATION_BLOCK_MESSAGE";
+    /** Message was flagged by Auto Moderation */
+    AuditLogEvent[AuditLogEvent["AUTO_MODERATION_FLAG_TO_CHANNEL"] = 144] = "AUTO_MODERATION_FLAG_TO_CHANNEL";
+    /** Member was timed out by Auto Moderation */
+    AuditLogEvent[AuditLogEvent["AUTO_MODERATION_USER_COMMUNICATION_DISABLED"] = 145] = "AUTO_MODERATION_USER_COMMUNICATION_DISABLED";
+})(AuditLogEvent || (AuditLogEvent = {}));
+export var ButtonStyle;
+(function (ButtonStyle) {
+    ButtonStyle[ButtonStyle["PRIMARY"] = 1] = "PRIMARY";
+    ButtonStyle[ButtonStyle["SECONDARY"] = 2] = "SECONDARY";
+    ButtonStyle[ButtonStyle["SUCCESS"] = 3] = "SUCCESS";
+    ButtonStyle[ButtonStyle["DANGER"] = 4] = "DANGER";
+    ButtonStyle[ButtonStyle["LINK"] = 5] = "LINK";
+})(ButtonStyle || (ButtonStyle = {}));
+export const ChannelFlag = {
+    /** this thread is pinned to the top of its parent GUILD_FORUM channel */
+    PINNED: 1 << 1,
+    /** whether a tag is required to be specified when creating a thread in a GUILD_FORUM channel. Tags are specified in the applied_tags field. */
+    REQUIRE_TAG: 1 << 4,
+};
+export var ChannelType;
+(function (ChannelType) {
+    /** a text channel within a server */
+    ChannelType[ChannelType["GUILD_TEXT"] = 0] = "GUILD_TEXT";
+    /** a direct message between users */
+    ChannelType[ChannelType["DM"] = 1] = "DM";
+    /** a voice channel within a server */
+    ChannelType[ChannelType["GUILD_VOICE"] = 2] = "GUILD_VOICE";
+    /** a direct message between multiple users */
+    ChannelType[ChannelType["GROUP_DM"] = 3] = "GROUP_DM";
+    /** an organizational category that contains up to 50 channels */
+    ChannelType[ChannelType["GUILD_CATEGORY"] = 4] = "GUILD_CATEGORY";
+    /** a channel that users can follow and crosspost into their own server (formerly news channels) */
+    ChannelType[ChannelType["GUILD_ANNOUNCEMENT"] = 5] = "GUILD_ANNOUNCEMENT";
+    /** a temporary sub-channel within a GUILD_ANNOUNCEMENT channel */
+    ChannelType[ChannelType["ANNOUNCEMENT_THREAD"] = 10] = "ANNOUNCEMENT_THREAD";
+    /** a temporary sub-channel within a GUILD_TEXT or GUILD_FORUM channel */
+    ChannelType[ChannelType["PUBLIC_THREAD"] = 11] = "PUBLIC_THREAD";
+    /** a temporary sub-channel within a GUILD_TEXT channel that is only viewable by those invited and those with the MANAGE_THREADS permission */
+    ChannelType[ChannelType["PRIVATE_THREAD"] = 12] = "PRIVATE_THREAD";
+    /** a voice channel for hosting events with an audience */
+    ChannelType[ChannelType["GUILD_STAGE_VOICE"] = 13] = "GUILD_STAGE_VOICE";
+    /** the channel in a hub containing the listed servers */
+    ChannelType[ChannelType["GUILD_DIRECTORY"] = 14] = "GUILD_DIRECTORY";
+    /** Channel that can only contain threads */
+    ChannelType[ChannelType["GUILD_FORUM"] = 15] = "GUILD_FORUM";
+})(ChannelType || (ChannelType = {}));
+export var ComponentType;
+(function (ComponentType) {
+    /** Container for other components */
+    ComponentType[ComponentType["ACTION_ROW"] = 1] = "ACTION_ROW";
+    /** Button object */
+    ComponentType[ComponentType["BUTTON"] = 2] = "BUTTON";
+    /** Select menu for picking from defined text options */
+    ComponentType[ComponentType["STRING_SELECT"] = 3] = "STRING_SELECT";
+    /** Text input object */
+    ComponentType[ComponentType["TEXT_INPUT"] = 4] = "TEXT_INPUT";
+    /** Select menu for users */
+    ComponentType[ComponentType["USER_SELECT"] = 5] = "USER_SELECT";
+    /** Select menu for roles */
+    ComponentType[ComponentType["ROLE_SELECT"] = 6] = "ROLE_SELECT";
+    /** Select menu for mentionables (users and roles) */
+    ComponentType[ComponentType["MENTIONABLE_SELECT"] = 7] = "MENTIONABLE_SELECT";
+    /** Select menu for channels */
+    ComponentType[ComponentType["CHANNEL_SELECT"] = 8] = "CHANNEL_SELECT";
+})(ComponentType || (ComponentType = {}));
+export function createRoutes(fetch) {
+    return {
+        addGuildMember: (guildId, userId, params, options) => fetch({
+            method: "PUT",
+            url: `/guilds/${guildId}/members/${userId}`,
+            params,
+            options,
+        }),
+        addGuildMemberRole: (guildId, userId, roleId, options) => fetch({
+            method: "PUT",
+            url: `/guilds/${guildId}/members/${userId}/roles/${roleId}`,
+            options,
+        }),
+        addThreadMember: (channelId, userId, options) => fetch({
+            method: "PUT",
+            url: `/channels/${channelId}/thread-members/${userId}`,
+            options,
+        }),
+        batchEditApplicationCommandPermissions: (applicationId, guildId, options) => fetch({
+            method: "PUT",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands/permissions`,
+            options,
+        }),
+        beginGuildPrune: (guildId, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/${guildId}/prune`,
+            params,
+            options,
+        }),
+        bulkDeleteMessages: (channelId, params, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/messages/bulk-delete`,
+            params,
+            options,
+        }),
+        bulkOverwriteGlobalApplicationCommands: (applicationId, options) => fetch({
+            method: "PUT",
+            url: `/applications/${applicationId}/commands`,
+            options,
+        }),
+        bulkOverwriteGuildApplicationCommands: (applicationId, guildId, params, options) => fetch({
+            method: "PUT",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands`,
+            params,
+            options,
+        }),
+        createAutoModerationRule: (guildId, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/${guildId}/auto-moderation/rules`,
+            params,
+            options,
+        }),
+        createChannelInvite: (channelId, params, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/invites`,
+            params,
+            options,
+        }),
+        createDm: (params, options) => fetch({
+            method: "POST",
+            url: `/users/@me/channels`,
+            params,
+            options,
+        }),
+        createFollowupMessage: (applicationId, interactionToken, options) => fetch({
+            method: "POST",
+            url: `/webhooks/${applicationId}/${interactionToken}`,
+            options,
+        }),
+        createGlobalApplicationCommand: (applicationId, params, options) => fetch({
+            method: "POST",
+            url: `/applications/${applicationId}/commands`,
+            params,
+            options,
+        }),
+        createGroupDm: (params, options) => fetch({
+            method: "POST",
+            url: `/users/@me/channels`,
+            params,
+            options,
+        }),
+        createGuild: (params, options) => fetch({
+            method: "POST",
+            url: `/guilds`,
+            params,
+            options,
+        }),
+        createGuildApplicationCommand: (applicationId, guildId, params, options) => fetch({
+            method: "POST",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands`,
+            params,
+            options,
+        }),
+        createGuildBan: (guildId, userId, params, options) => fetch({
+            method: "PUT",
+            url: `/guilds/${guildId}/bans/${userId}`,
+            params,
+            options,
+        }),
+        createGuildChannel: (guildId, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/${guildId}/channels`,
+            params,
+            options,
+        }),
+        createGuildEmoji: (guildId, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/${guildId}/emojis`,
+            params,
+            options,
+        }),
+        createGuildFromGuildTemplate: (templateCode, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/templates/${templateCode}`,
+            params,
+            options,
+        }),
+        createGuildRole: (guildId, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/${guildId}/roles`,
+            params,
+            options,
+        }),
+        createGuildScheduledEvent: (guildId, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/${guildId}/scheduled-events`,
+            params,
+            options,
+        }),
+        createGuildSticker: (guildId, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/${guildId}/stickers`,
+            params,
+            options,
+        }),
+        createGuildTemplate: (guildId, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/${guildId}/templates`,
+            params,
+            options,
+        }),
+        createInteractionResponse: (interactionId, interactionToken, params, options) => fetch({
+            method: "POST",
+            url: `/interactions/${interactionId}/${interactionToken}/callback`,
+            params,
+            options,
+        }),
+        createMessage: (channelId, params, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/messages`,
+            params,
+            options,
+        }),
+        createReaction: (channelId, messageId, emoji, options) => fetch({
+            method: "PUT",
+            url: `/channels/${channelId}/messages/${messageId}/reactions/${emoji}/@me`,
+            options,
+        }),
+        createStageInstance: (params, options) => fetch({
+            method: "POST",
+            url: `/stage-instances`,
+            params,
+            options,
+        }),
+        createWebhook: (channelId, params, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/webhooks`,
+            params,
+            options,
+        }),
+        crosspostMessage: (channelId, messageId, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/messages/${messageId}/crosspost`,
+            options,
+        }),
+        deleteAllReactions: (channelId, messageId, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/messages/${messageId}/reactions`,
+            options,
+        }),
+        deleteAllReactionsForEmoji: (channelId, messageId, emoji, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/messages/${messageId}/reactions/${emoji}`,
+            options,
+        }),
+        deleteAutoModerationRule: (guildId, autoModerationRuleId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/auto-moderation/rules/${autoModerationRuleId}`,
+            options,
+        }),
+        deleteChannelPermission: (channelId, overwriteId, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/permissions/${overwriteId}`,
+            options,
+        }),
+        deletecloseChannel: (channelId, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}`,
+            options,
+        }),
+        deleteFollowupMessage: (applicationId, interactionToken, messageId, options) => fetch({
+            method: "DELETE",
+            url: `/webhooks/${applicationId}/${interactionToken}/messages/${messageId}`,
+            options,
+        }),
+        deleteGlobalApplicationCommand: (applicationId, commandId, options) => fetch({
+            method: "DELETE",
+            url: `/applications/${applicationId}/commands/${commandId}`,
+            options,
+        }),
+        deleteGuild: (guildId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}`,
+            options,
+        }),
+        deleteGuildApplicationCommand: (applicationId, guildId, commandId, options) => fetch({
+            method: "DELETE",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}`,
+            options,
+        }),
+        deleteGuildEmoji: (guildId, emojiId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/emojis/${emojiId}`,
+            options,
+        }),
+        deleteGuildIntegration: (guildId, integrationId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/integrations/${integrationId}`,
+            options,
+        }),
+        deleteGuildRole: (guildId, roleId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/roles/${roleId}`,
+            options,
+        }),
+        deleteGuildScheduledEvent: (guildId, guildScheduledEventId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/scheduled-events/${guildScheduledEventId}`,
+            options,
+        }),
+        deleteGuildSticker: (guildId, stickerId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/stickers/${stickerId}`,
+            options,
+        }),
+        deleteGuildTemplate: (guildId, templateCode, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/templates/${templateCode}`,
+            options,
+        }),
+        deleteInvite: (inviteCode, options) => fetch({
+            method: "DELETE",
+            url: `/invites/${inviteCode}`,
+            options,
+        }),
+        deleteMessage: (channelId, messageId, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/messages/${messageId}`,
+            options,
+        }),
+        deleteOriginalInteractionResponse: (applicationId, interactionToken, options) => fetch({
+            method: "DELETE",
+            url: `/webhooks/${applicationId}/${interactionToken}/messages/@original`,
+            options,
+        }),
+        deleteOwnReaction: (channelId, messageId, emoji, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/messages/${messageId}/reactions/${emoji}/@me`,
+            options,
+        }),
+        deleteStageInstance: (channelId, options) => fetch({
+            method: "DELETE",
+            url: `/stage-instances/${channelId}`,
+            options,
+        }),
+        deleteUserReaction: (channelId, messageId, emoji, userId, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/messages/${messageId}/reactions/${emoji}/${userId}`,
+            options,
+        }),
+        deleteWebhook: (webhookId, options) => fetch({
+            method: "DELETE",
+            url: `/webhooks/${webhookId}`,
+            options,
+        }),
+        deleteWebhookMessage: (webhookId, webhookToken, messageId, params, options) => fetch({
+            method: "DELETE",
+            url: `/webhooks/${webhookId}/${webhookToken}/messages/${messageId}`,
+            params,
+            options,
+        }),
+        deleteWebhookWithToken: (webhookId, webhookToken, options) => fetch({
+            method: "DELETE",
+            url: `/webhooks/${webhookId}/${webhookToken}`,
+            options,
+        }),
+        editApplicationCommandPermissions: (applicationId, guildId, commandId, params, options) => fetch({
+            method: "PUT",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}/permissions`,
+            params,
+            options,
+        }),
+        editChannelPermissions: (channelId, overwriteId, params, options) => fetch({
+            method: "PUT",
+            url: `/channels/${channelId}/permissions/${overwriteId}`,
+            params,
+            options,
+        }),
+        editFollowupMessage: (applicationId, interactionToken, messageId, options) => fetch({
+            method: "PATCH",
+            url: `/webhooks/${applicationId}/${interactionToken}/messages/${messageId}`,
+            options,
+        }),
+        editGlobalApplicationCommand: (applicationId, commandId, params, options) => fetch({
+            method: "PATCH",
+            url: `/applications/${applicationId}/commands/${commandId}`,
+            params,
+            options,
+        }),
+        editGuildApplicationCommand: (applicationId, guildId, commandId, params, options) => fetch({
+            method: "PATCH",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}`,
+            params,
+            options,
+        }),
+        editMessage: (channelId, messageId, params, options) => fetch({
+            method: "PATCH",
+            url: `/channels/${channelId}/messages/${messageId}`,
+            params,
+            options,
+        }),
+        editOriginalInteractionResponse: (applicationId, interactionToken, options) => fetch({
+            method: "PATCH",
+            url: `/webhooks/${applicationId}/${interactionToken}/messages/@original`,
+            options,
+        }),
+        editWebhookMessage: (webhookId, webhookToken, messageId, params, options) => fetch({
+            method: "PATCH",
+            url: `/webhooks/${webhookId}/${webhookToken}/messages/${messageId}`,
+            params,
+            options,
+        }),
+        executeGitHubCompatibleWebhook: (webhookId, webhookToken, options) => fetch({
+            method: "POST",
+            url: `/webhooks/${webhookId}/${webhookToken}/github`,
+            options,
+        }),
+        executeSlackCompatibleWebhook: (webhookId, webhookToken, options) => fetch({
+            method: "POST",
+            url: `/webhooks/${webhookId}/${webhookToken}/slack`,
+            options,
+        }),
+        executeWebhook: (webhookId, webhookToken, params, options) => fetch({
+            method: "POST",
+            url: `/webhooks/${webhookId}/${webhookToken}`,
+            params,
+            options,
+        }),
+        followAnnouncementChannel: (channelId, params, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/followers`,
+            params,
+            options,
+        }),
+        getApplicationCommandPermissions: (applicationId, guildId, commandId, options) => fetch({
+            method: "GET",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}/permissions`,
+            options,
+        }),
+        getAutoModerationRule: (guildId, autoModerationRuleId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/auto-moderation/rules/${autoModerationRuleId}`,
+            options,
+        }),
+        getChannel: (channelId, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}`,
+            options,
+        }),
+        getChannelInvites: (channelId, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/invites`,
+            options,
+        }),
+        getChannelMessage: (channelId, messageId, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/messages/${messageId}`,
+            options,
+        }),
+        getChannelMessages: (channelId, params, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/messages`,
+            params,
+            options,
+        }),
+        getChannelWebhooks: (channelId, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/webhooks`,
+            options,
+        }),
+        getCurrentAuthorizationInformation: (options) => fetch({
+            method: "GET",
+            url: `/oauth2/@me`,
+            options,
+        }),
+        getCurrentBotApplicationInformation: (options) => fetch({
+            method: "GET",
+            url: `/oauth2/applications/@me`,
+            options,
+        }),
+        getCurrentUser: (options) => fetch({
+            method: "GET",
+            url: `/users/@me`,
+            options,
+        }),
+        getCurrentUserGuildMember: (guildId, options) => fetch({
+            method: "GET",
+            url: `/users/@me/guilds/${guildId}/member`,
+            options,
+        }),
+        getCurrentUserGuilds: (params, options) => fetch({
+            method: "GET",
+            url: `/users/@me/guilds`,
+            params,
+            options,
+        }),
+        getFollowupMessage: (applicationId, interactionToken, messageId, options) => fetch({
+            method: "GET",
+            url: `/webhooks/${applicationId}/${interactionToken}/messages/${messageId}`,
+            options,
+        }),
+        getGateway: (options) => fetch({
+            method: "GET",
+            url: `/gateway`,
+            options,
+        }),
+        getGatewayBot: (options) => fetch({
+            method: "GET",
+            url: `/gateway/bot`,
+            options,
+        }),
+        getGlobalApplicationCommand: (applicationId, commandId, options) => fetch({
+            method: "GET",
+            url: `/applications/${applicationId}/commands/${commandId}`,
+            options,
+        }),
+        getGlobalApplicationCommands: (applicationId, params, options) => fetch({
+            method: "GET",
+            url: `/applications/${applicationId}/commands`,
+            params,
+            options,
+        }),
+        getGuild: (guildId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}`,
+            params,
+            options,
+        }),
+        getGuildApplicationCommand: (applicationId, guildId, commandId, options) => fetch({
+            method: "GET",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}`,
+            options,
+        }),
+        getGuildApplicationCommandPermissions: (applicationId, guildId, options) => fetch({
+            method: "GET",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands/permissions`,
+            options,
+        }),
+        getGuildApplicationCommands: (applicationId, guildId, params, options) => fetch({
+            method: "GET",
+            url: `/applications/${applicationId}/guilds/${guildId}/commands`,
+            params,
+            options,
+        }),
+        getGuildAuditLog: (guildId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/audit-logs`,
+            params,
+            options,
+        }),
+        getGuildBan: (guildId, userId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/bans/${userId}`,
+            options,
+        }),
+        getGuildBans: (guildId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/bans`,
+            params,
+            options,
+        }),
+        getGuildChannels: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/channels`,
+            options,
+        }),
+        getGuildEmoji: (guildId, emojiId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/emojis/${emojiId}`,
+            options,
+        }),
+        getGuildIntegrations: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/integrations`,
+            options,
+        }),
+        getGuildInvites: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/invites`,
+            options,
+        }),
+        getGuildMember: (guildId, userId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/members/${userId}`,
+            options,
+        }),
+        getGuildPreview: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/preview`,
+            options,
+        }),
+        getGuildPruneCount: (guildId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/prune`,
+            params,
+            options,
+        }),
+        getGuildRoles: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/roles`,
+            options,
+        }),
+        getGuildScheduledEvent: (guildId, guildScheduledEventId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/scheduled-events/${guildScheduledEventId}`,
+            params,
+            options,
+        }),
+        getGuildScheduledEventUsers: (guildId, guildScheduledEventId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/scheduled-events/${guildScheduledEventId}/users`,
+            params,
+            options,
+        }),
+        getGuildSticker: (guildId, stickerId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/stickers/${stickerId}`,
+            options,
+        }),
+        getGuildTemplate: (templateCode, options) => fetch({
+            method: "GET",
+            url: `/guilds/templates/${templateCode}`,
+            options,
+        }),
+        getGuildTemplates: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/templates`,
+            options,
+        }),
+        getGuildVanityUrl: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/vanity-url`,
+            options,
+        }),
+        getGuildVoiceRegions: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/regions`,
+            options,
+        }),
+        getGuildWebhooks: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/webhooks`,
+            options,
+        }),
+        getGuildWelcomeScreen: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/welcome-screen`,
+            options,
+        }),
+        getGuildWidget: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/widget.json`,
+            options,
+        }),
+        getGuildWidgetImage: (guildId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/widget.png`,
+            params,
+            options,
+        }),
+        getGuildWidgetSettings: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/widget`,
+            options,
+        }),
+        getInvite: (inviteCode, params, options) => fetch({
+            method: "GET",
+            url: `/invites/${inviteCode}`,
+            params,
+            options,
+        }),
+        getOriginalInteractionResponse: (applicationId, interactionToken, options) => fetch({
+            method: "GET",
+            url: `/webhooks/${applicationId}/${interactionToken}/messages/@original`,
+            options,
+        }),
+        getPinnedMessages: (channelId, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/pins`,
+            options,
+        }),
+        getReactions: (channelId, messageId, emoji, params, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/messages/${messageId}/reactions/${emoji}`,
+            params,
+            options,
+        }),
+        getStageInstance: (channelId, options) => fetch({
+            method: "GET",
+            url: `/stage-instances/${channelId}`,
+            options,
+        }),
+        getSticker: (stickerId, options) => fetch({
+            method: "GET",
+            url: `/stickers/${stickerId}`,
+            options,
+        }),
+        getThreadMember: (channelId, userId, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/thread-members/${userId}`,
+            options,
+        }),
+        getUser: (userId, options) => fetch({
+            method: "GET",
+            url: `/users/${userId}`,
+            options,
+        }),
+        getUserConnections: (options) => fetch({
+            method: "GET",
+            url: `/users/@me/connections`,
+            options,
+        }),
+        getWebhook: (webhookId, options) => fetch({
+            method: "GET",
+            url: `/webhooks/${webhookId}`,
+            options,
+        }),
+        getWebhookMessage: (webhookId, webhookToken, messageId, params, options) => fetch({
+            method: "GET",
+            url: `/webhooks/${webhookId}/${webhookToken}/messages/${messageId}`,
+            params,
+            options,
+        }),
+        getWebhookWithToken: (webhookId, webhookToken, options) => fetch({
+            method: "GET",
+            url: `/webhooks/${webhookId}/${webhookToken}`,
+            options,
+        }),
+        groupDmAddRecipient: (channelId, userId, params, options) => fetch({
+            method: "PUT",
+            url: `/channels/${channelId}/recipients/${userId}`,
+            params,
+            options,
+        }),
+        groupDmRemoveRecipient: (channelId, userId, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/recipients/${userId}`,
+            options,
+        }),
+        joinThread: (channelId, options) => fetch({
+            method: "PUT",
+            url: `/channels/${channelId}/thread-members/@me`,
+            options,
+        }),
+        leaveGuild: (guildId, options) => fetch({
+            method: "DELETE",
+            url: `/users/@me/guilds/${guildId}`,
+            options,
+        }),
+        leaveThread: (channelId, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/thread-members/@me`,
+            options,
+        }),
+        listActiveGuildThreads: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/threads/active`,
+            options,
+        }),
+        listAutoModerationRulesForGuild: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/auto-moderation/rules`,
+            options,
+        }),
+        listGuildEmojis: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/emojis`,
+            options,
+        }),
+        listGuildMembers: (guildId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/members`,
+            params,
+            options,
+        }),
+        listGuildStickers: (guildId, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/stickers`,
+            options,
+        }),
+        listJoinedPrivateArchivedThreads: (channelId, params, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/users/@me/threads/archived/private`,
+            params,
+            options,
+        }),
+        listNitroStickerPacks: (options) => fetch({
+            method: "GET",
+            url: `/sticker-packs`,
+            options,
+        }),
+        listPrivateArchivedThreads: (channelId, params, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/threads/archived/private`,
+            params,
+            options,
+        }),
+        listPublicArchivedThreads: (channelId, params, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/threads/archived/public`,
+            params,
+            options,
+        }),
+        listScheduledEventsForGuild: (guildId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/scheduled-events`,
+            params,
+            options,
+        }),
+        listThreadMembers: (channelId, options) => fetch({
+            method: "GET",
+            url: `/channels/${channelId}/thread-members`,
+            options,
+        }),
+        listVoiceRegions: (options) => fetch({
+            method: "GET",
+            url: `/voice/regions`,
+            options,
+        }),
+        modifyAutoModerationRule: (guildId, autoModerationRuleId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/auto-moderation/rules/${autoModerationRuleId}`,
+            params,
+            options,
+        }),
+        modifyChannel: (channelId, params, options) => fetch({
+            method: "PATCH",
+            url: `/channels/${channelId}`,
+            params,
+            options,
+        }),
+        modifyCurrentMember: (guildId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/members/@me`,
+            params,
+            options,
+        }),
+        modifyCurrentUser: (params, options) => fetch({
+            method: "PATCH",
+            url: `/users/@me`,
+            params,
+            options,
+        }),
+        modifyCurrentUserNick: (guildId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/members/@me/nick`,
+            params,
+            options,
+        }),
+        modifyCurrentUserVoiceState: (guildId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/voice-states/@me`,
+            params,
+            options,
+        }),
+        modifyGuild: (guildId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}`,
+            params,
+            options,
+        }),
+        modifyGuildChannelPositions: (guildId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/channels`,
+            params,
+            options,
+        }),
+        modifyGuildEmoji: (guildId, emojiId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/emojis/${emojiId}`,
+            params,
+            options,
+        }),
+        modifyGuildMember: (guildId, userId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/members/${userId}`,
+            params,
+            options,
+        }),
+        modifyGuildMfaLevel: (guildId, params, options) => fetch({
+            method: "POST",
+            url: `/guilds/${guildId}/mfa`,
+            params,
+            options,
+        }),
+        modifyGuildRole: (guildId, roleId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/roles/${roleId}`,
+            params,
+            options,
+        }),
+        modifyGuildRolePositions: (guildId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/roles`,
+            params,
+            options,
+        }),
+        modifyGuildScheduledEvent: (guildId, guildScheduledEventId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/scheduled-events/${guildScheduledEventId}`,
+            params,
+            options,
+        }),
+        modifyGuildSticker: (guildId, stickerId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/stickers/${stickerId}`,
+            params,
+            options,
+        }),
+        modifyGuildTemplate: (guildId, templateCode, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/templates/${templateCode}`,
+            params,
+            options,
+        }),
+        modifyGuildWelcomeScreen: (guildId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/welcome-screen`,
+            params,
+            options,
+        }),
+        modifyGuildWidget: (guildId, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/widget`,
+            options,
+        }),
+        modifyStageInstance: (channelId, params, options) => fetch({
+            method: "PATCH",
+            url: `/stage-instances/${channelId}`,
+            params,
+            options,
+        }),
+        modifyUserVoiceState: (guildId, userId, params, options) => fetch({
+            method: "PATCH",
+            url: `/guilds/${guildId}/voice-states/${userId}`,
+            params,
+            options,
+        }),
+        modifyWebhook: (webhookId, params, options) => fetch({
+            method: "PATCH",
+            url: `/webhooks/${webhookId}`,
+            params,
+            options,
+        }),
+        modifyWebhookWithToken: (webhookId, webhookToken, options) => fetch({
+            method: "PATCH",
+            url: `/webhooks/${webhookId}/${webhookToken}`,
+            options,
+        }),
+        pinMessage: (channelId, messageId, options) => fetch({
+            method: "PUT",
+            url: `/channels/${channelId}/pins/${messageId}`,
+            options,
+        }),
+        removeGuildBan: (guildId, userId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/bans/${userId}`,
+            options,
+        }),
+        removeGuildMember: (guildId, userId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/members/${userId}`,
+            options,
+        }),
+        removeGuildMemberRole: (guildId, userId, roleId, options) => fetch({
+            method: "DELETE",
+            url: `/guilds/${guildId}/members/${userId}/roles/${roleId}`,
+            options,
+        }),
+        removeThreadMember: (channelId, userId, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/thread-members/${userId}`,
+            options,
+        }),
+        searchGuildMembers: (guildId, params, options) => fetch({
+            method: "GET",
+            url: `/guilds/${guildId}/members/search`,
+            params,
+            options,
+        }),
+        startThreadFromMessage: (channelId, messageId, params, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/messages/${messageId}/threads`,
+            params,
+            options,
+        }),
+        startThreadInForumChannel: (channelId, params, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/threads`,
+            params,
+            options,
+        }),
+        startThreadWithoutMessage: (channelId, params, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/threads`,
+            params,
+            options,
+        }),
+        syncGuildTemplate: (guildId, templateCode, options) => fetch({
+            method: "PUT",
+            url: `/guilds/${guildId}/templates/${templateCode}`,
+            options,
+        }),
+        triggerTypingIndicator: (channelId, options) => fetch({
+            method: "POST",
+            url: `/channels/${channelId}/typing`,
+            options,
+        }),
+        unpinMessage: (channelId, messageId, options) => fetch({
+            method: "DELETE",
+            url: `/channels/${channelId}/pins/${messageId}`,
+            options,
+        }),
+    };
+}
+export var DefaultMessageNotificationLevel;
+(function (DefaultMessageNotificationLevel) {
+    /** members will receive notifications for all messages by default */
+    DefaultMessageNotificationLevel[DefaultMessageNotificationLevel["ALL_MESSAGES"] = 0] = "ALL_MESSAGES";
+    /** members will receive notifications only for messages that @mention them by default */
+    DefaultMessageNotificationLevel[DefaultMessageNotificationLevel["ONLY_MENTIONS"] = 1] = "ONLY_MENTIONS";
+})(DefaultMessageNotificationLevel || (DefaultMessageNotificationLevel = {}));
+export var EmbedType;
+(function (EmbedType) {
+    /** generic embed rendered from embed attributes */
+    EmbedType["RICH"] = "rich";
+    /** image embed */
+    EmbedType["IMAGE"] = "image";
+    /** video embed */
+    EmbedType["VIDEO"] = "video";
+    /** animated gif image embed rendered as a video embed */
+    EmbedType["GIFV"] = "gifv";
+    /** article embed */
+    EmbedType["ARTICLE"] = "article";
+    /** link embed */
+    EmbedType["LINK"] = "link";
+})(EmbedType || (EmbedType = {}));
+export var EventType;
+(function (EventType) {
+    /** when a member sends or edits a message in the guild */
+    EventType[EventType["MESSAGE_SEND"] = 1] = "MESSAGE_SEND";
+})(EventType || (EventType = {}));
+export var ExplicitContentFilterLevel;
+(function (ExplicitContentFilterLevel) {
+    /** media content will not be scanned */
+    ExplicitContentFilterLevel[ExplicitContentFilterLevel["DISABLED"] = 0] = "DISABLED";
+    /** media content sent by members without roles will be scanned */
+    ExplicitContentFilterLevel[ExplicitContentFilterLevel["MEMBERS_WITHOUT_ROLES"] = 1] = "MEMBERS_WITHOUT_ROLES";
+    /** media content sent by all members will be scanned */
+    ExplicitContentFilterLevel[ExplicitContentFilterLevel["ALL_MEMBERS"] = 2] = "ALL_MEMBERS";
+})(ExplicitContentFilterLevel || (ExplicitContentFilterLevel = {}));
+export const GatewayIntents = {
+    GUILDS: 1 << 0,
+    GUILD_MEMBERS: 1 << 1,
+    GUILD_BANS: 1 << 2,
+    GUILD_EMOJIS_AND_STICKERS: 1 << 3,
+    GUILD_INTEGRATIONS: 1 << 4,
+    GUILD_WEBHOOKS: 1 << 5,
+    GUILD_INVITES: 1 << 6,
+    GUILD_VOICE_STATES: 1 << 7,
+    GUILD_PRESENCES: 1 << 8,
+    GUILD_MESSAGES: 1 << 9,
+    GUILD_MESSAGE_REACTIONS: 1 << 10,
+    GUILD_MESSAGE_TYPING: 1 << 11,
+    DIRECT_MESSAGES: 1 << 12,
+    DIRECT_MESSAGE_REACTIONS: 1 << 13,
+    DIRECT_MESSAGE_TYPING: 1 << 14,
+    MESSAGE_CONTENT: 1 << 15,
+    GUILD_SCHEDULED_EVENTS: 1 << 16,
+    AUTO_MODERATION_CONFIGURATION: 1 << 20,
+    AUTO_MODERATION_EXECUTION: 1 << 21,
+};
+export var GatewayOpcode;
+(function (GatewayOpcode) {
+    /** An event was dispatched. */
+    GatewayOpcode[GatewayOpcode["DISPATCH"] = 0] = "DISPATCH";
+    /** Fired periodically by the client to keep the connection alive. */
+    GatewayOpcode[GatewayOpcode["HEARTBEAT"] = 1] = "HEARTBEAT";
+    /** Starts a new session during the initial handshake. */
+    GatewayOpcode[GatewayOpcode["IDENTIFY"] = 2] = "IDENTIFY";
+    /** Update the client's presence. */
+    GatewayOpcode[GatewayOpcode["PRESENCE_UPDATE"] = 3] = "PRESENCE_UPDATE";
+    /** Used to join/leave or move between voice channels. */
+    GatewayOpcode[GatewayOpcode["VOICE_STATE_UPDATE"] = 4] = "VOICE_STATE_UPDATE";
+    /** Resume a previous session that was disconnected. */
+    GatewayOpcode[GatewayOpcode["RESUME"] = 6] = "RESUME";
+    /** You should attempt to reconnect and resume immediately. */
+    GatewayOpcode[GatewayOpcode["RECONNECT"] = 7] = "RECONNECT";
+    /** Request information about offline guild members in a large guild. */
+    GatewayOpcode[GatewayOpcode["REQUEST_GUILD_MEMBERS"] = 8] = "REQUEST_GUILD_MEMBERS";
+    /** The session has been invalidated. You should reconnect and identify/resume accordingly. */
+    GatewayOpcode[GatewayOpcode["INVALID_SESSION"] = 9] = "INVALID_SESSION";
+    /** Sent immediately after connecting, contains the heartbeat_interval to use. */
+    GatewayOpcode[GatewayOpcode["HELLO"] = 10] = "HELLO";
+    /** Sent in response to receiving a heartbeat to acknowledge that it has been received. */
+    GatewayOpcode[GatewayOpcode["HEARTBEAT_ACK"] = 11] = "HEARTBEAT_ACK";
+})(GatewayOpcode || (GatewayOpcode = {}));
+export var GuildFeature;
+(function (GuildFeature) {
+    /** guild has access to set an animated guild banner image */
+    GuildFeature["ANIMATED_BANNER"] = "ANIMATED_BANNER";
+    /** guild has access to set an animated guild icon */
+    GuildFeature["ANIMATED_ICON"] = "ANIMATED_ICON";
+    /** guild is using the old permissions configuration behavior */
+    GuildFeature["APPLICATION_COMMAND_PERMISSIONS_V2"] = "APPLICATION_COMMAND_PERMISSIONS_V2";
+    /** guild has set up auto moderation rules */
+    GuildFeature["AUTO_MODERATION"] = "AUTO_MODERATION";
+    /** guild has access to set a guild banner image */
+    GuildFeature["BANNER"] = "BANNER";
+    /** guild can enable welcome screen, Membership Screening, stage channels and discovery, and receives community updates */
+    GuildFeature["COMMUNITY"] = "COMMUNITY";
+    /** guild has been set as a support server on the App Directory */
+    GuildFeature["DEVELOPER_SUPPORT_SERVER"] = "DEVELOPER_SUPPORT_SERVER";
+    /** guild is able to be discovered in the directory */
+    GuildFeature["DISCOVERABLE"] = "DISCOVERABLE";
+    /** guild is able to be featured in the directory */
+    GuildFeature["FEATURABLE"] = "FEATURABLE";
+    /** guild has paused invites, preventing new users from joining */
+    GuildFeature["INVITES_DISABLED"] = "INVITES_DISABLED";
+    /** guild has access to set an invite splash background */
+    GuildFeature["INVITE_SPLASH"] = "INVITE_SPLASH";
+    /** guild has enabled Membership Screening */
+    GuildFeature["MEMBER_VERIFICATION_GATE_ENABLED"] = "MEMBER_VERIFICATION_GATE_ENABLED";
+    /** guild has enabled monetization */
+    GuildFeature["MONETIZATION_ENABLED"] = "MONETIZATION_ENABLED";
+    /** guild has increased custom sticker slots */
+    GuildFeature["MORE_STICKERS"] = "MORE_STICKERS";
+    /** guild has access to create announcement channels */
+    GuildFeature["NEWS"] = "NEWS";
+    /** guild is partnered */
+    GuildFeature["PARTNERED"] = "PARTNERED";
+    /** guild can be previewed before joining via Membership Screening or the directory */
+    GuildFeature["PREVIEW_ENABLED"] = "PREVIEW_ENABLED";
+    /** guild is able to set role icons */
+    GuildFeature["ROLE_ICONS"] = "ROLE_ICONS";
+    /** guild has enabled ticketed events */
+    GuildFeature["TICKETED_EVENTS_ENABLED"] = "TICKETED_EVENTS_ENABLED";
+    /** guild has access to set a vanity URL */
+    GuildFeature["VANITY_URL"] = "VANITY_URL";
+    /** guild is verified */
+    GuildFeature["VERIFIED"] = "VERIFIED";
+    /** guild has access to set 384kbps bitrate in voice (previously VIP voice servers) */
+    GuildFeature["VIP_REGIONS"] = "VIP_REGIONS";
+    /** guild has enabled the welcome screen */
+    GuildFeature["WELCOME_SCREEN_ENABLED"] = "WELCOME_SCREEN_ENABLED";
+})(GuildFeature || (GuildFeature = {}));
+export var GuildNsfwLevel;
+(function (GuildNsfwLevel) {
+    GuildNsfwLevel[GuildNsfwLevel["DEFAULT"] = 0] = "DEFAULT";
+    GuildNsfwLevel[GuildNsfwLevel["EXPLICIT"] = 1] = "EXPLICIT";
+    GuildNsfwLevel[GuildNsfwLevel["SAFE"] = 2] = "SAFE";
+    GuildNsfwLevel[GuildNsfwLevel["AGE_RESTRICTED"] = 3] = "AGE_RESTRICTED";
+})(GuildNsfwLevel || (GuildNsfwLevel = {}));
+export var GuildScheduledEventEntityType;
+(function (GuildScheduledEventEntityType) {
+    GuildScheduledEventEntityType[GuildScheduledEventEntityType["STAGE_INSTANCE"] = 1] = "STAGE_INSTANCE";
+    GuildScheduledEventEntityType[GuildScheduledEventEntityType["VOICE"] = 2] = "VOICE";
+    GuildScheduledEventEntityType[GuildScheduledEventEntityType["EXTERNAL"] = 3] = "EXTERNAL";
+})(GuildScheduledEventEntityType || (GuildScheduledEventEntityType = {}));
+export var GuildScheduledEventPrivacyLevel;
+(function (GuildScheduledEventPrivacyLevel) {
+    /** the scheduled event is only accessible to guild members */
+    GuildScheduledEventPrivacyLevel[GuildScheduledEventPrivacyLevel["GUILD_ONLY"] = 2] = "GUILD_ONLY";
+})(GuildScheduledEventPrivacyLevel || (GuildScheduledEventPrivacyLevel = {}));
+export var GuildScheduledEventStatus;
+(function (GuildScheduledEventStatus) {
+    GuildScheduledEventStatus[GuildScheduledEventStatus["SCHEDULED"] = 1] = "SCHEDULED";
+    GuildScheduledEventStatus[GuildScheduledEventStatus["ACTIVE"] = 2] = "ACTIVE";
+    GuildScheduledEventStatus[GuildScheduledEventStatus["COMPLETED"] = 3] = "COMPLETED";
+    GuildScheduledEventStatus[GuildScheduledEventStatus["CANCELED"] = 4] = "CANCELED";
+})(GuildScheduledEventStatus || (GuildScheduledEventStatus = {}));
+export var IntegrationExpireBehavior;
+(function (IntegrationExpireBehavior) {
+    IntegrationExpireBehavior[IntegrationExpireBehavior["REMOVE_ROLE"] = 0] = "REMOVE_ROLE";
+    IntegrationExpireBehavior[IntegrationExpireBehavior["KICK"] = 1] = "KICK";
+})(IntegrationExpireBehavior || (IntegrationExpireBehavior = {}));
+export var InteractionCallbackType;
+(function (InteractionCallbackType) {
+    /** ACK a Ping */
+    InteractionCallbackType[InteractionCallbackType["PONG"] = 1] = "PONG";
+    /** respond to an interaction with a message */
+    InteractionCallbackType[InteractionCallbackType["CHANNEL_MESSAGE_WITH_SOURCE"] = 4] = "CHANNEL_MESSAGE_WITH_SOURCE";
+    /** ACK an interaction and edit a response later, the user sees a loading state */
+    InteractionCallbackType[InteractionCallbackType["DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE"] = 5] = "DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE";
+    /** for components, ACK an interaction and edit the original message later; the user does not see a loading state */
+    InteractionCallbackType[InteractionCallbackType["DEFERRED_UPDATE_MESSAGE"] = 6] = "DEFERRED_UPDATE_MESSAGE";
+    /** for components, edit the message the component was attached to */
+    InteractionCallbackType[InteractionCallbackType["UPDATE_MESSAGE"] = 7] = "UPDATE_MESSAGE";
+    /** respond to an autocomplete interaction with suggested choices */
+    InteractionCallbackType[InteractionCallbackType["APPLICATION_COMMAND_AUTOCOMPLETE_RESULT"] = 8] = "APPLICATION_COMMAND_AUTOCOMPLETE_RESULT";
+    /** respond to an interaction with a popup modal */
+    InteractionCallbackType[InteractionCallbackType["MODAL"] = 9] = "MODAL";
+})(InteractionCallbackType || (InteractionCallbackType = {}));
+export var InteractionType;
+(function (InteractionType) {
+    InteractionType[InteractionType["PING"] = 1] = "PING";
+    InteractionType[InteractionType["APPLICATION_COMMAND"] = 2] = "APPLICATION_COMMAND";
+    InteractionType[InteractionType["MESSAGE_COMPONENT"] = 3] = "MESSAGE_COMPONENT";
+    InteractionType[InteractionType["APPLICATION_COMMAND_AUTOCOMPLETE"] = 4] = "APPLICATION_COMMAND_AUTOCOMPLETE";
+    InteractionType[InteractionType["MODAL_SUBMIT"] = 5] = "MODAL_SUBMIT";
+})(InteractionType || (InteractionType = {}));
+export var InviteTargetType;
+(function (InviteTargetType) {
+    InviteTargetType[InviteTargetType["STREAM"] = 1] = "STREAM";
+    InviteTargetType[InviteTargetType["EMBEDDED_APPLICATION"] = 2] = "EMBEDDED_APPLICATION";
+})(InviteTargetType || (InviteTargetType = {}));
+export var KeywordPresetType;
+(function (KeywordPresetType) {
+    /** Words that may be considered forms of swearing or cursing */
+    KeywordPresetType[KeywordPresetType["PROFANITY"] = 1] = "PROFANITY";
+    /** Words that refer to sexually explicit behavior or activity */
+    KeywordPresetType[KeywordPresetType["SEXUAL_CONTENT"] = 2] = "SEXUAL_CONTENT";
+    /** Personal insults or words that may be considered hate speech */
+    KeywordPresetType[KeywordPresetType["SLURS"] = 3] = "SLURS";
+})(KeywordPresetType || (KeywordPresetType = {}));
+export var MembershipState;
+(function (MembershipState) {
+    MembershipState[MembershipState["INVITED"] = 1] = "INVITED";
+    MembershipState[MembershipState["ACCEPTED"] = 2] = "ACCEPTED";
+})(MembershipState || (MembershipState = {}));
+export var MessageActivityType;
+(function (MessageActivityType) {
+    MessageActivityType[MessageActivityType["JOIN"] = 1] = "JOIN";
+    MessageActivityType[MessageActivityType["SPECTATE"] = 2] = "SPECTATE";
+    MessageActivityType[MessageActivityType["LISTEN"] = 3] = "LISTEN";
+    MessageActivityType[MessageActivityType["JOIN_REQUEST"] = 5] = "JOIN_REQUEST";
+})(MessageActivityType || (MessageActivityType = {}));
+export const MessageFlag = {
+    /** this message has been published to subscribed channels (via Channel Following) */
+    CROSSPOSTED: 1 << 0,
+    /** this message originated from a message in another channel (via Channel Following) */
+    IS_CROSSPOST: 1 << 1,
+    /** do not include any embeds when serializing this message */
+    SUPPRESS_EMBEDS: 1 << 2,
+    /** the source message for this crosspost has been deleted (via Channel Following) */
+    SOURCE_MESSAGE_DELETED: 1 << 3,
+    /** this message came from the urgent message system */
+    URGENT: 1 << 4,
+    /** this message has an associated thread, with the same id as the message */
+    HAS_THREAD: 1 << 5,
+    /** this message is only visible to the user who invoked the Interaction */
+    EPHEMERAL: 1 << 6,
+    /** this message is an Interaction Response and the bot is "thinking" */
+    LOADING: 1 << 7,
+    /** this message failed to mention some roles and add their members to the thread */
+    FAILED_TO_MENTION_SOME_ROLES_IN_THREAD: 1 << 8,
+};
+export var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["DEFAULT"] = 0] = "DEFAULT";
+    MessageType[MessageType["RECIPIENT_ADD"] = 1] = "RECIPIENT_ADD";
+    MessageType[MessageType["RECIPIENT_REMOVE"] = 2] = "RECIPIENT_REMOVE";
+    MessageType[MessageType["CALL"] = 3] = "CALL";
+    MessageType[MessageType["CHANNEL_NAME_CHANGE"] = 4] = "CHANNEL_NAME_CHANGE";
+    MessageType[MessageType["CHANNEL_ICON_CHANGE"] = 5] = "CHANNEL_ICON_CHANGE";
+    MessageType[MessageType["CHANNEL_PINNED_MESSAGE"] = 6] = "CHANNEL_PINNED_MESSAGE";
+    MessageType[MessageType["USER_JOIN"] = 7] = "USER_JOIN";
+    MessageType[MessageType["GUILD_BOOST"] = 8] = "GUILD_BOOST";
+    MessageType[MessageType["GUILD_BOOST_TIER_1"] = 9] = "GUILD_BOOST_TIER_1";
+    MessageType[MessageType["GUILD_BOOST_TIER_2"] = 10] = "GUILD_BOOST_TIER_2";
+    MessageType[MessageType["GUILD_BOOST_TIER_3"] = 11] = "GUILD_BOOST_TIER_3";
+    MessageType[MessageType["CHANNEL_FOLLOW_ADD"] = 12] = "CHANNEL_FOLLOW_ADD";
+    MessageType[MessageType["GUILD_DISCOVERY_DISQUALIFIED"] = 14] = "GUILD_DISCOVERY_DISQUALIFIED";
+    MessageType[MessageType["GUILD_DISCOVERY_REQUALIFIED"] = 15] = "GUILD_DISCOVERY_REQUALIFIED";
+    MessageType[MessageType["GUILD_DISCOVERY_GRACE_PERIOD_INITIAL_WARNING"] = 16] = "GUILD_DISCOVERY_GRACE_PERIOD_INITIAL_WARNING";
+    MessageType[MessageType["GUILD_DISCOVERY_GRACE_PERIOD_FINAL_WARNING"] = 17] = "GUILD_DISCOVERY_GRACE_PERIOD_FINAL_WARNING";
+    MessageType[MessageType["THREAD_CREATED"] = 18] = "THREAD_CREATED";
+    MessageType[MessageType["REPLY"] = 19] = "REPLY";
+    MessageType[MessageType["CHAT_INPUT_COMMAND"] = 20] = "CHAT_INPUT_COMMAND";
+    MessageType[MessageType["THREAD_STARTER_MESSAGE"] = 21] = "THREAD_STARTER_MESSAGE";
+    MessageType[MessageType["GUILD_INVITE_REMINDER"] = 22] = "GUILD_INVITE_REMINDER";
+    MessageType[MessageType["CONTEXT_MENU_COMMAND"] = 23] = "CONTEXT_MENU_COMMAND";
+    MessageType[MessageType["AUTO_MODERATION_ACTION"] = 24] = "AUTO_MODERATION_ACTION";
+})(MessageType || (MessageType = {}));
+export var MfaLevel;
+(function (MfaLevel) {
+    /** guild has no MFA/2FA requirement for moderation actions */
+    MfaLevel[MfaLevel["NONE"] = 0] = "NONE";
+    /** guild has a 2FA requirement for moderation actions */
+    MfaLevel[MfaLevel["ELEVATED"] = 1] = "ELEVATED";
+})(MfaLevel || (MfaLevel = {}));
+export var MutableGuildFeature;
+(function (MutableGuildFeature) {
+    MutableGuildFeature["COMMUNITY"] = "COMMUNITY";
+    MutableGuildFeature["INVITES_DISABLED"] = "INVITES_DISABLED";
+    MutableGuildFeature["DISCOVERABLE"] = "DISCOVERABLE";
+})(MutableGuildFeature || (MutableGuildFeature = {}));
+export var OAuth2Scope;
+(function (OAuth2Scope) {
+    /** allows your app to fetch data from a user's "Now Playing/Recently Played" list - requires Discord approval */
+    OAuth2Scope["ACTIVITIES_READ"] = "activities.read";
+    /** allows your app to update a user's activity - requires Discord approval (NOT REQUIRED FOR GAMESDK ACTIVITY MANAGER) */
+    OAuth2Scope["ACTIVITIES_WRITE"] = "activities.write";
+    /** allows your app to read build data for a user's applications */
+    OAuth2Scope["APPLICATIONS_BUILDS_READ"] = "applications.builds.read";
+    /** allows your app to upload/update builds for a user's applications - requires Discord approval */
+    OAuth2Scope["APPLICATIONS_BUILDS_UPLOAD"] = "applications.builds.upload";
+    /** allows your app to use commands in a guild */
+    OAuth2Scope["APPLICATIONS_COMMANDS"] = "applications.commands";
+    /** allows your app to update its commands using a Bearer token - client credentials grant only */
+    OAuth2Scope["APPLICATIONS_COMMANDS_UPDATE"] = "applications.commands.update";
+    /** allows your app to update permissions for its commands in a guild a user has permissions to */
+    OAuth2Scope["APPLICATIONS_COMMANDS_PERMISSIONS_UPDATE"] = "applications.commands.permissions.update";
+    /** allows your app to read entitlements for a user's applications */
+    OAuth2Scope["APPLICATIONS_ENTITLEMENTS"] = "applications.entitlements";
+    /** allows your app to read and update store data (SKUs, store listings, achievements, etc.) for a user's applications */
+    OAuth2Scope["APPLICATIONS_STORE_UPDATE"] = "applications.store.update";
+    /** for oauth2 bots, this puts the bot in the user's selected guild by default */
+    OAuth2Scope["BOT"] = "bot";
+    /** allows /users/@me/connections to return linked third-party accounts */
+    OAuth2Scope["CONNECTIONS"] = "connections";
+    /** allows your app to see information about the user's DMs and group DMs - requires Discord approval */
+    OAuth2Scope["DM_CHANNELS_READ"] = "dm_channels.read";
+    /** enables /users/@me to return an email */
+    OAuth2Scope["EMAIL"] = "email";
+    /** allows your app to join users to a group dm */
+    OAuth2Scope["GDM_JOIN"] = "gdm.join";
+    /** allows /users/@me/guilds to return basic information about all of a user's guilds */
+    OAuth2Scope["GUILDS"] = "guilds";
+    /** allows /guilds/{guild.id}/members/{user.id} to be used for joining users to a guild */
+    OAuth2Scope["GUILDS_JOIN"] = "guilds.join";
+    /** allows /users/@me/guilds/{guild.id}/member to return a user's member information in a guild */
+    OAuth2Scope["GUILDS_MEMBERS_READ"] = "guilds.members.read";
+    /** allows /users/@me without email */
+    OAuth2Scope["IDENTIFY"] = "identify";
+    /** for local rpc server api access, this allows you to read messages from all client channels (otherwise restricted to channels/guilds your app creates) */
+    OAuth2Scope["MESSAGES_READ"] = "messages.read";
+    /** allows your app to know a user's friends and implicit relationships - requires Discord approval */
+    OAuth2Scope["RELATIONSHIPS_READ"] = "relationships.read";
+    /** for local rpc server access, this allows you to control a user's local Discord client - requires Discord approval */
+    OAuth2Scope["RPC"] = "rpc";
+    /** for local rpc server access, this allows you to update a user's activity - requires Discord approval */
+    OAuth2Scope["RPC_ACTIVITIES_WRITE"] = "rpc.activities.write";
+    /** for local rpc server access, this allows you to receive notifications pushed out to the user - requires Discord approval */
+    OAuth2Scope["RPC_NOTIFICATIONS_READ"] = "rpc.notifications.read";
+    /** for local rpc server access, this allows you to read a user's voice settings and listen for voice events - requires Discord approval */
+    OAuth2Scope["RPC_VOICE_READ"] = "rpc.voice.read";
+    /** for local rpc server access, this allows you to update a user's voice settings - requires Discord approval */
+    OAuth2Scope["RPC_VOICE_WRITE"] = "rpc.voice.write";
+    /** allows your app to connect to voice on user's behalf and see all the voice members - requires Discord approval */
+    OAuth2Scope["VOICE"] = "voice";
+    /** this generates a webhook that is returned in the oauth token response for authorization code grants */
+    OAuth2Scope["WEBHOOK_INCOMING"] = "webhook.incoming";
+})(OAuth2Scope || (OAuth2Scope = {}));
+export const PermissionFlag = {
+    /** Allows creation of instant invites */
+    CREATE_INSTANT_INVITE: BigInt(1) << BigInt(0),
+    /** Allows kicking members */
+    KICK_MEMBERS: BigInt(1) << BigInt(1),
+    /** Allows banning members */
+    BAN_MEMBERS: BigInt(1) << BigInt(2),
+    /** Allows all permissions and bypasses channel permission overwrites */
+    ADMINISTRATOR: BigInt(1) << BigInt(3),
+    /** Allows management and editing of channels */
+    MANAGE_CHANNELS: BigInt(1) << BigInt(4),
+    /** Allows management and editing of the guild */
+    MANAGE_GUILD: BigInt(1) << BigInt(5),
+    /** Allows for the addition of reactions to messages */
+    ADD_REACTIONS: BigInt(1) << BigInt(6),
+    /** Allows for viewing of audit logs */
+    VIEW_AUDIT_LOG: BigInt(1) << BigInt(7),
+    /** Allows for using priority speaker in a voice channel */
+    PRIORITY_SPEAKER: BigInt(1) << BigInt(8),
+    /** Allows the user to go live */
+    STREAM: BigInt(1) << BigInt(9),
+    /** Allows guild members to view a channel, which includes reading messages in text channels and joining voice channels */
+    VIEW_CHANNEL: BigInt(1) << BigInt(10),
+    /** Allows for sending messages in a channel and creating threads in a forum (does not allow sending messages in threads) */
+    SEND_MESSAGES: BigInt(1) << BigInt(11),
+    /** Allows for sending of /tts messages */
+    SEND_TTS_MESSAGES: BigInt(1) << BigInt(12),
+    /** Allows for deletion of other users messages */
+    MANAGE_MESSAGES: BigInt(1) << BigInt(13),
+    /** Links sent by users with this permission will be auto-embedded */
+    EMBED_LINKS: BigInt(1) << BigInt(14),
+    /** Allows for uploading images and files */
+    ATTACH_FILES: BigInt(1) << BigInt(15),
+    /** Allows for reading of message history */
+    READ_MESSAGE_HISTORY: BigInt(1) << BigInt(16),
+    /** Allows for using the @everyone tag to notify all users in a channel, and the @here tag to notify all online users in a channel */
+    MENTION_EVERYONE: BigInt(1) << BigInt(17),
+    /** Allows the usage of custom emojis from other servers */
+    USE_EXTERNAL_EMOJIS: BigInt(1) << BigInt(18),
+    /** Allows for viewing guild insights */
+    VIEW_GUILD_INSIGHTS: BigInt(1) << BigInt(19),
+    /** Allows for joining of a voice channel */
+    CONNECT: BigInt(1) << BigInt(20),
+    /** Allows for speaking in a voice channel */
+    SPEAK: BigInt(1) << BigInt(21),
+    /** Allows for muting members in a voice channel */
+    MUTE_MEMBERS: BigInt(1) << BigInt(22),
+    /** Allows for deafening of members in a voice channel */
+    DEAFEN_MEMBERS: BigInt(1) << BigInt(23),
+    /** Allows for moving of members between voice channels */
+    MOVE_MEMBERS: BigInt(1) << BigInt(24),
+    /** Allows for using voice-activity-detection in a voice channel */
+    USE_VAD: BigInt(1) << BigInt(25),
+    /** Allows for modification of own nickname */
+    CHANGE_NICKNAME: BigInt(1) << BigInt(26),
+    /** Allows for modification of other users nicknames */
+    MANAGE_NICKNAMES: BigInt(1) << BigInt(27),
+    /** Allows management and editing of roles */
+    MANAGE_ROLES: BigInt(1) << BigInt(28),
+    /** Allows management and editing of webhooks */
+    MANAGE_WEBHOOKS: BigInt(1) << BigInt(29),
+    /** Allows management and editing of emojis and stickers */
+    MANAGE_EMOJIS_AND_STICKERS: BigInt(1) << BigInt(30),
+    /** Allows members to use application commands, including slash commands and context menu commands. */
+    USE_APPLICATION_COMMANDS: BigInt(1) << BigInt(31),
+    /** Allows for requesting to speak in stage channels. (This permission is under active development and may be changed or removed.) */
+    REQUEST_TO_SPEAK: BigInt(1) << BigInt(32),
+    /** Allows for creating, editing, and deleting scheduled events */
+    MANAGE_EVENTS: BigInt(1) << BigInt(33),
+    /** Allows for deleting and archiving threads, and viewing all private threads */
+    MANAGE_THREADS: BigInt(1) << BigInt(34),
+    /** Allows for creating public and announcement threads */
+    CREATE_PUBLIC_THREADS: BigInt(1) << BigInt(35),
+    /** Allows for creating private threads */
+    CREATE_PRIVATE_THREADS: BigInt(1) << BigInt(36),
+    /** Allows the usage of custom stickers from other servers */
+    USE_EXTERNAL_STICKERS: BigInt(1) << BigInt(37),
+    /** Allows for sending messages in threads */
+    SEND_MESSAGES_IN_THREADS: BigInt(1) << BigInt(38),
+    /** Allows for using Activities (applications with the EMBEDDED flag) in a voice channel */
+    USE_EMBEDDED_ACTIVITIES: BigInt(1) << BigInt(39),
+    /** Allows for timing out users to prevent them from sending or reacting to messages in chat and threads, and from speaking in voice and stage channels */
+    MODERATE_MEMBERS: BigInt(1) << BigInt(40),
+};
+export var PremiumTier;
+(function (PremiumTier) {
+    /** guild has not unlocked any Server Boost perks */
+    PremiumTier[PremiumTier["NONE"] = 0] = "NONE";
+    /** guild has unlocked Server Boost level 1 perks */
+    PremiumTier[PremiumTier["TIER_1"] = 1] = "TIER_1";
+    /** guild has unlocked Server Boost level 2 perks */
+    PremiumTier[PremiumTier["TIER_2"] = 2] = "TIER_2";
+    /** guild has unlocked Server Boost level 3 perks */
+    PremiumTier[PremiumTier["TIER_3"] = 3] = "TIER_3";
+})(PremiumTier || (PremiumTier = {}));
+export var PremiumType;
+(function (PremiumType) {
+    PremiumType[PremiumType["NONE"] = 0] = "NONE";
+    PremiumType[PremiumType["NITRO_CLASSIC"] = 1] = "NITRO_CLASSIC";
+    PremiumType[PremiumType["NITRO"] = 2] = "NITRO";
+    PremiumType[PremiumType["NITRO_BASIC"] = 3] = "NITRO_BASIC";
+})(PremiumType || (PremiumType = {}));
+export var PrivacyLevel;
+(function (PrivacyLevel) {
+    /** The Stage instance is visible publicly. (deprecated) */
+    PrivacyLevel[PrivacyLevel["PUBLIC"] = 1] = "PUBLIC";
+    /** The Stage instance is visible to only guild members. */
+    PrivacyLevel[PrivacyLevel["GUILD_ONLY"] = 2] = "GUILD_ONLY";
+})(PrivacyLevel || (PrivacyLevel = {}));
+export var SortOrderType;
+(function (SortOrderType) {
+    /** Sort forum posts by activity */
+    SortOrderType[SortOrderType["LATEST_ACTIVITY"] = 0] = "LATEST_ACTIVITY";
+    /** Sort forum posts by creation time (from most recent to oldest) */
+    SortOrderType[SortOrderType["CREATION_DATE"] = 1] = "CREATION_DATE";
+})(SortOrderType || (SortOrderType = {}));
+export var StatusType;
+(function (StatusType) {
+    /** Online */
+    StatusType["ONLINE"] = "online";
+    /** Do Not Disturb */
+    StatusType["DND"] = "dnd";
+    /** AFK */
+    StatusType["IDLE"] = "idle";
+    /** Invisible and shown as offline */
+    StatusType["INVISIBLE"] = "invisible";
+    /** Offline */
+    StatusType["OFFLINE"] = "offline";
+})(StatusType || (StatusType = {}));
+export var StickerFormatType;
+(function (StickerFormatType) {
+    StickerFormatType[StickerFormatType["PNG"] = 1] = "PNG";
+    StickerFormatType[StickerFormatType["APNG"] = 2] = "APNG";
+    StickerFormatType[StickerFormatType["LOTTIE"] = 3] = "LOTTIE";
+})(StickerFormatType || (StickerFormatType = {}));
+export var StickerType;
+(function (StickerType) {
+    /** an official sticker in a pack, part of Nitro or in a removed purchasable pack */
+    StickerType[StickerType["STANDARD"] = 1] = "STANDARD";
+    /** a sticker uploaded to a guild for the guild's members */
+    StickerType[StickerType["GUILD"] = 2] = "GUILD";
+})(StickerType || (StickerType = {}));
+export const SystemChannelFlag = {
+    /** Suppress member join notifications */
+    SUPPRESS_JOIN_NOTIFICATIONS: 1 << 0,
+    /** Suppress server boost notifications */
+    SUPPRESS_PREMIUM_SUBSCRIPTIONS: 1 << 1,
+    /** Suppress server setup tips */
+    SUPPRESS_GUILD_REMINDER_NOTIFICATIONS: 1 << 2,
+    /** Hide member join sticker reply buttons */
+    SUPPRESS_JOIN_NOTIFICATION_REPLIES: 1 << 3,
+};
+export var TextInputStyle;
+(function (TextInputStyle) {
+    /** Single-line input */
+    TextInputStyle[TextInputStyle["SHORT"] = 1] = "SHORT";
+    /** Multi-line input */
+    TextInputStyle[TextInputStyle["PARAGRAPH"] = 2] = "PARAGRAPH";
+})(TextInputStyle || (TextInputStyle = {}));
+export var TriggerType;
+(function (TriggerType) {
+    /** check if content contains words from a user defined list of keywords */
+    TriggerType[TriggerType["KEYWORD"] = 1] = "KEYWORD";
+    /** check if content represents generic spam */
+    TriggerType[TriggerType["SPAM"] = 3] = "SPAM";
+    /** check if content contains words from internal pre-defined wordsets */
+    TriggerType[TriggerType["KEYWORD_PRESET"] = 4] = "KEYWORD_PRESET";
+    /** check if content contains more unique mentions than allowed */
+    TriggerType[TriggerType["MENTION_SPAM"] = 5] = "MENTION_SPAM";
+})(TriggerType || (TriggerType = {}));
+export const UserFlag = {
+    /** Discord Employee */
+    STAFF: 1 << 0,
+    /** Partnered Server Owner */
+    PARTNER: 1 << 1,
+    /** HypeSquad Events Member */
+    HYPESQUAD: 1 << 2,
+    /** Bug Hunter Level 1 */
+    BUG_HUNTER_LEVEL_1: 1 << 3,
+    /** House Bravery Member */
+    HYPESQUAD_ONLINE_HOUSE_1: 1 << 6,
+    /** House Brilliance Member */
+    HYPESQUAD_ONLINE_HOUSE_2: 1 << 7,
+    /** House Balance Member */
+    HYPESQUAD_ONLINE_HOUSE_3: 1 << 8,
+    /** Early Nitro Supporter */
+    PREMIUM_EARLY_SUPPORTER: 1 << 9,
+    /** User is a team */
+    TEAM_PSEUDO_USER: 1 << 10,
+    /** Bug Hunter Level 2 */
+    BUG_HUNTER_LEVEL_2: 1 << 14,
+    /** Verified Bot */
+    VERIFIED_BOT: 1 << 16,
+    /** Early Verified Bot Developer */
+    VERIFIED_DEVELOPER: 1 << 17,
+    /** Discord Certified Moderator */
+    CERTIFIED_MODERATOR: 1 << 18,
+    /** Bot uses only HTTP interactions and is shown in the online member list */
+    BOT_HTTP_INTERACTIONS: 1 << 19,
+    /** User is an Active Developer */
+    ACTIVE_DEVELOPER: 1 << 22,
+};
+export var VerificationLevel;
+(function (VerificationLevel) {
+    /** unrestricted */
+    VerificationLevel[VerificationLevel["NONE"] = 0] = "NONE";
+    /** must have verified email on account */
+    VerificationLevel[VerificationLevel["LOW"] = 1] = "LOW";
+    /** must be registered on Discord for longer than 5 minutes */
+    VerificationLevel[VerificationLevel["MEDIUM"] = 2] = "MEDIUM";
+    /** must be a member of the server for longer than 10 minutes */
+    VerificationLevel[VerificationLevel["HIGH"] = 3] = "HIGH";
+    /** must have a verified phone number */
+    VerificationLevel[VerificationLevel["VERY_HIGH"] = 4] = "VERY_HIGH";
+})(VerificationLevel || (VerificationLevel = {}));
+export var VideoQualityMode;
+(function (VideoQualityMode) {
+    /** Discord chooses the quality for optimal performance */
+    VideoQualityMode[VideoQualityMode["AUTO"] = 1] = "AUTO";
+    /** 720p */
+    VideoQualityMode[VideoQualityMode["FULL"] = 2] = "FULL";
+})(VideoQualityMode || (VideoQualityMode = {}));
+export var VisibilityType;
+(function (VisibilityType) {
+    /** invisible to everyone except the user themselves */
+    VisibilityType[VisibilityType["NONE"] = 0] = "NONE";
+    /** visible to everyone */
+    VisibilityType[VisibilityType["EVERYONE"] = 1] = "EVERYONE";
+})(VisibilityType || (VisibilityType = {}));
+export var VoiceOpcode;
+(function (VoiceOpcode) {
+    /** Begin a voice websocket connection. */
+    VoiceOpcode[VoiceOpcode["IDENTIFY"] = 0] = "IDENTIFY";
+    /** Select the voice protocol. */
+    VoiceOpcode[VoiceOpcode["SELECT_PROTOCOL"] = 1] = "SELECT_PROTOCOL";
+    /** Complete the websocket handshake. */
+    VoiceOpcode[VoiceOpcode["READY"] = 2] = "READY";
+    /** Keep the websocket connection alive. */
+    VoiceOpcode[VoiceOpcode["HEARTBEAT"] = 3] = "HEARTBEAT";
+    /** Describe the session. */
+    VoiceOpcode[VoiceOpcode["SESSION_DESCRIPTION"] = 4] = "SESSION_DESCRIPTION";
+    /** Indicate which users are speaking. */
+    VoiceOpcode[VoiceOpcode["SPEAKING"] = 5] = "SPEAKING";
+    /** Sent to acknowledge a received client heartbeat. */
+    VoiceOpcode[VoiceOpcode["HEARTBEAT_ACK"] = 6] = "HEARTBEAT_ACK";
+    /** Resume a connection. */
+    VoiceOpcode[VoiceOpcode["RESUME"] = 7] = "RESUME";
+    /** Time to wait between sending heartbeats in milliseconds. */
+    VoiceOpcode[VoiceOpcode["HELLO"] = 8] = "HELLO";
+    /** Acknowledge a successful session resume. */
+    VoiceOpcode[VoiceOpcode["RESUMED"] = 9] = "RESUMED";
+    /** A client has disconnected from the voice channel */
+    VoiceOpcode[VoiceOpcode["CLIENT_DISCONNECT"] = 13] = "CLIENT_DISCONNECT";
+})(VoiceOpcode || (VoiceOpcode = {}));
+export var WebhookType;
+(function (WebhookType) {
+    /** Incoming Webhooks can post messages to channels with a generated token */
+    WebhookType[WebhookType["INCOMING"] = 1] = "INCOMING";
+    /** Channel Follower Webhooks are internal webhooks used with Channel Following to post new messages into channels */
+    WebhookType[WebhookType["CHANNEL_FOLLOWER"] = 2] = "CHANNEL_FOLLOWER";
+    /** Application webhooks are webhooks used with Interactions */
+    WebhookType[WebhookType["APPLICATION"] = 3] = "APPLICATION";
+})(WebhookType || (WebhookType = {}));
+//# sourceMappingURL=types.js.map