lunibee 0.1.5 → 0.1.7

package/dist/core/index.js

@@ -107,58 +107,57 @@ var Permissions = {
   SendPolls: 1n << 49n,
   UseExternalApps: 1n << 50n
 };
-var PermissionFlagsBits;
-((PermissionFlagsBits2) => {
-  PermissionFlagsBits2["CreateInstantInvite"] = "1";
-  PermissionFlagsBits2["KickMembers"] = "2";
-  PermissionFlagsBits2["BanMembers"] = "4";
-  PermissionFlagsBits2["Administrator"] = "8";
-  PermissionFlagsBits2["ManageChannels"] = "16";
-  PermissionFlagsBits2["ManageGuild"] = "32";
-  PermissionFlagsBits2["AddReactions"] = "64";
-  PermissionFlagsBits2["ViewAuditLog"] = "128";
-  PermissionFlagsBits2["PrioritySpeaker"] = "256";
-  PermissionFlagsBits2["Stream"] = "512";
-  PermissionFlagsBits2["ViewChannel"] = "1024";
-  PermissionFlagsBits2["SendMessages"] = "2048";
-  PermissionFlagsBits2["SendTTSMessages"] = "4096";
-  PermissionFlagsBits2["ManageMessages"] = "8192";
-  PermissionFlagsBits2["EmbedLinks"] = "16384";
-  PermissionFlagsBits2["AttachFiles"] = "32768";
-  PermissionFlagsBits2["ReadMessageHistory"] = "65536";
-  PermissionFlagsBits2["MentionEveryone"] = "131072";
-  PermissionFlagsBits2["UseExternalEmojis"] = "262144";
-  PermissionFlagsBits2["ViewGuildInsights"] = "524288";
-  PermissionFlagsBits2["Connect"] = "1048576";
-  PermissionFlagsBits2["Speak"] = "2097152";
-  PermissionFlagsBits2["MuteMembers"] = "4194304";
-  PermissionFlagsBits2["DeafenMembers"] = "8388608";
-  PermissionFlagsBits2["MoveMembers"] = "16777216";
-  PermissionFlagsBits2["UseVAD"] = "33554432";
-  PermissionFlagsBits2["ChangeNickname"] = "67108864";
-  PermissionFlagsBits2["ManageNicknames"] = "134217728";
-  PermissionFlagsBits2["ManageRoles"] = "268435456";
-  PermissionFlagsBits2["ManageWebhooks"] = "536870912";
-  PermissionFlagsBits2["ManageGuildExpressions"] = "1073741824";
-  PermissionFlagsBits2["UseApplicationCommands"] = "2147483648";
-  PermissionFlagsBits2["RequestToSpeak"] = "4294967296";
-  PermissionFlagsBits2["ManageEvents"] = "8589934592";
-  PermissionFlagsBits2["ManageThreads"] = "17179869184";
-  PermissionFlagsBits2["CreatePublicThreads"] = "34359738368";
-  PermissionFlagsBits2["CreatePrivateThreads"] = "68719476736";
-  PermissionFlagsBits2["UseExternalStickers"] = "137438953472";
-  PermissionFlagsBits2["SendMessagesInThreads"] = "274877906944";
-  PermissionFlagsBits2["UseEmbeddedActivities"] = "549755813888";
-  PermissionFlagsBits2["ModerateMembers"] = "1099511627776";
-  PermissionFlagsBits2["ViewCreatorMonetizationAnalytics"] = "2199023255552";
-  PermissionFlagsBits2["UseSoundboard"] = "4398046511104";
-  PermissionFlagsBits2["CreateGuildExpressions"] = "8796093022208";
-  PermissionFlagsBits2["CreateEvents"] = "17592186044416";
-  PermissionFlagsBits2["UseExternalSounds"] = "35184372088832";
-  PermissionFlagsBits2["SendVoiceMessages"] = "70368744177664";
-  PermissionFlagsBits2["SendPolls"] = "562949953421312";
-  PermissionFlagsBits2["UseExternalApps"] = "1125899906842624";
-})(PermissionFlagsBits ||= {});
+var PermissionFlagsBits = {
+  CreateInstantInvite: 1n << 0n,
+  KickMembers: 1n << 1n,
+  BanMembers: 1n << 2n,
+  Administrator: 1n << 3n,
+  ManageChannels: 1n << 4n,
+  ManageGuild: 1n << 5n,
+  AddReactions: 1n << 6n,
+  ViewAuditLog: 1n << 7n,
+  PrioritySpeaker: 1n << 8n,
+  Stream: 1n << 9n,
+  ViewChannel: 1n << 10n,
+  SendMessages: 1n << 11n,
+  SendTTSMessages: 1n << 12n,
+  ManageMessages: 1n << 13n,
+  EmbedLinks: 1n << 14n,
+  AttachFiles: 1n << 15n,
+  ReadMessageHistory: 1n << 16n,
+  MentionEveryone: 1n << 17n,
+  UseExternalEmojis: 1n << 18n,
+  ViewGuildInsights: 1n << 19n,
+  Connect: 1n << 20n,
+  Speak: 1n << 21n,
+  MuteMembers: 1n << 22n,
+  DeafenMembers: 1n << 23n,
+  MoveMembers: 1n << 24n,
+  UseVAD: 1n << 25n,
+  ChangeNickname: 1n << 26n,
+  ManageNicknames: 1n << 27n,
+  ManageRoles: 1n << 28n,
+  ManageWebhooks: 1n << 29n,
+  ManageGuildExpressions: 1n << 30n,
+  UseApplicationCommands: 1n << 31n,
+  RequestToSpeak: 1n << 32n,
+  ManageEvents: 1n << 33n,
+  ManageThreads: 1n << 34n,
+  CreatePublicThreads: 1n << 35n,
+  CreatePrivateThreads: 1n << 36n,
+  UseExternalStickers: 1n << 37n,
+  SendMessagesInThreads: 1n << 38n,
+  UseEmbeddedActivities: 1n << 39n,
+  ModerateMembers: 1n << 40n,
+  ViewCreatorMonetizationAnalytics: 1n << 41n,
+  UseSoundboard: 1n << 42n,
+  CreateGuildExpressions: 1n << 43n,
+  CreateEvents: 1n << 44n,
+  UseExternalSounds: 1n << 45n,
+  SendVoiceMessages: 1n << 46n,
+  SendPolls: 1n << 49n,
+  UseExternalApps: 1n << 50n
+};
 
 class PermissionSet {
   bitfield;
@@ -403,7 +402,7 @@ class PermissionSet {
       if (permission in Permissions)
         return Permissions[permission];
       if (permission in PermissionFlagsBits)
-        return BigInt(PermissionFlagsBits[permission]);
+        return PermissionFlagsBits[permission];
       const lower = permission.charAt(0).toLowerCase() + permission.slice(1);
       if (lower in Permission)
         return Permission[lower];
@@ -420,6 +419,228 @@ class PermissionsBitField extends PermissionSet {
     super(value);
   }
 }
+// packages/core/src/events.ts
+var ClientEvent;
+((ClientEvent2) => {
+  ClientEvent2["Ready"] = "ready";
+  ClientEvent2["Resumed"] = "resumed";
+  ClientEvent2["InvalidSession"] = "invalidSession";
+  ClientEvent2["Raw"] = "raw";
+  ClientEvent2["Error"] = "error";
+  ClientEvent2["Open"] = "open";
+  ClientEvent2["Close"] = "close";
+  ClientEvent2["MessageCreate"] = "messageCreate";
+  ClientEvent2["MessageUpdate"] = "messageUpdate";
+  ClientEvent2["MessageDelete"] = "messageDelete";
+  ClientEvent2["MessageDeleteBulk"] = "messageDeleteBulk";
+  ClientEvent2["MessageReactionAdd"] = "messageReactionAdd";
+  ClientEvent2["MessageReactionRemove"] = "messageReactionRemove";
+  ClientEvent2["MessageReactionRemoveAll"] = "messageReactionRemoveAll";
+  ClientEvent2["MessageReactionRemoveEmoji"] = "messageReactionRemoveEmoji";
+  ClientEvent2["MessagePollVoteAdd"] = "messagePollVoteAdd";
+  ClientEvent2["MessagePollVoteRemove"] = "messagePollVoteRemove";
+  ClientEvent2["GuildCreate"] = "guildCreate";
+  ClientEvent2["GuildUpdate"] = "guildUpdate";
+  ClientEvent2["GuildDelete"] = "guildDelete";
+  ClientEvent2["GuildAvailable"] = "guildAvailable";
+  ClientEvent2["GuildUnavailable"] = "guildUnavailable";
+  ClientEvent2["GuildMemberAdd"] = "guildMemberAdd";
+  ClientEvent2["GuildMemberUpdate"] = "guildMemberUpdate";
+  ClientEvent2["GuildMemberRemove"] = "guildMemberRemove";
+  ClientEvent2["GuildMembersChunk"] = "guildMembersChunk";
+  ClientEvent2["GuildBanAdd"] = "guildBanAdd";
+  ClientEvent2["GuildBanRemove"] = "guildBanRemove";
+  ClientEvent2["GuildRoleCreate"] = "guildRoleCreate";
+  ClientEvent2["GuildRoleUpdate"] = "guildRoleUpdate";
+  ClientEvent2["GuildRoleDelete"] = "guildRoleDelete";
+  ClientEvent2["GuildEmojisUpdate"] = "guildEmojisUpdate";
+  ClientEvent2["GuildStickersUpdate"] = "guildStickersUpdate";
+  ClientEvent2["GuildIntegrationsUpdate"] = "guildIntegrationsUpdate";
+  ClientEvent2["GuildScheduledEventCreate"] = "guildScheduledEventCreate";
+  ClientEvent2["GuildScheduledEventUpdate"] = "guildScheduledEventUpdate";
+  ClientEvent2["GuildScheduledEventDelete"] = "guildScheduledEventDelete";
+  ClientEvent2["GuildScheduledEventUserAdd"] = "guildScheduledEventUserAdd";
+  ClientEvent2["GuildScheduledEventUserRemove"] = "guildScheduledEventUserRemove";
+  ClientEvent2["AutoModerationRuleCreate"] = "autoModerationRuleCreate";
+  ClientEvent2["AutoModerationRuleUpdate"] = "autoModerationRuleUpdate";
+  ClientEvent2["AutoModerationRuleDelete"] = "autoModerationRuleDelete";
+  ClientEvent2["AutoModerationActionExecution"] = "autoModerationActionExecution";
+  ClientEvent2["ChannelCreate"] = "channelCreate";
+  ClientEvent2["ChannelUpdate"] = "channelUpdate";
+  ClientEvent2["ChannelDelete"] = "channelDelete";
+  ClientEvent2["ChannelPinsUpdate"] = "channelPinsUpdate";
+  ClientEvent2["ThreadCreate"] = "threadCreate";
+  ClientEvent2["ThreadUpdate"] = "threadUpdate";
+  ClientEvent2["ThreadDelete"] = "threadDelete";
+  ClientEvent2["ThreadListSync"] = "threadListSync";
+  ClientEvent2["ThreadMembersUpdate"] = "threadMembersUpdate";
+  ClientEvent2["ThreadMemberUpdate"] = "threadMemberUpdate";
+  ClientEvent2["StageInstanceCreate"] = "stageInstanceCreate";
+  ClientEvent2["StageInstanceUpdate"] = "stageInstanceUpdate";
+  ClientEvent2["StageInstanceDelete"] = "stageInstanceDelete";
+  ClientEvent2["InviteCreate"] = "inviteCreate";
+  ClientEvent2["InviteDelete"] = "inviteDelete";
+  ClientEvent2["WebhooksUpdate"] = "webhooksUpdate";
+  ClientEvent2["VoiceStateUpdate"] = "voiceStateUpdate";
+  ClientEvent2["VoiceServerUpdate"] = "voiceServerUpdate";
+  ClientEvent2["PresenceUpdate"] = "presenceUpdate";
+  ClientEvent2["TypingStart"] = "typingStart";
+  ClientEvent2["InteractionCreate"] = "interactionCreate";
+})(ClientEvent ||= {});
+// packages/core/src/collector.ts
+import { EventEmitter } from "events";
+
+class Collector extends EventEmitter {
+  collected = new Map;
+  options;
+  ended = false;
+  endReason;
+  totalProcessed = 0;
+  #timeoutTimer;
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    if (options.time && options.time > 0) {
+      this.#timeoutTimer = setTimeout(() => {
+        this.stop("time");
+      }, options.time);
+    }
+  }
+  async handle(key, item) {
+    if (this.ended)
+      return false;
+    this.totalProcessed++;
+    const reachedProcessed = !!this.options.maxProcessed && this.totalProcessed >= this.options.maxProcessed;
+    let passed = true;
+    if (this.options.filter)
+      passed = !!await this.options.filter(item);
+    if (this.ended)
+      return false;
+    if (!passed) {
+      if (reachedProcessed)
+        this.stop("processedLimit");
+      return false;
+    }
+    this.collected.set(key, item);
+    this.emit("collect", item);
+    if (this.options.max && this.collected.size >= this.options.max) {
+      this.stop("limit");
+      return true;
+    }
+    if (reachedProcessed) {
+      this.stop("processedLimit");
+      return true;
+    }
+    return true;
+  }
+  stop(reason = "user") {
+    if (this.ended)
+      return;
+    this.ended = true;
+    this.endReason = reason;
+    if (this.#timeoutTimer)
+      clearTimeout(this.#timeoutTimer);
+    this.emit("end", this.collected, reason);
+    this.removeAllListeners();
+  }
+  next() {
+    return new Promise((resolve, reject) => {
+      if (this.ended) {
+        return reject(new Error(`Collector already ended: ${this.endReason ?? "unknown"}`));
+      }
+      this.once("collect", (item) => {
+        resolve(item);
+      });
+      this.once("end", (_collected, reason) => {
+        reject(new Error(`Collector ended before item was collected: ${reason}`));
+      });
+    });
+  }
+}
+// packages/types/src/index.ts
+var GatewayIntentBits = {
+  Guilds: 1 << 0,
+  GuildMembers: 1 << 1,
+  GuildModeration: 1 << 2,
+  GuildExpressions: 1 << 3,
+  GuildIntegrations: 1 << 4,
+  GuildWebhooks: 1 << 5,
+  GuildInvites: 1 << 6,
+  GuildVoiceStates: 1 << 7,
+  GuildPresences: 1 << 8,
+  GuildMessages: 1 << 9,
+  GuildMessageReactions: 1 << 10,
+  GuildMessageTyping: 1 << 11,
+  DirectMessages: 1 << 12,
+  DirectMessageReactions: 1 << 13,
+  DirectMessageTyping: 1 << 14,
+  MessageContent: 1 << 15,
+  GuildScheduledEvents: 1 << 16,
+  AutoModerationConfiguration: 1 << 20,
+  AutoModerationExecution: 1 << 21,
+  GuildMessagePolls: 1 << 24,
+  DirectMessagePolls: 1 << 25
+};
+var IntentBits = {
+  guild: 1 << 0,
+  guilds: 1 << 0,
+  guildMembers: 1 << 1,
+  guildModeration: 1 << 2,
+  guildBans: 1 << 2,
+  guildExpressions: 1 << 3,
+  guildEmojis: 1 << 3,
+  guildEmojisAndStickers: 1 << 3,
+  guildIntegrations: 1 << 4,
+  guildWebhooks: 1 << 5,
+  guildInvites: 1 << 6,
+  guildVoiceStates: 1 << 7,
+  guildPresences: 1 << 8,
+  guildMessages: 1 << 9,
+  guildMessage: 1 << 9,
+  guildMessageReactions: 1 << 10,
+  guildMessageTyping: 1 << 11,
+  directMessages: 1 << 12,
+  directMessageReactions: 1 << 13,
+  directMessageTyping: 1 << 14,
+  messageContent: 1 << 15,
+  guildScheduledEvents: 1 << 16,
+  autoModerationConfiguration: 1 << 20,
+  autoModerationExecution: 1 << 21,
+  guildMessagePolls: 1 << 24,
+  directMessagePolls: 1 << 25
+};
+var Intents = IntentBits;
+function resolveGatewayIntents(intents) {
+  if (typeof intents === "number")
+    return intents;
+  if (Array.isArray(intents)) {
+    return intents.reduce((acc, intent) => {
+      return acc | resolveGatewayIntents(intent);
+    }, 0);
+  }
+  if (typeof intents === "string") {
+    if (intents in GatewayIntentBits)
+      return GatewayIntentBits[intents];
+    if (intents in IntentBits)
+      return IntentBits[intents];
+    const lower = intents.charAt(0).toLowerCase() + intents.slice(1);
+    if (lower in IntentBits)
+      return IntentBits[lower];
+    const num = Number(intents);
+    if (!Number.isNaN(num))
+      return num;
+  }
+  return 0;
+}
+var InteractionResponseType = {
+  Pong: 1,
+  ChannelMessage: 4,
+  DeferredChannelMessage: 5,
+  DeferredMessageUpdate: 6,
+  MessageUpdate: 7,
+  Autocomplete: 8,
+  Modal: 9
+};
 // packages/collection/src/index.ts
 class Collection extends Map {
   first() {
@@ -544,6 +765,97 @@ class Collection extends Map {
       entry = [item[0], item[1]];
     return entry;
   }
+  union(other) {
+    const result = this.clone();
+    for (const [key, value] of other)
+      result.set(key, value);
+    return result;
+  }
+  intersection(other) {
+    const result = new Collection;
+    for (const [key, value] of this) {
+      if (other.has(key))
+        result.set(key, value);
+    }
+    return result;
+  }
+  difference(other) {
+    const result = new Collection;
+    for (const [key, value] of this) {
+      if (!other.has(key))
+        result.set(key, value);
+    }
+    return result;
+  }
+  partition(predicate) {
+    const pass = new Collection;
+    const fail = new Collection;
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        pass.set(key, value);
+      else
+        fail.set(key, value);
+    }
+    return [pass, fail];
+  }
+  tap(fn) {
+    fn(this);
+    return this;
+  }
+  flatMap(transform) {
+    const result = [];
+    for (const [key, value] of this) {
+      for (const item of transform(value, key, this))
+        result.push(item);
+    }
+    return result;
+  }
+  reduce(fn, initialValue) {
+    let acc = initialValue;
+    for (const [key, value] of this)
+      acc = fn(acc, value, key, this);
+    return acc;
+  }
+  sorted(comparator) {
+    const decorated = [...this.entries()].map((entry, index) => ({
+      entry,
+      index
+    }));
+    if (comparator)
+      decorated.sort((x, y) => {
+        const comparison = comparator(x.entry[1], y.entry[1], x.entry[0], y.entry[0]);
+        return comparison !== 0 ? comparison : x.index - y.index;
+      });
+    const result = new Collection;
+    for (const { entry } of decorated)
+      result.set(entry[0], entry[1]);
+    return result;
+  }
+  random() {
+    const arr = [...this.values()];
+    if (!arr.length)
+      return;
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+  randomKey() {
+    const arr = [...this.keys()];
+    if (!arr.length)
+      return;
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+  at(index) {
+    const arr = [...this.values()];
+    const i = index < 0 ? arr.length + index : index;
+    return arr[i];
+  }
+  keyAt(index) {
+    const arr = [...this.keys()];
+    const i = index < 0 ? arr.length + index : index;
+    return arr[i];
+  }
+  toJSON() {
+    return [...this.entries()];
+  }
 }
 
 // packages/managers/src/base.ts
@@ -612,11 +924,66 @@ class ResourceManager extends Manager {
     return this.upsert(resource);
   }
 }
+// packages/rest/package.json
+var package_default = {
+  name: "@lunibee/rest",
+  version: "0.1.7",
+  type: "module",
+  module: "./src/index.ts",
+  types: "./src/index.ts",
+  exports: {
+    ".": "./src/index.ts"
+  }
+};
+
+// packages/rest/src/store.ts
+class MemoryRateLimitStore {
+  #buckets = new Map;
+  #routeBuckets = new Map;
+  #globalResetAt = 0;
+  static #PRUNE_INTERVAL = 60000;
+  #lastPruneAt = 0;
+  getBucketHash(route) {
+    return this.#routeBuckets.get(route);
+  }
+  setBucketHash(route, hash) {
+    this.#routeBuckets.set(route, hash);
+  }
+  getBucket(key) {
+    return this.#buckets.get(key);
+  }
+  updateBucket(key, state) {
+    this.#buckets.set(key, state);
+    const now = Date.now();
+    if (now - this.#lastPruneAt >= MemoryRateLimitStore.#PRUNE_INTERVAL) {
+      this.#lastPruneAt = now;
+      this.prune();
+    }
+  }
+  prune(maxAge = 0) {
+    const cutoff = Date.now() - Math.max(0, maxAge);
+    for (const [key, state] of this.#buckets) {
+      if (state.resetAt <= cutoff)
+        this.#buckets.delete(key);
+    }
+  }
+  getGlobalReset() {
+    return this.#globalResetAt;
+  }
+  setGlobalReset(resetAt) {
+    this.#globalResetAt = resetAt;
+  }
+}
+
 // packages/rest/src/routes.ts
 var Routes = {
   user: () => "/users/@me",
   userById: (userId) => `/users/${snowflake(userId, "User ID")}`,
   guild: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}`,
+  guildPreview: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/preview`,
+  guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
+  guildWebhooks: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/webhooks`,
+  guildInvites: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/invites`,
   guildChannels: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/channels`,
   guildMember: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}`,
   guildRoles: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles`,
@@ -644,7 +1011,6 @@ var Routes = {
   guildApplicationCommand: (applicationId, guildId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands/${snowflake(commandId, "Command ID")}`,
   interactionCallback: (interactionId, token) => `/interactions/${snowflake(interactionId, "Interaction ID")}/${encodeURIComponent(token)}/callback`,
   interactionOriginalResponse: (applicationId, token) => `/webhooks/${snowflake(applicationId, "Application ID")}/${encodeURIComponent(token)}/messages/@original`,
-  guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
   channelPublicArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/public`,
   channelPrivateArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/private`,
   threadMembers: (threadId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members`,
@@ -654,7 +1020,18 @@ var Routes = {
   guildAutoModerationRule: (guildId, ruleId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules/${snowflake(ruleId, "Rule ID")}`,
   voiceRegions: () => "/voice/regions",
   gateway: () => "/gateway",
-  gatewayBot: () => "/gateway/bot"
+  gatewayBot: () => "/gateway/bot",
+  guildAuditLog: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/audit-logs`,
+  guildMembers: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members`,
+  guildWelcomeScreen: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/welcome-screen`,
+  guildOnboarding: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/onboarding`,
+  guildPrune: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/prune`,
+  stageInstances: () => "/stage-instances",
+  stageInstanceByChannel: (channelId) => `/stage-instances/${snowflake(channelId, "Channel ID")}`,
+  invite: (code) => `/invites/${encodeURIComponent(code)}`,
+  guildVanity: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/vanity-url`,
+  guildEmoji: (guildId, emojiId) => emojiId ? `/guilds/${snowflake(guildId, "Guild ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/emojis`,
+  applicationEmoji: (applicationId, emojiId) => emojiId ? `/applications/${snowflake(applicationId, "Application ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/emojis`
 };
 function snowflake(value, field) {
   if (!/^\d{1,20}$/.test(value))
@@ -679,7 +1056,53 @@ class RESTError extends Error {
     this.path = options.path;
   }
 }
-function createRetryPolicy(maxRetries = 2) {
+var LIBRARY_VERSION = package_default.version;
+var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
+var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${package_default.version})`;
+var REQUEST_DATA_KEYS = new Set([
+  "body",
+  "files",
+  "query",
+  "headers",
+  "reason",
+  "auth",
+  "signal"
+]);
+function isRequestData(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  if (Array.isArray(value))
+    return false;
+  if (typeof FormData !== "undefined" && value instanceof FormData)
+    return false;
+  if (value instanceof Blob || value instanceof Uint8Array || value instanceof ArrayBuffer)
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    return false;
+  return keys.every((key) => REQUEST_DATA_KEYS.has(key));
+}
+function serializeQuery(query) {
+  if (query === undefined)
+    return "";
+  if (typeof query === "string")
+    return query.length === 0 || query.startsWith("?") ? query : `?${query}`;
+  const params = query instanceof URLSearchParams ? query : new URLSearchParams(Object.entries(query).flatMap(([key, value]) => value === undefined || value === null ? [] : [[key, String(value)]]));
+  const serialized = params.toString();
+  return serialized.length === 0 ? "" : `?${serialized}`;
+}
+function majorParameter(path) {
+  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/.exec(path);
+  if (!match)
+    return "@none";
+  if (match[1] === "webhooks" && match[3] !== undefined)
+    return `${match[2]}:${match[3]}`;
+  return match[2];
+}
+function scopeBucket(hashOrRoute, major) {
+  return `${hashOrRoute}|${major}`;
+}
+function createRetryPolicy(maxRetries = 2) {
   if (!Number.isFinite(maxRetries) || maxRetries < 0)
     throw new TypeError("maxRetries must be a non-negative finite number.");
   return {
@@ -701,14 +1124,21 @@ class REST {
   #timeout;
   #retryPolicy;
   #token;
-  #globalResetAt = 0;
-  #buckets = new Map;
-  #routeBuckets = new Map;
+  #store;
+  #localQueues = new Map;
+  #hooks = {};
   constructor(options = {}) {
     this.#token = options.token;
     this.#timeout = Math.max(1, options.timeout ?? 15000);
     this.#retryPolicy = options.retryPolicy ?? createRetryPolicy(options.retries ?? 2);
     this.#baseURL = (options.baseURL ?? "https://discord.com/api/v10").replace(/\/$/, "");
+    this.#store = options.store ?? new MemoryRateLimitStore;
+    if (options.hooks)
+      this.#hooks = options.hooks;
+  }
+  setHooks(hooks) {
+    this.#hooks = hooks;
+    return this;
   }
   setToken(token) {
     if (!token.trim())
@@ -721,52 +1151,91 @@ class REST {
       throw new TypeError("REST method is required.");
     if (!path.startsWith("/"))
       throw new TypeError("REST paths must start with '/'.");
+    const files = options.files;
+    if (files && files.length > 0 && !(body instanceof FormData))
+      body = this.#fileForm(body, files);
+    const query = serializeQuery(options.query);
+    const finalPath = query ? `${path}${query}` : path;
     const route = `${normalizedMethod}:${this.#normalizeRoute(path)}`;
-    let bucketKey = this.#routeBuckets.get(route) ?? route;
-    let bucket = this.#buckets.get(bucketKey) ?? {
-      remaining: 1,
-      resetAt: 0,
-      queue: Promise.resolve()
-    };
-    this.#buckets.set(bucketKey, bucket);
-    const previous = bucket.queue;
+    const major = majorParameter(path);
+    let bucketKey = scopeBucket(await this.#store.getBucketHash(route) ?? route, major);
+    const queueKey = bucketKey;
+    const previous = this.#localQueues.get(queueKey) ?? Promise.resolve();
     let release;
-    bucket.queue = new Promise((resolve) => {
+    const gate = new Promise((resolve) => {
       release = resolve;
     });
+    this.#localQueues.set(queueKey, gate);
     await this.#abortable(previous, options.signal, path);
     try {
       for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
-        await this.#wait(bucket, options.signal, path);
+        await this.#wait(bucketKey, options.signal, path);
         await this.#waitGlobal(options.signal, path);
         const controller = new AbortController;
         const onAbort = () => controller.abort(options.signal?.reason);
         if (options.signal?.aborted)
           throw this.#abortError(path, options.signal.reason);
-        options.signal?.addEventListener("abort", onAbort, { once: true });
+        options.signal?.addEventListener("abort", onAbort, {
+          once: true
+        });
         const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
+        const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+        const headers = { ...options.headers };
+        if (options.auth !== false && this.#token)
+          headers["Authorization"] = `Bot ${this.#token}`;
+        headers["User-Agent"] = USER_AGENT;
+        if (options.reason !== undefined)
+          headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+        if (!isFormData)
+          headers["Content-Type"] = "application/json";
+        const fetchBody = isFormData ? body : body === undefined ? undefined : JSON.stringify(body);
         try {
-          const response = await fetch(`${this.#baseURL}${path}`, {
+          this.#emit(this.#hooks.onRequest, {
+            method: normalizedMethod,
+            path,
+            attempt
+          });
+          const requestStart = Date.now();
+          const response = await fetch(`${this.#baseURL}${finalPath}`, {
             method: normalizedMethod,
-            headers: {
-              ...this.#token ? { Authorization: `Bot ${this.#token}` } : {},
-              "Content-Type": "application/json",
-              "User-Agent": "Lunibee/0.1.0"
-            },
-            body: body === undefined ? undefined : JSON.stringify(body),
+            headers,
+            body: fetchBody,
             signal: controller.signal
           });
-          bucket = this.#update(response, bucket, route, bucketKey);
-          bucketKey = this.#routeBuckets.get(route) ?? bucketKey;
+          this.#emit(this.#hooks.onResponse, {
+            method: normalizedMethod,
+            path,
+            status: response.status,
+            durationMs: Date.now() - requestStart
+          });
+          bucketKey = await this.#update(response, bucketKey, route, major);
           const payload = await this.#readPayload(response);
           if (response.ok)
             return response.status === 204 ? undefined : payload;
           const data = this.#errorData(payload);
           const retryAfter = response.status === 429 ? this.#retryAfter(response, data) : undefined;
-          if (data.global && retryAfter !== undefined)
-            this.#globalResetAt = Date.now() + retryAfter * 1000;
+          if (data.global && retryAfter !== undefined) {
+            const currentGlobal = await this.#store.getGlobalReset();
+            await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
+          }
+          if (response.status === 429)
+            this.#emit(this.#hooks.onRateLimit, {
+              method: normalizedMethod,
+              path,
+              retryAfterMs: (retryAfter ?? 1) * 1000,
+              global: data.global ?? false,
+              bucket: await this.#store.getBucketHash(route)
+            });
           if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, response.status)) {
-            await this.#sleep(this.#retryPolicy.getDelay(attempt, retryAfter), options.signal, path);
+            const delay = this.#retryPolicy.getDelay(attempt, retryAfter);
+            this.#emit(this.#hooks.onRetry, {
+              method: normalizedMethod,
+              path,
+              attempt,
+              status: response.status,
+              delayMs: delay
+            });
+            await this.#sleep(delay, options.signal, path);
             continue;
           }
           throw new RESTError(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method: normalizedMethod, path });
@@ -789,30 +1258,64 @@ class REST {
       throw new RESTError("Discord REST request exhausted its retry attempts", 0, undefined, undefined, { method: normalizedMethod, path });
     } finally {
       release();
+      if (this.#localQueues.get(queueKey) === gate)
+        this.#localQueues.delete(queueKey);
     }
   }
+  #dispatch(method, path, bodyOrOptions, options) {
+    if (options === undefined && isRequestData(bodyOrOptions))
+      return this.request(method, path, bodyOrOptions.body, bodyOrOptions);
+    return this.request(method, path, bodyOrOptions, options);
+  }
   get(path, options) {
-    return this.request("GET", path, undefined, options);
+    return this.request("GET", path, options?.body, options);
   }
   post(path, body, options) {
-    return this.request("POST", path, body, options);
+    return this.#dispatch("POST", path, body, options);
   }
   patch(path, body, options) {
-    return this.request("PATCH", path, body, options);
+    return this.#dispatch("PATCH", path, body, options);
   }
   put(path, body, options) {
-    return this.request("PUT", path, body, options);
+    return this.#dispatch("PUT", path, body, options);
   }
   delete(path, options) {
-    return this.request("DELETE", path, undefined, options);
+    return this.request("DELETE", path, options?.body, options);
+  }
+  #fileForm(payload, files) {
+    const form = new FormData;
+    form.append("payload_json", JSON.stringify(payload));
+    for (let i = 0;i < files.length; i++) {
+      const file = files[i];
+      const blob = file.data instanceof Blob ? file.data : new Blob([file.data], {
+        type: file.contentType ?? "application/octet-stream"
+      });
+      form.append(`files[${i}]`, blob, file.name);
+    }
+    return form;
+  }
+  postWithFiles(path, payload, files, options) {
+    return this.request("POST", path, this.#fileForm(payload, files), options);
+  }
+  patchWithFiles(path, payload, files, options) {
+    return this.request("PATCH", path, this.#fileForm(payload, files), options);
+  }
+  #emit(hook, ctx) {
+    if (!hook)
+      return;
+    Promise.resolve().then(() => hook(ctx)).catch(() => {});
   }
-  async#wait(bucket, signal, path) {
+  async#wait(bucketKey, signal, path) {
+    const bucket = await this.#store.getBucket(bucketKey);
+    if (!bucket)
+      return;
     const delay = bucket.resetAt - Date.now();
     if (bucket.remaining <= 0 && delay > 0)
       await this.#sleep(delay, signal, path);
   }
   async#waitGlobal(signal, path) {
-    const delay = this.#globalResetAt - Date.now();
+    const globalResetAt = await this.#store.getGlobalReset();
+    const delay = globalResetAt - Date.now();
     if (delay > 0)
       await this.#sleep(delay, signal, path);
   }
@@ -876,16 +1379,17 @@ class REST {
     const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
     return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
   }
-  #update(response, bucket, route, bucketKey) {
+  async#update(response, bucketKey, route, major) {
+    let currentKey = bucketKey;
     const serverBucket = response.headers.get("X-RateLimit-Bucket");
     if (serverBucket) {
-      this.#routeBuckets.set(route, serverBucket);
-      if (serverBucket !== bucketKey) {
-        const shared = this.#buckets.get(serverBucket) ?? bucket;
-        this.#buckets.set(serverBucket, shared);
-        bucket = shared;
-      }
+      await this.#store.setBucketHash(route, serverBucket);
+      currentKey = scopeBucket(serverBucket, major);
     }
+    let bucket = await this.#store.getBucket(currentKey) ?? {
+      remaining: 1,
+      resetAt: 0
+    };
     const remaining = Number(response.headers.get("X-RateLimit-Remaining"));
     const resetAfter = Number(response.headers.get("X-RateLimit-Reset-After"));
     const reset = Number(response.headers.get("X-RateLimit-Reset"));
@@ -900,12 +1404,15 @@ class REST {
       if (Number.isFinite(retryAfter))
         bucket.resetAt = Math.max(bucket.resetAt, Date.now() + retryAfter * 1000);
     }
+    await this.#store.updateBucket(currentKey, bucket);
     if (response.headers.get("X-RateLimit-Global") === "true") {
       const retryAfter = Number(response.headers.get("Retry-After"));
-      if (Number.isFinite(retryAfter))
-        this.#globalResetAt = Math.max(this.#globalResetAt, Date.now() + retryAfter * 1000);
+      if (Number.isFinite(retryAfter)) {
+        const currentGlobal = await this.#store.getGlobalReset();
+        await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
+      }
     }
-    return bucket;
+    return currentKey;
   }
 }
 
@@ -920,6 +1427,16 @@ class BaseStructure {
   toString() {
     return this.id;
   }
+  get createdAt() {
+    return new Date(Number((BigInt(this.id) >> 22n) + 1420070400000n));
+  }
+}
+var CDN_BASE = "https://cdn.discordapp.com";
+function cdnURL(path, hash, options = {}) {
+  const isAnimated = hash.startsWith("a_") && !options.forceStatic;
+  const ext = options.extension ?? (isAnimated ? "gif" : "png");
+  const size = options.size ? `?size=${options.size}` : "";
+  return `${CDN_BASE}${path}/${hash}.${ext}${size}`;
 }
 
 class User extends BaseStructure {
@@ -929,6 +1446,7 @@ class User extends BaseStructure {
   bot;
   system;
   flags;
+  discriminator;
   constructor(data) {
     super(data.id);
     if (!data.username)
@@ -939,6 +1457,7 @@ class User extends BaseStructure {
     this.bot = data.bot ?? false;
     this.system = data.system ?? false;
     this.flags = data.public_flags ?? 0;
+    this.discriminator = data.discriminator && data.discriminator !== "0" ? data.discriminator : null;
   }
   get displayName() {
     return this.globalName ?? this.username;
@@ -946,21 +1465,29 @@ class User extends BaseStructure {
   avatarURL(options = {}) {
     if (!this.avatar)
       return null;
-    const extension = options.extension ?? (this.avatar.startsWith("a_") ? "gif" : "png");
-    return `https://cdn.discordapp.com/avatars/${this.id}/${this.avatar}.${extension}${options.size ? `?size=${options.size}` : ""}`;
+    return cdnURL(`/avatars/${this.id}`, this.avatar, options);
   }
   defaultAvatarURL() {
-    return `https://cdn.discordapp.com/embed/avatars/${Number(BigInt(this.id) % 5n)}.png`;
+    const index = this.discriminator ? Number(this.discriminator) % 5 : Number((BigInt(this.id) >> 22n) % 6n);
+    return `${CDN_BASE}/embed/avatars/${index}.png`;
   }
   displayAvatarURL(options = {}) {
     return this.avatarURL(options) ?? this.defaultAvatarURL();
   }
+  toString() {
+    return `<@${this.id}>`;
+  }
 }
 
 class Channel extends BaseStructure {
   type;
   name;
   guildId;
+  topic;
+  parentId;
+  nsfw;
+  rateLimitPerUser;
+  position;
   #context;
   constructor(data, context) {
     super(data.id);
@@ -969,6 +1496,11 @@ class Channel extends BaseStructure {
     this.type = data.type;
     this.name = data.name;
     this.guildId = data.guild_id;
+    this.topic = data.topic;
+    this.parentId = data.parent_id;
+    this.nsfw = data.nsfw;
+    this.rateLimitPerUser = data.rate_limit_per_user;
+    this.position = data.position;
     this.#context = context;
   }
   sendMessage(options) {
@@ -976,73 +1508,187 @@ class Channel extends BaseStructure {
       throw new Error("This channel is not attached to a client.");
     return this.#context.sendMessage(this.id, options);
   }
+  send(options) {
+    return this.sendMessage(options);
+  }
+  edit(options) {
+    if (!this.#context?.editChannel)
+      throw new Error("This channel is not attached to a client.");
+    return this.#context.editChannel(this.id, options);
+  }
+  editName(name) {
+    if (!name.trim())
+      throw new TypeError("Channel name cannot be empty.");
+    return this.edit({ name });
+  }
+  editTopic(topic) {
+    return this.edit({ topic });
+  }
+  editParent(parentId) {
+    return this.edit({ parent_id: parentId });
+  }
+  delete() {
+    if (!this.#context?.deleteChannel)
+      throw new Error("This channel is not attached to a client.");
+    return this.#context.deleteChannel(this.id);
+  }
+  update(options) {
+    return this.edit(options);
+  }
+  toString() {
+    return `<#${this.id}>`;
+  }
 }
 
 class Guild extends BaseStructure {
   name;
+  icon;
+  splash;
+  banner;
+  description;
   preferredLocale;
   ownerId;
+  features;
+  verificationLevel;
+  premiumTier;
+  premiumSubscriptionCount;
+  memberCount;
+  approximateMemberCount;
+  approximatePresenceCount;
+  vanityUrlCode;
+  nsfwLevel;
+  discoverySplash;
+  rulesChannelId;
+  systemChannelId;
+  systemChannelFlags;
+  maxMembers;
+  mfaLevel;
+  explicitContentFilter;
+  defaultMessageNotifications;
   constructor(data) {
     super(data.id);
     if (!data.name)
       throw new TypeError("A Discord guild requires a name.");
     this.name = data.name;
-    this.preferredLocale = data.preferred_locale;
+    this.icon = data.icon ?? null;
+    this.splash = data.splash ?? null;
+    this.banner = data.banner ?? null;
+    this.description = data.description ?? null;
+    this.preferredLocale = data.preferred_locale ?? "en-US";
     this.ownerId = data.owner_id;
+    this.features = data.features ?? [];
+    this.verificationLevel = data.verification_level ?? 0;
+    this.premiumTier = data.premium_tier ?? 0;
+    this.premiumSubscriptionCount = data.premium_subscription_count ?? 0;
+    this.memberCount = data.member_count ?? data.approximate_member_count;
+    this.approximateMemberCount = data.approximate_member_count;
+    this.approximatePresenceCount = data.approximate_presence_count;
+    this.vanityUrlCode = data.vanity_url_code ?? null;
+    this.nsfwLevel = data.nsfw_level ?? 0;
+    this.discoverySplash = data.discovery_splash ?? null;
+    const d = data;
+    this.rulesChannelId = d.rules_channel_id ?? null;
+    this.systemChannelId = d.system_channel_id ?? null;
+    this.systemChannelFlags = d.system_channel_flags ?? 0;
+    this.maxMembers = d.max_members ?? 0;
+    this.mfaLevel = d.mfa_level ?? 0;
+    this.explicitContentFilter = d.explicit_content_filter ?? 0;
+    this.defaultMessageNotifications = d.default_message_notifications ?? 0;
+  }
+  iconURL(options = {}) {
+    if (!this.icon)
+      return null;
+    return cdnURL(`/icons/${this.id}`, this.icon, options);
+  }
+  splashURL(options = {}) {
+    if (!this.splash)
+      return null;
+    return cdnURL(`/splashes/${this.id}`, this.splash, options);
+  }
+  bannerURL(options = {}) {
+    if (!this.banner)
+      return null;
+    return cdnURL(`/banners/${this.id}`, this.banner, options);
+  }
+  discoverySplashURL(options = {}) {
+    if (!this.discoverySplash)
+      return null;
+    return cdnURL(`/discovery-splashes/${this.id}`, this.discoverySplash, options);
+  }
+  widgetImageURL(style = "shield") {
+    return `https://discord.com/api/guilds/${this.id}/widget.png?style=${style}`;
+  }
+  hasFeature(feature) {
+    return this.features.includes(feature);
+  }
+  get isCommunity() {
+    return this.hasFeature("COMMUNITY");
+  }
+  get isPartnered() {
+    return this.hasFeature("PARTNERED");
+  }
+  get isVerified() {
+    return this.hasFeature("VERIFIED");
+  }
+  get isBoosted() {
+    return this.premiumSubscriptionCount > 0;
+  }
+  get boostLevel() {
+    return this.premiumTier;
+  }
+  get hasVanityUrl() {
+    return this.vanityUrlCode !== null;
+  }
+  get vanityURL() {
+    return this.vanityUrlCode ? `https://discord.gg/${this.vanityUrlCode}` : null;
+  }
+  toString() {
+    return this.name;
+  }
+}
+// packages/structures/src/resources.ts
+class AutoModerationRule extends BaseStructure {
+  guildId;
+  name;
+  creatorId;
+  eventType;
+  triggerType;
+  triggerMetadata;
+  actions;
+  enabled;
+  exemptRoles;
+  exemptChannels;
+  constructor(data) {
+    super(data.id);
+    if (!/^\d{1,20}$/.test(data.guild_id))
+      throw new TypeError("AutoModerationRule guild_id must be a valid snowflake.");
+    this.guildId = data.guild_id;
+    this.name = data.name;
+    this.creatorId = data.creator_id;
+    this.eventType = data.event_type;
+    this.triggerType = data.trigger_type;
+    this.triggerMetadata = data.trigger_metadata;
+    this.actions = data.actions;
+    this.enabled = data.enabled;
+    this.exemptRoles = data.exempt_roles;
+    this.exemptChannels = data.exempt_channels;
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      guildId: this.guildId,
+      name: this.name,
+      creatorId: this.creatorId,
+      eventType: this.eventType,
+      triggerType: this.triggerType,
+      triggerMetadata: this.triggerMetadata,
+      actions: this.actions,
+      enabled: this.enabled,
+      exemptRoles: this.exemptRoles,
+      exemptChannels: this.exemptChannels
+    };
   }
 }
-// packages/structures/src/permissions.ts
-var Permissions2 = {
-  CreateInstantInvite: 1n << 0n,
-  KickMembers: 1n << 1n,
-  BanMembers: 1n << 2n,
-  Administrator: 1n << 3n,
-  ManageChannels: 1n << 4n,
-  ManageGuild: 1n << 5n,
-  AddReactions: 1n << 6n,
-  ViewAuditLog: 1n << 7n,
-  PrioritySpeaker: 1n << 8n,
-  Stream: 1n << 9n,
-  ViewChannel: 1n << 10n,
-  SendMessages: 1n << 11n,
-  SendTTSMessages: 1n << 12n,
-  ManageMessages: 1n << 13n,
-  EmbedLinks: 1n << 14n,
-  AttachFiles: 1n << 15n,
-  ReadMessageHistory: 1n << 16n,
-  MentionEveryone: 1n << 17n,
-  UseExternalEmojis: 1n << 18n,
-  ViewGuildInsights: 1n << 19n,
-  Connect: 1n << 20n,
-  Speak: 1n << 21n,
-  MuteMembers: 1n << 22n,
-  DeafenMembers: 1n << 23n,
-  MoveMembers: 1n << 24n,
-  UseVAD: 1n << 25n,
-  ChangeNickname: 1n << 26n,
-  ManageNicknames: 1n << 27n,
-  ManageRoles: 1n << 28n,
-  ManageWebhooks: 1n << 29n,
-  ManageGuildExpressions: 1n << 30n,
-  UseApplicationCommands: 1n << 31n,
-  RequestToSpeak: 1n << 32n,
-  ManageEvents: 1n << 33n,
-  ManageThreads: 1n << 34n,
-  CreatePublicThreads: 1n << 35n,
-  CreatePrivateThreads: 1n << 36n,
-  UseExternalStickers: 1n << 37n,
-  SendMessagesInThreads: 1n << 38n,
-  UseEmbeddedActivities: 1n << 39n,
-  ModerateMembers: 1n << 40n,
-  ViewCreatorMonetizationAnalytics: 1n << 41n,
-  UseSoundboard: 1n << 42n,
-  CreateGuildExpressions: 1n << 43n,
-  CreateEvents: 1n << 44n,
-  UseExternalSounds: 1n << 45n,
-  SendVoiceMessages: 1n << 46n,
-  SendPolls: 1n << 49n,
-  UseExternalApps: 1n << 50n
-};
 // packages/structures/src/interactions.ts
 var InteractionType = {
   Ping: 1,
@@ -1051,16 +1697,167 @@ var InteractionType = {
   ApplicationCommandAutocomplete: 4,
   ModalSubmit: 5
 };
-var InteractionResponseType = {
-  Pong: 1,
-  ChannelMessage: 4,
-  DeferredChannelMessage: 5,
-  DeferredMessageUpdate: 6,
-  MessageUpdate: 7,
-  Autocomplete: 8,
-  Modal: 9
+var OptionType = {
+  SubCommand: 1,
+  SubCommandGroup: 2,
+  String: 3,
+  Integer: 4,
+  Boolean: 5,
+  User: 6,
+  Channel: 7,
+  Role: 8,
+  Mentionable: 9,
+  Number: 10,
+  Attachment: 11
 };
 
+class CommandOptions {
+  #options;
+  #resolved;
+  constructor(options, resolved = {}) {
+    let currentOptions = options;
+    let group = null;
+    let sub = null;
+    while (currentOptions.length === 1) {
+      const opt = currentOptions[0];
+      if (opt.type === OptionType.SubCommandGroup) {
+        group = opt.name;
+        currentOptions = opt.options ?? [];
+      } else if (opt.type === OptionType.SubCommand) {
+        sub = opt.name;
+        currentOptions = opt.options ?? [];
+      } else {
+        break;
+      }
+    }
+    this.#options = currentOptions;
+    this.#resolved = resolved;
+    this.#subcommandGroup = group;
+    this.#subcommand = sub;
+  }
+  #subcommandGroup;
+  #subcommand;
+  #get(name) {
+    return this.#options.find((o) => o.name.toLowerCase() === name.toLowerCase());
+  }
+  getSubcommand(required = false) {
+    if (!this.#subcommand && required) {
+      throw new TypeError("No subcommand was provided.");
+    }
+    return this.#subcommand;
+  }
+  getSubcommandGroup(required = false) {
+    if (!this.#subcommandGroup && required) {
+      throw new TypeError("No subcommand group was provided.");
+    }
+    return this.#subcommandGroup;
+  }
+  getString(name, required = false) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.String) {
+      if (required)
+        throw new TypeError(`Required option "${name}" (string) is missing.`);
+      return null;
+    }
+    return typeof opt.value === "string" ? opt.value : null;
+  }
+  getInteger(name, required = false) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.Integer) {
+      if (required)
+        throw new TypeError(`Required option "${name}" (integer) is missing.`);
+      return null;
+    }
+    return typeof opt.value === "number" ? Math.trunc(opt.value) : null;
+  }
+  getNumber(name, required = false) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.Number) {
+      if (required)
+        throw new TypeError(`Required option "${name}" (number) is missing.`);
+      return null;
+    }
+    return typeof opt.value === "number" ? opt.value : null;
+  }
+  getBoolean(name, required = false) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.Boolean) {
+      if (required)
+        throw new TypeError(`Required option "${name}" (boolean) is missing.`);
+      return null;
+    }
+    return typeof opt.value === "boolean" ? opt.value : null;
+  }
+  getUser(name, required = false) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.User) {
+      if (required)
+        throw new TypeError(`Required option "${name}" (user) is missing.`);
+      return null;
+    }
+    const userId = String(opt.value);
+    const resolved = this.#resolved?.users?.[userId] ?? null;
+    if (!resolved && required)
+      throw new TypeError(`Resolved user for option "${name}" is missing.`);
+    return resolved;
+  }
+  getChannel(name, required = false) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.Channel) {
+      if (required)
+        throw new TypeError(`Required option "${name}" (channel) is missing.`);
+      return null;
+    }
+    const channelId = String(opt.value);
+    const resolved = this.#resolved?.channels?.[channelId] ?? null;
+    if (!resolved && required)
+      throw new TypeError(`Resolved channel for option "${name}" is missing.`);
+    return resolved;
+  }
+  getRole(name, required = false) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.Role) {
+      if (required)
+        throw new TypeError(`Required option "${name}" (role) is missing.`);
+      return null;
+    }
+    const roleId = String(opt.value);
+    const resolved = this.#resolved?.roles?.[roleId] ?? null;
+    if (!resolved && required)
+      throw new TypeError(`Resolved role for option "${name}" is missing.`);
+    return resolved;
+  }
+  getMentionable(name, required = false) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.Mentionable) {
+      if (required)
+        throw new TypeError(`Required option "${name}" (mentionable) is missing.`);
+      return null;
+    }
+    const id = String(opt.value);
+    const resolved = this.#resolved?.users?.[id] ?? this.#resolved?.roles?.[id] ?? null;
+    if (!resolved && required)
+      throw new TypeError(`Resolved mentionable for option "${name}" is missing.`);
+    return resolved;
+  }
+  getAttachment(name, required = false) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.Attachment) {
+      if (required)
+        throw new TypeError(`Required option "${name}" (attachment) is missing.`);
+      return null;
+    }
+    const attachmentId = String(opt.value);
+    const resolved = this.#resolved?.attachments?.[attachmentId] ?? null;
+    if (!resolved && required)
+      throw new TypeError(`Resolved attachment for option "${name}" is missing.`);
+    return resolved;
+  }
+  get raw() {
+    return this.#options;
+  }
+}
+
 class InteractionResponse {
   type;
   data;
@@ -1174,9 +1971,16 @@ class Interaction {
 }
 
 class CommandInteraction extends Interaction {
+  options;
   get commandName() {
     return typeof this.data.data?.name === "string" ? this.data.data.name : "";
   }
+  constructor(client, data) {
+    super(client, data);
+    const rawOptions = data.data?.options ?? [];
+    const resolved = data.data?.resolved ?? {};
+    this.options = new CommandOptions(rawOptions, resolved);
+  }
 }
 
 class ComponentInteraction extends Interaction {
@@ -1202,20 +2006,75 @@ class ComponentInteraction extends Interaction {
     return result;
   }
 }
+
+class ModalSubmitInteraction extends Interaction {
+  get customId() {
+    return this.data?.data?.custom_id ?? "";
+  }
+  getInputValue(customId) {
+    const rows = this.data?.data?.components ?? [];
+    for (const row of rows) {
+      for (const comp of row.components ?? []) {
+        if (comp.custom_id === customId)
+          return comp.value;
+      }
+    }
+    return;
+  }
+  getRequiredInputValue(customId) {
+    const value = this.getInputValue(customId);
+    if (value === undefined)
+      throw new TypeError(`Modal input "${customId}" was not found in the submission.`);
+    return value;
+  }
+}
+
+class AutocompleteInteraction extends Interaction {
+  get commandName() {
+    return this.data?.data?.name ?? "";
+  }
+  get focusedOption() {
+    const options = this.data?.data?.options ?? [];
+    return findFocused(options);
+  }
+  async respond(choices) {
+    if (!Array.isArray(choices))
+      throw new TypeError("Autocomplete choices must be an array.");
+    const response = new InteractionResponse(InteractionResponseType.Autocomplete, { choices });
+    await this.postResponse(response);
+    this.replied = true;
+  }
+}
+function findFocused(options) {
+  for (const opt of options) {
+    if (opt.focused)
+      return { name: opt.name, value: opt.value, type: opt.type };
+    if (Array.isArray(opt.options)) {
+      const found = findFocused(opt.options);
+      if (found)
+        return found;
+    }
+  }
+  return;
+}
 function createInteraction(client, data) {
   switch (data.type) {
     case InteractionType.ApplicationCommand:
-    case InteractionType.ApplicationCommandAutocomplete:
       return new CommandInteraction(client, data);
+    case InteractionType.ApplicationCommandAutocomplete:
+      return new AutocompleteInteraction(client, data);
     case InteractionType.MessageComponent:
-    case InteractionType.ModalSubmit:
       return new ComponentInteraction(client, data);
+    case InteractionType.ModalSubmit:
+      return new ModalSubmitInteraction(client, data);
     default:
       return new Interaction(client, data);
   }
 }
 
 // packages/structures/src/index.ts
+var NON_SYSTEM_MESSAGE_TYPES = new Set([0, 19, 20, 23]);
+
 class Message extends BaseStructure {
   content;
   author;
@@ -1223,7 +2082,7 @@ class Message extends BaseStructure {
   channel;
   guildId;
   flags;
-  createdAt;
+  timestamp;
   attachments;
   embeds;
   mentions;
@@ -1232,6 +2091,7 @@ class Message extends BaseStructure {
   mentionEveryone;
   type;
   reference;
+  components;
   referencedMessage;
   #context;
   constructor(data, context) {
@@ -1243,9 +2103,10 @@ class Message extends BaseStructure {
     this.channelId = data.channel_id;
     this.guildId = data.guild_id;
     this.flags = data.flags ?? 0;
-    this.createdAt = new Date(data.timestamp ?? Number((BigInt(this.id) >> 22n) + 1420070400000n));
+    this.timestamp = new Date(data.timestamp ?? Number((BigInt(this.id) >> 22n) + 1420070400000n));
     this.attachments = data.attachments ?? [];
     this.embeds = data.embeds ?? [];
+    this.components = data.components ?? [];
     this.mentions = (data.mentions ?? []).map((user) => new User(user));
     this.mentionRoles = data.mention_roles ?? [];
     this.pinned = data.pinned ?? false;
@@ -1259,21 +2120,25 @@ class Message extends BaseStructure {
   get embedsSuppressed() {
     return (this.flags & 4) !== 0;
   }
+  get createdTimestamp() {
+    return this.timestamp.getTime();
+  }
+  get createdAt() {
+    return this.timestamp;
+  }
   edit(options) {
     if (!this.#context)
       throw new Error("This message is not attached to a client.");
     return this.#context.editMessage(this.channelId, this.id, options);
   }
+  update(options) {
+    return this.edit(options);
+  }
   delete() {
     if (!this.#context)
       throw new Error("This message is not attached to a client.");
     return this.#context.deleteMessage(this.channelId, this.id);
   }
-  crosspost() {
-    if (!this.#context)
-      throw new Error("This message is not attached to a client.");
-    return this.#context.crosspostMessage(this.channelId, this.id);
-  }
   reply(options) {
     if (!this.#context)
       throw new Error("This message is not attached to a client.");
@@ -1285,6 +2150,81 @@ class Message extends BaseStructure {
     };
     return this.#context.sendMessage(this.channelId, payload);
   }
+  crosspost() {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.crosspostMessage(this.channelId, this.id);
+  }
+  react(emoji) {
+    if (!this.#context?.addReaction)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.addReaction(this.channelId, this.id, emoji);
+  }
+  removeReaction(emoji, userId) {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return userId ? this.#context.removeReaction?.(this.channelId, this.id, emoji, userId) ?? Promise.reject(new Error("Reaction operations are unavailable.")) : this.#context.removeOwnReaction?.(this.channelId, this.id, emoji) ?? Promise.reject(new Error("Reaction operations are unavailable."));
+  }
+  removeAllReactions() {
+    if (!this.#context?.removeAllReactions)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.removeAllReactions(this.channelId, this.id);
+  }
+  pin() {
+    if (!this.#context?.pinMessage)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.pinMessage(this.channelId, this.id);
+  }
+  unpin() {
+    if (!this.#context?.unpinMessage)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.unpinMessage(this.channelId, this.id);
+  }
+  get isEphemeral() {
+    return (this.flags & 64) !== 0;
+  }
+  get isPinned() {
+    return this.pinned;
+  }
+  get isSystemMessage() {
+    return !NON_SYSTEM_MESSAGE_TYPES.has(this.type);
+  }
+  get isCrosspost() {
+    return (this.flags & 2) !== 0;
+  }
+  get hasAttachments() {
+    return this.attachments.length > 0;
+  }
+  get hasEmbeds() {
+    return this.embeds.length > 0;
+  }
+  get hasComponents() {
+    return this.components.length > 0;
+  }
+  suppressEmbeds() {
+    return this.edit({ flags: this.flags | 4 });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      content: this.content,
+      channelId: this.channelId,
+      guildId: this.guildId,
+      flags: this.flags,
+      pinned: this.pinned,
+      mentionEveryone: this.mentionEveryone,
+      type: this.type,
+      timestamp: this.timestamp.toISOString(),
+      author: { id: this.author.id, username: this.author.username },
+      attachments: [...this.attachments],
+      embeds: [...this.embeds],
+      components: [...this.components],
+      mentions: this.mentions.map((u) => u.id),
+      mentionRoles: [...this.mentionRoles],
+      reference: this.reference,
+      referencedMessage: this.referencedMessage ? this.referencedMessage.id : this.referencedMessage
+    };
+  }
 }
 
 // packages/managers/src/message.ts
@@ -1309,10 +2249,7 @@ class MessageManager {
   }
   async fetch(messageId) {
     const data = await this.#rest.get(Routes.message(this.#channelId, messageId));
-    const message = Array.isArray(data) ? data[0] : data;
-    if (!message)
-      throw new Error("Discord returned no message payload.");
-    return this.upsert(message);
+    return this.upsert(data);
   }
   fetchMany(messageIds) {
     return Promise.all(Array.from(messageIds, (messageId) => this.fetch(messageId)));
@@ -1353,8 +2290,110 @@ class ThreadManager {
     return new Channel(data, this.#context);
   }
 }
-// packages/managers/src/application.ts
-class ApplicationCommandManager {
+
+// packages/managers/src/user.ts
+class UserManager extends ResourceManager {
+  #rest;
+  constructor(rest) {
+    super(async (id) => new User(await rest.get(Routes.userById(id))), (user) => user.id);
+    this.#rest = rest;
+  }
+  async fetchMe() {
+    const data = await this.#rest.get("/users/@me");
+    return this.upsert(new User(data));
+  }
+  async editMe(options) {
+    const data = await this.#rest.patch("/users/@me", options);
+    return this.upsert(new User(data));
+  }
+  async leaveGuild(guildId) {
+    await this.#rest.delete(`/users/@me/guilds/${guildId}`);
+  }
+  async createDM(userId) {
+    return this.#rest.post("/users/@me/channels", {
+      recipient_id: userId
+    });
+  }
+}
+// packages/managers/src/guild.ts
+function withQuery(path, params) {
+  const suffix = params.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+class GuildManager extends ResourceManager {
+  #rest;
+  constructor(rest) {
+    super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
+    this.#rest = rest;
+  }
+  async create(options) {
+    const data = await this.#rest.post("/guilds", options);
+    return this.upsert(new Guild(data));
+  }
+  async edit(id, options) {
+    const data = await this.#rest.patch(Routes.guild(id), options);
+    return this.upsert(new Guild(data));
+  }
+  async deleteGuild(id) {
+    await this.#rest.delete(Routes.guild(id));
+  }
+  async fetchPreview(id) {
+    return this.#rest.get(Routes.guildPreview(id));
+  }
+  async fetchActiveThreads(id) {
+    return this.#rest.get(Routes.guildActiveThreads(id));
+  }
+  async fetchWebhooks(id) {
+    return this.#rest.get(Routes.guildWebhooks(id));
+  }
+  async fetchInvites(id) {
+    return this.#rest.get(Routes.guildInvites(id));
+  }
+  async fetchAuditLog(guildId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.userId)
+      params.set("user_id", options.userId);
+    if (options.actionType !== undefined)
+      params.set("action_type", String(options.actionType));
+    if (options.before)
+      params.set("before", options.before);
+    if (options.after)
+      params.set("after", options.after);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
+    return this.#rest.get(withQuery(Routes.guildAuditLog(guildId), params));
+  }
+  async fetchMembers(guildId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(1000, Math.max(1, options.limit))));
+    if (options.after)
+      params.set("after", options.after);
+    return this.#rest.get(withQuery(Routes.guildMembers(guildId), params));
+  }
+  async fetchAutoModerationRules(guildId) {
+    const rules = await this.#rest.get(Routes.guildAutoModerationRules(guildId));
+    return rules.map((r) => new AutoModerationRule(r));
+  }
+  async fetchAutoModerationRule(guildId, ruleId) {
+    const rule = await this.#rest.get(Routes.guildAutoModerationRule(guildId, ruleId));
+    return new AutoModerationRule(rule);
+  }
+  async createAutoModerationRule(guildId, options) {
+    const rule = await this.#rest.post(Routes.guildAutoModerationRules(guildId), options);
+    return new AutoModerationRule(rule);
+  }
+  async editAutoModerationRule(guildId, ruleId, options) {
+    const rule = await this.#rest.patch(Routes.guildAutoModerationRule(guildId, ruleId), options);
+    return new AutoModerationRule(rule);
+  }
+  async deleteAutoModerationRule(guildId, ruleId) {
+    await this.#rest.delete(Routes.guildAutoModerationRule(guildId, ruleId));
+  }
+}
+// packages/managers/src/application.ts
+class ApplicationCommandManager {
   #rest;
   #applicationId;
   constructor(rest, applicationId) {
@@ -1394,23 +2433,6 @@ class ApplicationCommandManager {
 }
 
 // packages/managers/src/index.ts
-class UserManager extends ResourceManager {
-  constructor(rest) {
-    super(async (id) => new User(await rest.get(Routes.userById(id))), (user) => user.id);
-  }
-}
-
-class GuildManager extends ResourceManager {
-  constructor(rest) {
-    super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
-  }
-}
-var MessageCreateOptions = undefined;
-var MessageEditOptions = undefined;
-var MessageFetchOptions = undefined;
-var MessageThreadOptions = undefined;
-var ReactionFetchOptions = undefined;
-
 class ChannelManager extends Manager {
   #rest;
   #context;
@@ -1422,7 +2444,15 @@ class ChannelManager extends Manager {
       sendMessage: (channelId, options) => this.send(channelId, options),
       editMessage: (channelId, messageId, options) => this.editMessage(channelId, messageId, options),
       deleteMessage: (channelId, messageId) => this.deleteMessage(channelId, messageId),
-      crosspostMessage: (channelId, messageId) => this.crosspostMessage(channelId, messageId)
+      crosspostMessage: (channelId, messageId) => this.crosspostMessage(channelId, messageId),
+      editChannel: (channelId, options) => this.edit(channelId, options),
+      deleteChannel: (channelId) => this.deleteChannel(channelId),
+      addReaction: (channelId, messageId, emoji) => this.addReaction(channelId, messageId, emoji),
+      removeOwnReaction: (channelId, messageId, emoji) => this.removeOwnReaction(channelId, messageId, emoji),
+      removeReaction: (channelId, messageId, emoji, userId) => this.removeReaction(channelId, messageId, emoji, userId),
+      removeAllReactions: (channelId, messageId) => this.removeAllReactions(channelId, messageId),
+      pinMessage: (channelId, messageId) => this.pinMessage(channelId, messageId),
+      unpinMessage: (channelId, messageId) => this.unpinMessage(channelId, messageId)
     };
   }
   messages(channelId) {
@@ -1437,8 +2467,7 @@ class ChannelManager extends Manager {
     return new ThreadManager(this.#rest, this.#context, channelId);
   }
   async fetch(channelId) {
-    const data = await this.#rest.get(Routes.channel(channelId));
-    return this.upsert(data);
+    return this.upsert(await this.#rest.get(Routes.channel(channelId)));
   }
   async resolve(channelId) {
     return this.get(channelId) ?? this.fetch(channelId);
@@ -1456,6 +2485,20 @@ class ChannelManager extends Manager {
   update(channel) {
     return this.set(channel.id, channel);
   }
+  async create(guildId, options) {
+    return this.upsert(await this.#rest.post(Routes.guildChannels(guildId), options));
+  }
+  async edit(channelId, options) {
+    return this.upsert(await this.#rest.patch(Routes.channel(channelId), options));
+  }
+  async deleteChannel(channelId) {
+    await this.#rest.delete(Routes.channel(channelId));
+    this.delete(channelId);
+  }
+  delete(channelId) {
+    this.#messageManagers.delete(channelId);
+    return super.delete(channelId);
+  }
   send(channelId, options) {
     return this.messages(channelId).send(options);
   }
@@ -1485,8 +2528,7 @@ class ChannelManager extends Manager {
     return this.messages(data.channel_id).upsert(data);
   }
   async editMessage(channelId, messageId, options) {
-    const data = await this.#rest.patch(Routes.message(channelId, messageId), options);
-    return this.messages(channelId).upsert(data);
+    return this.messages(channelId).upsert(await this.#rest.patch(Routes.message(channelId, messageId), options));
   }
   async deleteMessage(channelId, messageId) {
     await this.#rest.delete(Routes.message(channelId, messageId));
@@ -1496,11 +2538,12 @@ class ChannelManager extends Manager {
     return this.messages(channelId).delete(messageId);
   }
   async crosspostMessage(channelId, messageId) {
-    const data = await this.#rest.post(Routes.crosspostMessage(channelId, messageId));
-    return this.messages(channelId).upsert(data);
+    return this.messages(channelId).upsert(await this.#rest.post(Routes.crosspostMessage(channelId, messageId)));
   }
   async bulkDeleteMessages(channelId, messageIds) {
     const ids = [...messageIds];
+    if (ids.length < 2 || ids.length > 100)
+      throw new RangeError("bulkDelete requires between 2 and 100 message IDs.");
     await this.#rest.post(Routes.channelBulkDelete(channelId), {
       messages: ids
     });
@@ -1508,7 +2551,7 @@ class ChannelManager extends Manager {
       this.messages(channelId).delete(id);
   }
   async addReaction(channelId, messageId, emoji) {
-    await this.#rest.put(Routes.messageReactions(channelId, messageId, emoji));
+    await this.#rest.put(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
   }
   async fetchReactions(channelId, messageId, emoji, options = {}) {
     const params = new URLSearchParams;
@@ -1521,7 +2564,7 @@ class ChannelManager extends Manager {
     return data.map((user) => new User(user));
   }
   async removeOwnReaction(channelId, messageId, emoji) {
-    await this.#rest.delete(Routes.messageReactions(channelId, messageId, emoji) + "/@me");
+    await this.#rest.delete(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
   }
   async removeReaction(channelId, messageId, emoji, userId) {
     await this.#rest.delete(`${Routes.messageReactions(channelId, messageId, emoji)}/${userId}`);
@@ -1542,9 +2585,21 @@ class ChannelManager extends Manager {
   createThreadFromMessage(channelId, messageId, options) {
     return this.threads(channelId).createFromMessage(messageId, options);
   }
-  delete(channelId) {
-    this.#messageManagers.delete(channelId);
-    return super.delete(channelId);
+  async fetchPage(channelId, options = {}) {
+    const limit = Math.min(100, Math.max(1, options.limit ?? 50));
+    const messages = await this.fetchMessages(channelId, {
+      ...options,
+      limit
+    });
+    return {
+      messages,
+      before: messages[0]?.id,
+      after: messages[messages.length - 1]?.id,
+      hasMore: messages.length === limit
+    };
+  }
+  async bulkDelete(channelId, messageIds) {
+    return this.bulkDeleteMessages(channelId, messageIds);
   }
   clear() {
     this.#messageManagers.clear();
@@ -1555,126 +2610,6 @@ function isMessageQuery(value) {
   return typeof value === "object" && value !== null && !(Symbol.iterator in value);
 }
 
-// packages/types/src/index.ts
-var GatewayIntentBits = {
-  Guilds: 1 << 0,
-  GuildMembers: 1 << 1,
-  GuildModeration: 1 << 2,
-  GuildExpressions: 1 << 3,
-  GuildIntegrations: 1 << 4,
-  GuildWebhooks: 1 << 5,
-  GuildInvites: 1 << 6,
-  GuildVoiceStates: 1 << 7,
-  GuildPresences: 1 << 8,
-  GuildMessages: 1 << 9,
-  GuildMessageReactions: 1 << 10,
-  GuildMessageTyping: 1 << 11,
-  DirectMessages: 1 << 12,
-  DirectMessageReactions: 1 << 13,
-  DirectMessageTyping: 1 << 14,
-  MessageContent: 1 << 15,
-  GuildScheduledEvents: 1 << 16,
-  AutoModerationConfiguration: 1 << 20,
-  AutoModerationExecution: 1 << 21,
-  GuildMessagePolls: 1 << 24,
-  DirectMessagePolls: 1 << 25
-};
-var IntentBits = {
-  guild: 1 << 0,
-  guilds: 1 << 0,
-  guildMembers: 1 << 1,
-  guildModeration: 1 << 2,
-  guildBans: 1 << 2,
-  guildExpressions: 1 << 3,
-  guildEmojis: 1 << 3,
-  guildEmojisAndStickers: 1 << 3,
-  guildIntegrations: 1 << 4,
-  guildWebhooks: 1 << 5,
-  guildInvites: 1 << 6,
-  guildVoiceStates: 1 << 7,
-  guildPresences: 1 << 8,
-  guildMessages: 1 << 9,
-  guildMessage: 1 << 9,
-  guildMessageReactions: 1 << 10,
-  guildMessageTyping: 1 << 11,
-  directMessages: 1 << 12,
-  directMessageReactions: 1 << 13,
-  directMessageTyping: 1 << 14,
-  messageContent: 1 << 15,
-  guildScheduledEvents: 1 << 16,
-  autoModerationConfiguration: 1 << 20,
-  autoModerationExecution: 1 << 21,
-  guildMessagePolls: 1 << 24,
-  directMessagePolls: 1 << 25
-};
-var Intents = IntentBits;
-function resolveGatewayIntents(intents) {
-  if (typeof intents === "number")
-    return intents;
-  if (Array.isArray(intents)) {
-    return intents.reduce((acc, intent) => {
-      return acc | resolveGatewayIntents(intent);
-    }, 0);
-  }
-  if (typeof intents === "string") {
-    if (intents in GatewayIntentBits)
-      return GatewayIntentBits[intents];
-    if (intents in IntentBits)
-      return IntentBits[intents];
-    const lower = intents.charAt(0).toLowerCase() + intents.slice(1);
-    if (lower in IntentBits)
-      return IntentBits[lower];
-    const num = Number(intents);
-    if (!Number.isNaN(num))
-      return num;
-  }
-  return 0;
-}
-var MessageFlags = {
-  Crossposted: 1,
-  IsCrosspost: 2,
-  SuppressEmbeds: 4,
-  SourceMessageDeleted: 8,
-  Urgent: 16,
-  HasThread: 32,
-  Ephemeral: 64,
-  Loading: 128,
-  IsComponentsV2: 32768
-};
-var ChannelType = {
-  GuildText: 0,
-  DM: 1,
-  GuildVoice: 2,
-  GroupDM: 3,
-  GuildCategory: 4,
-  GuildAnnouncement: 5,
-  AnnouncementThread: 10,
-  PublicThread: 11,
-  PrivateThread: 12,
-  GuildStageVoice: 13,
-  GuildDirectory: 14,
-  GuildForum: 15,
-  GuildMedia: 16
-};
-var ApplicationCommandOptionType = {
-  SubCommand: 1,
-  SubCommandGroup: 2,
-  String: 3,
-  Integer: 4,
-  Boolean: 5,
-  User: 6,
-  Channel: 7,
-  Role: 8,
-  Mentionable: 9,
-  Number: 10,
-  Attachment: 11
-};
-var ApplicationCommandType = {
-  ChatInput: 1,
-  User: 2,
-  Message: 3
-};
-
 // packages/ws/src/index.ts
 var GatewayOpcodes = {
   Dispatch: 0,
@@ -1689,6 +2624,22 @@ var GatewayOpcodes = {
   Hello: 10,
   HeartbeatAck: 11
 };
+var GatewayCloseCodes = {
+  UnknownError: 4000,
+  UnknownOpcode: 4001,
+  DecodeError: 4002,
+  NotAuthenticated: 4003,
+  AuthenticationFailed: 4004,
+  AlreadyAuthenticated: 4005,
+  InvalidSeq: 4007,
+  RateLimited: 4008,
+  SessionTimedOut: 4009,
+  InvalidShard: 4010,
+  ShardingRequired: 4011,
+  InvalidAPIVersion: 4012,
+  InvalidIntents: 4013,
+  DisallowedIntents: 4014
+};
 class GatewayError extends Error {
   code;
   constructor(message, code, options) {
@@ -1722,6 +2673,8 @@ class Gateway {
   #rejectConnect;
   #listeners = new Map;
   #sendTimestamps = [];
+  ping = -1;
+  #decompressor;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Gateway token is required.");
@@ -1742,7 +2695,12 @@ class Gateway {
         browser: "Discord Android",
         device: "Discord Android"
       },
-      presence: { status: "online", activities: [], afk: false, since: null },
+      presence: {
+        status: "online",
+        activities: [],
+        afk: false,
+        since: null
+      },
       ...options
     };
     if (this.#options.shardId < 0 || this.#options.shardId >= this.#options.shardCount)
@@ -1757,10 +2715,13 @@ class Gateway {
       return this.#connectPromise;
     this.#closed = false;
     this.#setState("CONNECT" /* Connect */);
+    const connectURL = this.#options.compress ? url.includes("compress=") ? url : `${url}&compress=zlib-stream` : url;
+    if (this.#options.compress)
+      this.#initDecompressor();
     this.#connectPromise = new Promise((resolve, reject) => {
       this.#resolveConnect = resolve;
       this.#rejectConnect = reject;
-      this.#open(url);
+      this.#open(connectURL);
     });
     return this.#connectPromise;
   }
@@ -1796,12 +2757,15 @@ class Gateway {
   send(payload) {
     if (!payload || !Number.isInteger(payload.op))
       throw new TypeError("Gateway payload must contain an integer opcode.");
+    return this.#dispatch(payload, false);
+  }
+  #dispatch(payload, privileged) {
     if (this.#ws?.readyState !== WebSocket.OPEN)
       return false;
     const now = Date.now();
     while (this.#sendTimestamps.length && now - this.#sendTimestamps[0] >= 60000)
       this.#sendTimestamps.shift();
-    if (this.#sendTimestamps.length >= 115) {
+    if (!privileged && this.#sendTimestamps.length >= 115) {
       this.#emitError(new GatewayError("Gateway send rate budget exhausted."));
       return false;
     }
@@ -1872,7 +2836,11 @@ class Gateway {
     ws.addEventListener("message", (event) => {
       this.#lastMessageAt = Date.now();
       this.#zombieReported = false;
-      this.#message(ws, String(event.data));
+      if (this.#options.compress && event.data instanceof ArrayBuffer) {
+        this.#decompress(new Uint8Array(event.data)).then((text) => this.#message(ws, text)).catch((err) => this.#emitError(err));
+      } else {
+        this.#message(ws, String(event.data));
+      }
     });
     ws.addEventListener("close", (event) => this.#close(ws, event.code));
     ws.addEventListener("error", () => this.#emitError(new GatewayError("Gateway WebSocket error")));
@@ -1880,7 +2848,7 @@ class Gateway {
   #startZombieDetection() {
     if (this.#zombieTimer)
       clearInterval(this.#zombieTimer);
-    const interval = Math.max(1, Math.min(250, this.#options.heartbeatAckTimeout, this.#options.zombieTimeout / 2));
+    const interval = Math.max(1, Math.min(1000, this.#options.heartbeatAckTimeout, this.#options.zombieTimeout / 2));
     this.#zombieTimer = setInterval(() => {
       if (this.#closed || this.#ws?.readyState !== WebSocket.OPEN || this.#lastMessageAt === 0)
         return;
@@ -1931,18 +2899,24 @@ class Gateway {
         break;
       case GatewayOpcodes.HeartbeatAck:
         this.#heartbeatACK = true;
+        this.ping = Date.now() - this.#heartbeatSentAt;
         this.#clearHeartbeatAckTimer();
         this.#emit("heartbeatAck", payload.d);
         break;
       case GatewayOpcodes.Reconnect:
         ws.close(1001, "Server requested reconnect");
         break;
-      case GatewayOpcodes.InvalidSession:
-        this.#sessionId = undefined;
-        this.#sequence = null;
-        this.#emit("invalidSession", payload.d);
-        ws.close(1000, "Invalid session");
+      case GatewayOpcodes.InvalidSession: {
+        const resumable = payload.d === true;
+        if (!resumable) {
+          this.#sessionId = undefined;
+          this.#sequence = null;
+          this.#resumeURL = undefined;
+        }
+        this.#emit("invalidSession", resumable);
+        ws.close(resumable ? GatewayCloseCodes.UnknownError : 1000, resumable ? "Invalid session (resumable)" : "Invalid session");
         break;
+      }
     }
   }
   #handleDispatch(event, data) {
@@ -1957,7 +2931,14 @@ class Gateway {
       this.#attempt = 0;
       this.#setState("READY" /* Ready */);
       this.#emit("ready", data);
+    } else if (event === "RESUMED") {
+      this.#attempt = 0;
+      this.#setState("READY" /* Ready */);
+      this.#emit("resumed", data);
     }
+    this.#emit("RAW", { event: event ?? "UNKNOWN", data });
+    if (this.#closed)
+      return;
     this.#emit(event ?? "dispatch", data);
   }
   #handleHello(data) {
@@ -2031,12 +3012,12 @@ class Gateway {
   #sendHeartbeat() {
     this.#heartbeatACK = false;
     this.#heartbeatSentAt = Date.now();
-    if (!this.send({
+    if (!this.#dispatch({
       op: GatewayOpcodes.Heartbeat,
       d: this.#sequence,
       s: null,
       t: null
-    })) {
+    }, true)) {
       this.#emitError(new GatewayError("Unable to send Gateway heartbeat because the WebSocket is not open."));
       return;
     }
@@ -2069,14 +3050,23 @@ class Gateway {
     if (action === "identify") {
       this.#sequence = null;
       this.#sessionId = undefined;
+      this.#resumeURL = undefined;
     }
     this.#setState("RECONNECT" /* Reconnect */);
     this.#scheduleReconnect();
   }
   #closeAction(code) {
-    if ([4004, 4010, 4011, 4012, 4013, 4014].includes(code))
+    const fatal = [
+      GatewayCloseCodes.AuthenticationFailed,
+      GatewayCloseCodes.InvalidShard,
+      GatewayCloseCodes.ShardingRequired,
+      GatewayCloseCodes.InvalidAPIVersion,
+      GatewayCloseCodes.InvalidIntents,
+      GatewayCloseCodes.DisallowedIntents
+    ];
+    if (fatal.includes(code))
       return "stop";
-    if ([4007, 4009].includes(code))
+    if (code === GatewayCloseCodes.InvalidSeq || code === GatewayCloseCodes.SessionTimedOut)
       return "identify";
     return this.#sessionId && this.#sequence !== null ? "resume" : "identify";
   }
@@ -2089,7 +3079,7 @@ class Gateway {
       return;
     }
     const delay = Math.min(this.#options.reconnectMaxDelay, this.#options.reconnectBaseDelay * 2 ** this.#attempt++);
-    const jitter = Math.random() * Math.min(250, Math.max(1, delay * 0.25));
+    const jitter = Math.random() * Math.max(1, delay * 0.25);
     this.#reconnectTimer = setTimeout(() => {
       this.#reconnectTimer = undefined;
       this.#open(this.#resumeURL ?? "wss://gateway.discord.gg/?v=10&encoding=json");
@@ -2159,690 +3149,36 @@ class Gateway {
     this.state = next;
     this.#emit("stateChange", { previous, next });
   }
-}
-// packages/builders/src/embed.ts
-class EmbedBuilder {
-  #data = {};
-  setTitle(value) {
-    this.#data.title = validate(value, 256, "Embed title");
-    return this;
-  }
-  setDescription(value) {
-    this.#data.description = validate(value, 4096, "Embed description");
-    return this;
-  }
-  setURL(value) {
-    this.#data.url = url(value, "Embed URL");
-    return this;
-  }
-  setColor(value) {
-    if (!Number.isInteger(value) || value < 0 || value > 16777215)
-      throw new RangeError("Embed color must be an integer between 0 and 16777215.");
-    this.#data.color = value;
-    return this;
-  }
-  setTimestamp(value = new Date) {
-    const date = value instanceof Date ? value : new Date(value);
-    if (Number.isNaN(date.getTime()))
-      throw new RangeError("Embed timestamp must be a valid date.");
-    this.#data.timestamp = date.toISOString();
-    return this;
-  }
-  setFooter(value) {
-    this.#data.footer = {
-      text: validate(value.text, 2048, "Footer text"),
-      ...value.icon_url ? { icon_url: url(value.icon_url, "Footer icon URL") } : {}
-    };
-    return this;
-  }
-  setAuthor(value) {
-    this.#data.author = {
-      name: validate(value.name, 256, "Author name"),
-      ...value.url ? { url: url(value.url, "Author URL") } : {},
-      ...value.icon_url ? { icon_url: url(value.icon_url, "Author icon URL") } : {}
+  #initDecompressor() {
+    const ds = new DecompressionStream("deflate-raw");
+    this.#decompressor = {
+      writer: ds.writable.getWriter(),
+      reader: ds.readable.getReader()
     };
-    return this;
-  }
-  setThumbnail(value) {
-    const valueURL = typeof value === "string" ? value : value.url;
-    this.#data.thumbnail = { url: url(valueURL, "Thumbnail URL") };
-    return this;
-  }
-  setImage(value) {
-    const valueURL = typeof value === "string" ? value : value.url;
-    this.#data.image = { url: url(valueURL, "Image URL") };
-    return this;
-  }
-  addFields(...fields) {
-    if (!fields.length)
-      throw new TypeError("At least one embed field is required.");
-    const current = this.#data.fields ?? [];
-    if (current.length + fields.length > 25)
-      throw new RangeError("An embed cannot contain more than 25 fields.");
-    for (const field of fields) {
-      validate(field.name, 256, "Embed field name");
-      validate(field.value, 1024, "Embed field value");
-    }
-    this.#data.fields = [...current, ...fields.map((field) => ({ ...field }))];
-    return this;
-  }
-  setFields(fields) {
-    this.#data.fields = [];
-    return this.addFields(...fields);
-  }
-  spliceFields(index, deleteCount, ...fields) {
-    const current = [...this.#data.fields ?? []];
-    if (!Number.isInteger(index) || !Number.isInteger(deleteCount) || index < 0 || deleteCount < 0)
-      throw new RangeError("Field index and delete count must be non-negative integers.");
-    current.splice(index, deleteCount, ...fields);
-    if (current.length > 25)
-      throw new RangeError("An embed cannot contain more than 25 fields.");
-    this.#data.fields = current;
-    return this;
-  }
-  clearFields() {
-    delete this.#data.fields;
-    return this;
-  }
-  clearTitle() {
-    delete this.#data.title;
-    return this;
-  }
-  clearDescription() {
-    delete this.#data.description;
-    return this;
-  }
-  get data() {
-    return this.toJSON();
-  }
-  toJSON() {
-    return structuredClone(this.#data);
-  }
-}
-function validate(value, max, field) {
-  if (typeof value !== "string" || value.length === 0 || value.length > max)
-    throw new RangeError(`${field} must contain 1-${max} characters.`);
-  return value;
-}
-function url(value, field) {
-  try {
-    return new URL(value).toString();
-  } catch (error) {
-    throw new TypeError(`${field} must be a valid URL.`, { cause: error });
-  }
-}
-// packages/builders/src/components.ts
-var ComponentType = {
-  ActionRow: 1,
-  Button: 2,
-  StringSelect: 3,
-  TextInput: 4,
-  UserSelect: 5,
-  RoleSelect: 6,
-  MentionableSelect: 7,
-  ChannelSelect: 8
-};
-var ButtonStyle = {
-  Primary: 1,
-  Secondary: 2,
-  Success: 3,
-  Danger: 4,
-  Link: 5
-};
-class ActionRowBuilder {
-  #components = [];
-  addComponents(...components) {
-    if (!components.length)
-      throw new TypeError("At least one component is required.");
-    if (this.#components.length + components.length > 5)
-      throw new RangeError("An action row cannot contain more than 5 components.");
-    this.#components.push(...components);
-    return this;
-  }
-  clearComponents() {
-    this.#components.length = 0;
-    return this;
-  }
-  toJSON() {
-    return {
-      type: ComponentType.ActionRow,
-      components: this.#components.map((component) => component.toJSON())
-    };
-  }
-}
-
-class StringSelectBuilder {
-  #data = {
-    type: ComponentType.StringSelect
-  };
-  setCustomId(value) {
-    validateText(value, 100, "Component custom ID");
-    this.#data.custom_id = value;
-    return this;
-  }
-  setPlaceholder(value) {
-    validateText(value, 150, "Component placeholder");
-    this.#data.placeholder = value;
-    return this;
-  }
-  setMinValues(value) {
-    validateCount(value, "min_values", 0);
-    this.#data.min_values = value;
-    return this;
-  }
-  setMaxValues(value) {
-    validateCount(value, "max_values", 1);
-    this.#data.max_values = value;
-    return this;
-  }
-  setRequired(value = true) {
-    this.#data.required = value;
-    return this;
-  }
-  setDisabled(value = true) {
-    this.#data.disabled = value;
-    return this;
-  }
-  addOptions(...options) {
-    if (!options.length)
-      throw new TypeError("At least one select option is required.");
-    const current = this.#data.options ?? [];
-    if (current.length + options.length > 25)
-      throw new RangeError("A string select cannot contain more than 25 options.");
-    for (const option of options) {
-      validateText(option.label, 100, "Select option label");
-      validateText(option.value, 100, "Select option value");
-      if (option.description)
-        validateText(option.description, 100, "Select option description");
-    }
-    this.#data.options = [
-      ...current,
-      ...options.map((option) => ({ ...option }))
-    ];
-    return this;
-  }
-  toJSON() {
-    return structuredClone(this.#data);
-  }
-}
-
-class ButtonBuilder {
-  #data = {
-    type: ComponentType.Button,
-    style: ButtonStyle.Secondary
-  };
-  setStyle(style) {
-    this.#data.style = style;
-    if (style === ButtonStyle.Link)
-      delete this.#data.custom_id;
-    return this;
-  }
-  setCustomId(value) {
-    validateText(value, 100, "Button custom ID");
-    if (this.#data.style === ButtonStyle.Link)
-      throw new TypeError("Link buttons cannot use custom IDs.");
-    this.#data.custom_id = value;
-    return this;
-  }
-  setLabel(value) {
-    validateText(value, 80, "Button label");
-    this.#data.label = value;
-    return this;
-  }
-  setURL(value) {
-    validateText(value, 512, "Button URL");
-    let url2;
-    try {
-      url2 = new URL(value);
-    } catch (error) {
-      throw new TypeError("Button URL must be a valid URL.", { cause: error });
-    }
-    this.#data.style = ButtonStyle.Link;
-    delete this.#data.custom_id;
-    this.#data.url = url2.toString();
-    return this;
-  }
-  setEmoji(emoji) {
-    this.#data.emoji = typeof emoji === "string" ? { name: emoji } : { ...emoji };
-    return this;
-  }
-  setDisabled(value = true) {
-    this.#data.disabled = value;
-    return this;
-  }
-  toJSON() {
-    return structuredClone(this.#data);
-  }
-}
-function validateText(value, max, field) {
-  if (typeof value !== "string")
-    throw new TypeError(`${field} must be a string.`);
-  if (!value.trim())
-    throw new RangeError(`${field} must be a non-empty string.`);
-  if (value.length > max)
-    throw new RangeError(`${field} cannot exceed ${max} characters.`);
-}
-function validateCount(value, field, min, max = 25) {
-  if (!Number.isInteger(value) || value < min || value > max)
-    throw new RangeError(`${field} must be an integer between ${min} and ${max}.`);
-}
-// packages/builders/src/commands.ts
-var ApplicationCommandOptionType2 = {
-  Subcommand: 1,
-  SubcommandGroup: 2,
-  String: 3,
-  Integer: 4,
-  Boolean: 5,
-  User: 6,
-  Channel: 7,
-  Role: 8,
-  Mentionable: 9,
-  Number: 10,
-  Attachment: 11
-};
-
-class SlashCommandBuilder {
-  #data = { type: 1 };
-  setName(name) {
-    validateName(name, "Command name");
-    this.#data.name = name;
-    return this;
-  }
-  setDescription(description) {
-    validateText2(description, "Command description", 100);
-    this.#data.description = description;
-    return this;
-  }
-  setDMPermission(enabled) {
-    this.#data.dm_permission = enabled;
-    return this;
-  }
-  setNSFW(nsfw = true) {
-    this.#data.nsfw = nsfw;
-    return this;
-  }
-  setNsfw(nsfw = true) {
-    return this.setNSFW(nsfw);
-  }
-  setDefaultMemberPermissions(permissions) {
-    this.#data.default_member_permissions = permissions === null ? null : BigInt(permissions).toString();
-    return this;
-  }
-  setIntegrationTypes(...types) {
-    this.#data.integration_types = [...types];
-    return this;
-  }
-  addStringOption(configure) {
-    return this.addOption(configure(new StringOptionBuilder));
-  }
-  addIntegerOption(configure) {
-    return this.addOption(configure(new IntegerOptionBuilder));
-  }
-  addNumberOption(configure) {
-    return this.addOption(configure(new NumberOptionBuilder));
-  }
-  addBooleanOption(configure) {
-    return this.addOption(configure(new BooleanOptionBuilder));
   }
-  addUserOption(configure) {
-    return this.addOption(configure(new UserOptionBuilder));
-  }
-  addChannelOption(configure) {
-    return this.addOption(configure(new ChannelOptionBuilder));
-  }
-  addRoleOption(configure) {
-    return this.addOption(configure(new RoleOptionBuilder));
-  }
-  addMentionableOption(configure) {
-    return this.addOption(configure(new MentionableOptionBuilder));
-  }
-  addAttachmentOption(configure) {
-    return this.addOption(configure(new AttachmentOptionBuilder));
-  }
-  addSubcommand(configure) {
-    return this.addOption(configure(new SubcommandBuilder));
-  }
-  addSubcommandGroup(configure) {
-    return this.addOption(configure(new SubcommandGroupBuilder));
-  }
-  toJSON() {
-    return structuredClone(this.#data);
-  }
-  addOption(option) {
-    const options = this.#data.options ?? [];
-    if (options.length >= 25)
-      throw new RangeError("An application command cannot contain more than 25 options.");
-    const payload = option.toJSON();
-    if (options.some((existing) => existing.name === payload.name))
-      throw new RangeError(`Duplicate option name: ${String(payload.name)}.`);
-    if (payload.required === true && options.some((existing) => existing.required !== true))
-      throw new RangeError("Required application command options must be placed before optional options.");
-    options.push(payload);
-    this.#data.options = options;
-    return this;
-  }
-}
-
-class CommandOptionBuilder {
-  data;
-  constructor(type) {
-    this.data = { type };
-  }
-  setName(name) {
-    validateName(name, "Option name");
-    this.data.name = name;
-    return this;
-  }
-  setDescription(description) {
-    validateText2(description, "Option description", 100);
-    this.data.description = description;
-    return this;
-  }
-  setRequired(required = true) {
-    this.data.required = required;
-    return this;
-  }
-  setAutocomplete(enabled = true) {
-    this.data.autocomplete = enabled;
-    return this;
-  }
-  toJSON() {
-    return structuredClone(this.data);
-  }
-}
-
-class StringOptionBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.String);
-  }
-  addChoices(...choices) {
-    const current = this.data.choices ?? [];
-    if (!choices.length)
-      throw new TypeError("At least one choice is required.");
-    if (this.data.autocomplete === true)
-      throw new RangeError("Autocomplete options cannot define choices.");
-    if (current.length + choices.length > 25)
-      throw new RangeError("An option cannot contain more than 25 choices.");
-    for (const choice of choices) {
-      validateText2(choice.name, "Choice name", 100);
-      validateText2(choice.value, "Choice value", 100);
-    }
-    this.data.choices = [
-      ...current,
-      ...choices.map((choice) => ({ ...choice }))
-    ];
-    return this;
-  }
-  setMinLength(value) {
-    validateIntegerRange(value, 0, 6000, "min_length");
-    this.data.min_length = value;
-    return this;
-  }
-  setMaxLength(value) {
-    validateIntegerRange(value, 1, 6000, "max_length");
-    if (this.data.min_length !== undefined && this.data.min_length > value)
-      throw new RangeError("min_length cannot exceed max_length.");
-    this.data.max_length = value;
-    return this;
-  }
-}
-
-class IntegerOptionBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.Integer);
-  }
-  setMinValue(value) {
-    validateNumberRange(value, -9007199254740991, 9007199254740991, "min_value", true);
-    this.data.min_value = value;
-    return this;
-  }
-  setMaxValue(value) {
-    validateNumberRange(value, -9007199254740991, 9007199254740991, "max_value", true);
-    if (this.data.min_value !== undefined && this.data.min_value > value)
-      throw new RangeError("min_value cannot exceed max_value.");
-    this.data.max_value = value;
-    return this;
-  }
-  setAutocomplete(enabled = true) {
-    if (enabled && Array.isArray(this.data.choices) && this.data.choices.length)
-      throw new RangeError("Autocomplete options cannot define choices.");
-    this.data.autocomplete = enabled;
-    return this;
-  }
-  addChoices(...choices) {
-    const current = this.data.choices ?? [];
-    if (!choices.length)
-      throw new TypeError("At least one choice is required.");
-    if (this.data.autocomplete === true)
-      throw new RangeError("Autocomplete options cannot define choices.");
-    if (current.length + choices.length > 25)
-      throw new RangeError("An option cannot contain more than 25 choices.");
-    this.data.choices = [...current, ...choices];
-    return this;
-  }
-}
-
-class NumberOptionBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.Number);
-  }
-  setMinValue(value) {
-    validateNumberRange(value, -9007199254740991, 9007199254740991, "min_value", false);
-    this.data.min_value = value;
-    return this;
-  }
-  setMaxValue(value) {
-    validateNumberRange(value, -9007199254740991, 9007199254740991, "max_value", false);
-    if (this.data.min_value !== undefined && this.data.min_value > value)
-      throw new RangeError("min_value cannot exceed max_value.");
-    this.data.max_value = value;
-    return this;
-  }
-  setAutocomplete(enabled = true) {
-    if (enabled && Array.isArray(this.data.choices) && this.data.choices.length)
-      throw new RangeError("Autocomplete options cannot define choices.");
-    this.data.autocomplete = enabled;
-    return this;
-  }
-  addChoices(...choices) {
-    const current = this.data.choices ?? [];
-    if (!choices.length)
-      throw new TypeError("At least one choice is required.");
-    if (this.data.autocomplete === true)
-      throw new RangeError("Autocomplete options cannot define choices.");
-    if (current.length + choices.length > 25)
-      throw new RangeError("An option cannot contain more than 25 choices.");
-    this.data.choices = [...current, ...choices];
-    return this;
-  }
-}
-
-class BooleanOptionBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.Boolean);
-  }
-}
-
-class UserOptionBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.User);
-  }
-}
-
-class RoleOptionBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.Role);
-  }
-}
-
-class MentionableOptionBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.Mentionable);
-  }
-}
-
-class AttachmentOptionBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.Attachment);
-  }
-}
-
-class ChannelOptionBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.Channel);
-  }
-  addChannelTypes(...types) {
-    if (types.some((type) => !Number.isInteger(type) || type < 0))
-      throw new RangeError("Channel types must be non-negative integers.");
-    this.data.channel_types = [...new Set(types)];
-    return this;
-  }
-}
-
-class SubcommandBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.Subcommand);
-  }
-  addStringOption(configure) {
-    return this.addChildOption(configure(new StringOptionBuilder));
-  }
-  addIntegerOption(configure) {
-    return this.addChildOption(configure(new IntegerOptionBuilder));
-  }
-  addNumberOption(configure) {
-    return this.addChildOption(configure(new NumberOptionBuilder));
-  }
-  addBooleanOption(configure) {
-    return this.addChildOption(configure(new BooleanOptionBuilder));
-  }
-  addUserOption(configure) {
-    return this.addChildOption(configure(new UserOptionBuilder));
-  }
-  addChannelOption(configure) {
-    return this.addChildOption(configure(new ChannelOptionBuilder));
-  }
-  addRoleOption(configure) {
-    return this.addChildOption(configure(new RoleOptionBuilder));
-  }
-  addMentionableOption(configure) {
-    return this.addChildOption(configure(new MentionableOptionBuilder));
-  }
-  addAttachmentOption(configure) {
-    return this.addChildOption(configure(new AttachmentOptionBuilder));
-  }
-  addChildOption(option) {
-    const options = this.data.options ?? [];
-    if (options.length >= 25)
-      throw new RangeError("A subcommand cannot contain more than 25 options.");
-    const payload = option.toJSON();
-    if (options.some((existing) => existing.name === payload.name))
-      throw new RangeError(`Duplicate option name: ${String(payload.name)}.`);
-    if (payload.required === true && options.some((existing) => existing.required !== true))
-      throw new RangeError("Required subcommand options must be placed before optional options.");
-    if (options.some((existing) => existing.type === ApplicationCommandOptionType2.Subcommand))
-      throw new RangeError("Subcommands cannot contain nested subcommands.");
-    options.push(payload);
-    this.data.options = options;
-    return this;
-  }
-}
-
-class SubcommandGroupBuilder extends CommandOptionBuilder {
-  constructor() {
-    super(ApplicationCommandOptionType2.SubcommandGroup);
-  }
-  addSubcommand(configure) {
-    const options = this.data.options ?? [];
-    if (options.length >= 25)
-      throw new RangeError("A subcommand group cannot contain more than 25 subcommands.");
-    const payload = configure(new SubcommandBuilder).toJSON();
-    if (options.some((existing) => existing.name === payload.name))
-      throw new RangeError(`Duplicate subcommand name: ${String(payload.name)}.`);
-    if (payload.type !== ApplicationCommandOptionType2.Subcommand)
-      throw new TypeError("Subcommand group children must be subcommands.");
-    options.push(payload);
-    this.data.options = options;
-    return this;
-  }
-}
-function validateName(value, field) {
-  if (!/^[\p{L}\p{N}_-]{1,32}$/u.test(value) || value !== value.toLowerCase())
-    throw new RangeError(`${field} must contain 1-32 lowercase letters, numbers, underscores, or hyphens.`);
-}
-function validateText2(value, field, max) {
-  if (typeof value !== "string" || !value.trim() || value.length > max)
-    throw new RangeError(`${field} must contain 1-${max} characters.`);
-}
-function validateIntegerRange(value, minimum, maximum, field) {
-  if (!Number.isInteger(value) || value < minimum || value > maximum)
-    throw new RangeError(`${field} must be an integer between ${minimum} and ${maximum}.`);
-}
-function validateNumberRange(value, minimum, maximum, field, integerOnly = true) {
-  if (!Number.isFinite(value) || integerOnly && !Number.isInteger(value) || value < minimum || value > maximum)
-    throw new RangeError(`${field} must be ${integerOnly ? "an integer" : "a number"} between ${minimum} and ${maximum}.`);
-}
-// packages/core/src/collector.ts
-import { EventEmitter } from "events";
-
-class Collector extends EventEmitter {
-  collected = new Map;
-  options;
-  ended = false;
-  endReason;
-  totalProcessed = 0;
-  #timeoutTimer;
-  constructor(options = {}) {
-    super();
-    this.options = options;
-    if (options.time && options.time > 0) {
-      this.#timeoutTimer = setTimeout(() => {
-        this.stop("time");
-      }, options.time);
-    }
-  }
-  async handle(key, item) {
-    if (this.ended)
-      return false;
-    this.totalProcessed++;
-    if (this.options.filter) {
-      const passed = await this.options.filter(item);
-      if (!passed)
-        return false;
-    }
-    this.collected.set(key, item);
-    this.emit("collect", item);
-    if (this.options.max && this.collected.size >= this.options.max) {
-      this.stop("limit");
-      return true;
+  async#decompress(chunk) {
+    if (!this.#decompressor)
+      this.#initDecompressor();
+    const { writer, reader } = this.#decompressor;
+    await writer.write(chunk);
+    const parts = [];
+    while (true) {
+      const { done, value } = await Promise.race([
+        reader.read(),
+        new Promise((resolve) => setTimeout(() => resolve({ done: true, value: undefined }), 50))
+      ]);
+      if (done || !value)
+        break;
+      parts.push(value);
     }
-    if (this.options.maxProcessed && this.totalProcessed >= this.options.maxProcessed) {
-      this.stop("processedLimit");
-      return true;
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+      merged.set(p, offset);
+      offset += p.length;
     }
-    return true;
-  }
-  stop(reason = "user") {
-    if (this.ended)
-      return;
-    this.ended = true;
-    this.endReason = reason;
-    if (this.#timeoutTimer)
-      clearTimeout(this.#timeoutTimer);
-    this.emit("end", this.collected, reason);
-    this.removeAllListeners();
-  }
-  next() {
-    return new Promise((resolve, reject) => {
-      if (this.ended) {
-        return reject(new Error(`Collector already ended: ${this.endReason ?? "unknown"}`));
-      }
-      this.once("collect", (item) => {
-        resolve(item);
-      });
-      this.once("end", (_collected, reason) => {
-        reject(new Error(`Collector ended before item was collected: ${reason}`));
-      });
-    });
+    return new TextDecoder().decode(merged);
   }
 }
 
@@ -2869,6 +3205,9 @@ class EventEmitter2 {
     this.#listeners.get(event)?.delete(listener);
     return this;
   }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
   removeAllListeners(event) {
     if (event === undefined)
       this.#listeners.clear();
@@ -2892,11 +3231,11 @@ class EventEmitter2 {
     return true;
   }
   #handleError(event, error) {
-    if (event === "error")
+    if (event === "error" /* Error */)
       return;
     const normalized = error instanceof Error ? error : new Error(String(error), { cause: error });
     for (const listener of [
-      ...this.#listeners.get("error") ?? []
+      ...this.#listeners.get("error" /* Error */) ?? []
     ]) {
       try {
         listener(normalized);
@@ -2921,9 +3260,27 @@ class Client extends EventEmitter2 {
   user;
   readyAt;
   state = "idle";
+  get token() {
+    return this.state === "destroyed" ? null : this.options.token ?? null;
+  }
   get uptime() {
     return this.readyAt ? Date.now() - this.readyAt.getTime() : null;
   }
+  get ping() {
+    return this.#gateway.ping;
+  }
+  isReady() {
+    return this.state === "ready";
+  }
+  setPresence(data) {
+    return this.#gateway.setPresence(data);
+  }
+  setVoiceState(data) {
+    return this.#gateway.setVoiceState(data);
+  }
+  requestGuildMembers(data) {
+    return this.#gateway.requestGuildMembers(data);
+  }
   #gateway;
   #resourceContext;
   constructor(options) {
@@ -2941,7 +3298,15 @@ class Client extends EventEmitter2 {
       sendMessage: (channelId, options2) => this.channels.send(channelId, options2),
       editMessage: (channelId, messageId, options2) => this.channels.editMessage(channelId, messageId, options2),
       deleteMessage: (channelId, messageId) => this.channels.deleteMessage(channelId, messageId),
-      crosspostMessage: (channelId, messageId) => this.channels.crosspostMessage(channelId, messageId)
+      crosspostMessage: (channelId, messageId) => this.channels.crosspostMessage(channelId, messageId),
+      editChannel: (channelId, options2) => this.channels.edit(channelId, options2),
+      deleteChannel: (channelId) => this.channels.deleteChannel(channelId),
+      addReaction: (channelId, messageId, emoji) => this.channels.addReaction(channelId, messageId, emoji),
+      removeOwnReaction: (channelId, messageId, emoji) => this.channels.removeOwnReaction(channelId, messageId, emoji),
+      removeReaction: (channelId, messageId, emoji, userId) => this.channels.removeReaction(channelId, messageId, emoji, userId),
+      removeAllReactions: (channelId, messageId) => this.channels.removeAllReactions(channelId, messageId),
+      pinMessage: (channelId, messageId) => this.channels.pinMessage(channelId, messageId),
+      unpinMessage: (channelId, messageId) => this.channels.unpinMessage(channelId, messageId)
     };
     this.#gateway = new Gateway({
       token: options.token,
@@ -2956,233 +3321,242 @@ class Client extends EventEmitter2 {
       this.state = "ready";
       const appId = ready.application?.id ?? this.user.id;
       this.application.commands = new ApplicationCommandManager(this.rest, appId);
-      this.emit("ready", this.user);
+      this.emit("ready" /* Ready */, this.user);
+    });
+    this.#gateway.on("RESUMED", () => {
+      this.state = "ready";
+      this.emit("resumed" /* Resumed */);
     });
-    this.#gateway.on("open", () => this.emit("open"));
+    this.#gateway.on("invalidSession", (isRecoverable) => {
+      this.emit("invalidSession" /* InvalidSession */, isRecoverable);
+    });
+    this.#gateway.on("open", () => this.emit("open" /* Open */));
     this.#gateway.on("close", (data) => {
       if (this.state !== "destroyed")
         this.state = "idle";
-      this.emit("close", data);
+      this.emit("close" /* Close */, data);
     });
     this.#gateway.on("MESSAGE_CREATE", (data) => {
       const message = new Message(data, this.#resourceContext);
       this.channels.set(message.channelId, message.channel);
       this.users.set(message.author.id, message.author);
-      this.emit("messageCreate", message);
+      this.emit("messageCreate" /* MessageCreate */, message);
     });
     this.#gateway.on("MESSAGE_UPDATE", (data) => {
       const message = new Message(data, this.#resourceContext);
       this.channels.set(message.channelId, message.channel);
       this.users.set(message.author.id, message.author);
-      this.emit("messageUpdate", message);
+      this.emit("messageUpdate" /* MessageUpdate */, message);
     });
-    this.#gateway.on("MESSAGE_DELETE", (data) => this.emit("messageDelete", data));
-    this.#gateway.on("MESSAGE_DELETE_BULK", (data) => this.emit("messageDeleteBulk", data));
+    this.#gateway.on("MESSAGE_DELETE", (data) => this.emit("messageDelete" /* MessageDelete */, data));
+    this.#gateway.on("MESSAGE_DELETE_BULK", (data) => this.emit("messageDeleteBulk" /* MessageDeleteBulk */, data));
+    this.#gateway.on("MESSAGE_REACTION_ADD", (data) => this.emit("messageReactionAdd" /* MessageReactionAdd */, data));
+    this.#gateway.on("MESSAGE_REACTION_REMOVE", (data) => this.emit("messageReactionRemove" /* MessageReactionRemove */, data));
+    this.#gateway.on("MESSAGE_REACTION_REMOVE_ALL", (data) => this.emit("messageReactionRemoveAll" /* MessageReactionRemoveAll */, data));
+    this.#gateway.on("MESSAGE_REACTION_REMOVE_EMOJI", (data) => this.emit("messageReactionRemoveEmoji" /* MessageReactionRemoveEmoji */, data));
+    this.#gateway.on("MESSAGE_POLL_VOTE_ADD", (data) => this.emit("messagePollVoteAdd" /* MessagePollVoteAdd */, data));
+    this.#gateway.on("MESSAGE_POLL_VOTE_REMOVE", (data) => this.emit("messagePollVoteRemove" /* MessagePollVoteRemove */, data));
     this.#gateway.on("GUILD_CREATE", (data) => {
-      const guild = new Guild(data);
-      this.guilds.set(guild.id, guild);
       const payload = data;
+      if (payload.unavailable) {
+        this.emit("guildUnavailable" /* GuildUnavailable */, payload);
+        return;
+      }
+      const wasCached = this.guilds.has(payload.id);
+      const guild = new Guild(payload);
+      this.guilds.set(guild.id, guild);
       for (const member of payload.members ?? [])
         this.users.set(member.user.id, new User(member.user));
       for (const channelData of [
         ...payload.channels ?? [],
         ...payload.threads ?? []
-      ]) {
-        const channel = new Channel(channelData, this.#resourceContext);
-        this.channels.set(channel.id, channel);
-      }
-      this.emit("guildCreate", data);
+      ])
+        this.channels.set(channelData.id, new Channel(channelData, this.#resourceContext));
+      this.emit(wasCached ? "guildAvailable" /* GuildAvailable */ : "guildCreate" /* GuildCreate */, payload);
     });
     this.#gateway.on("GUILD_UPDATE", (data) => {
       const guild = new Guild(data);
       this.guilds.update(guild);
-      this.emit("guildUpdate", data);
+      this.emit("guildUpdate" /* GuildUpdate */, data);
     });
     this.#gateway.on("GUILD_DELETE", (data) => {
       const payload = data;
-      if (!payload.unavailable)
-        this.guilds.delete(payload.id);
-      this.emit("guildDelete", payload);
+      if (payload.unavailable) {
+        this.emit("guildUnavailable" /* GuildUnavailable */, payload);
+        return;
+      }
+      this.guilds.delete(payload.id);
+      this.emit("guildDelete" /* GuildDelete */, payload);
     });
+    this.#gateway.on("GUILD_MEMBER_ADD", (data) => {
+      const member = data;
+      this.users.set(member.user.id, new User(member.user));
+      this.emit("guildMemberAdd" /* GuildMemberAdd */, member);
+    });
+    this.#gateway.on("GUILD_MEMBER_UPDATE", (data) => {
+      const member = data;
+      this.users.set(member.user.id, new User(member.user));
+      this.emit("guildMemberUpdate" /* GuildMemberUpdate */, member);
+    });
+    this.#gateway.on("GUILD_MEMBER_REMOVE", (data) => this.emit("guildMemberRemove" /* GuildMemberRemove */, data));
+    this.#gateway.on("GUILD_MEMBERS_CHUNK", (data) => this.emit("guildMembersChunk" /* GuildMembersChunk */, data));
+    this.#gateway.on("GUILD_BAN_ADD", (data) => this.emit("guildBanAdd" /* GuildBanAdd */, data));
+    this.#gateway.on("GUILD_BAN_REMOVE", (data) => this.emit("guildBanRemove" /* GuildBanRemove */, data));
+    this.#gateway.on("GUILD_ROLE_CREATE", (data) => this.emit("guildRoleCreate" /* GuildRoleCreate */, data));
+    this.#gateway.on("GUILD_ROLE_UPDATE", (data) => this.emit("guildRoleUpdate" /* GuildRoleUpdate */, data));
+    this.#gateway.on("GUILD_ROLE_DELETE", (data) => this.emit("guildRoleDelete" /* GuildRoleDelete */, data));
+    this.#gateway.on("GUILD_EMOJIS_UPDATE", (data) => this.emit("guildEmojisUpdate" /* GuildEmojisUpdate */, data));
+    this.#gateway.on("GUILD_STICKERS_UPDATE", (data) => this.emit("guildStickersUpdate" /* GuildStickersUpdate */, data));
+    this.#gateway.on("GUILD_INTEGRATIONS_UPDATE", (data) => this.emit("guildIntegrationsUpdate" /* GuildIntegrationsUpdate */, data));
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_CREATE", (data) => this.emit("guildScheduledEventCreate" /* GuildScheduledEventCreate */, data));
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_UPDATE", (data) => this.emit("guildScheduledEventUpdate" /* GuildScheduledEventUpdate */, data));
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_DELETE", (data) => this.emit("guildScheduledEventDelete" /* GuildScheduledEventDelete */, data));
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_USER_ADD", (data) => this.emit("guildScheduledEventUserAdd" /* GuildScheduledEventUserAdd */, data));
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_USER_REMOVE", (data) => this.emit("guildScheduledEventUserRemove" /* GuildScheduledEventUserRemove */, data));
+    this.#gateway.on("AUTO_MODERATION_RULE_CREATE", (data) => this.emit("autoModerationRuleCreate" /* AutoModerationRuleCreate */, data));
+    this.#gateway.on("AUTO_MODERATION_RULE_UPDATE", (data) => this.emit("autoModerationRuleUpdate" /* AutoModerationRuleUpdate */, data));
+    this.#gateway.on("AUTO_MODERATION_RULE_DELETE", (data) => this.emit("autoModerationRuleDelete" /* AutoModerationRuleDelete */, data));
+    this.#gateway.on("AUTO_MODERATION_ACTION_EXECUTION", (data) => this.emit("autoModerationActionExecution" /* AutoModerationActionExecution */, data));
     this.#gateway.on("CHANNEL_CREATE", (data) => {
       const channel = new Channel(data, this.#resourceContext);
       this.channels.update(channel);
-      this.emit("channelCreate", channel);
+      this.emit("channelCreate" /* ChannelCreate */, channel);
     });
     this.#gateway.on("CHANNEL_UPDATE", (data) => {
       const channel = new Channel(data, this.#resourceContext);
       this.channels.update(channel);
-      this.emit("channelUpdate", channel);
+      this.emit("channelUpdate" /* ChannelUpdate */, channel);
     });
     this.#gateway.on("CHANNEL_DELETE", (data) => {
       const payload = data;
       this.channels.delete(payload.id);
-      this.emit("channelDelete", payload);
+      this.emit("channelDelete" /* ChannelDelete */, payload);
     });
+    this.#gateway.on("CHANNEL_PINS_UPDATE", (data) => this.emit("channelPinsUpdate" /* ChannelPinsUpdate */, data));
     this.#gateway.on("THREAD_CREATE", (data) => {
       const channel = new Channel(data, this.#resourceContext);
       this.channels.update(channel);
-      this.emit("threadCreate", channel);
+      this.emit("threadCreate" /* ThreadCreate */, channel);
     });
     this.#gateway.on("THREAD_UPDATE", (data) => {
       const channel = new Channel(data, this.#resourceContext);
       this.channels.update(channel);
-      this.emit("threadUpdate", channel);
+      this.emit("threadUpdate" /* ThreadUpdate */, channel);
     });
     this.#gateway.on("THREAD_DELETE", (data) => {
       const payload = data;
       this.channels.delete(payload.id);
-      this.emit("threadDelete", payload);
+      this.emit("threadDelete" /* ThreadDelete */, payload);
     });
-    this.#gateway.on("GUILD_MEMBER_ADD", (data) => {
-      const member = data;
-      this.users.set(member.user.id, new User(member.user));
-      this.emit("guildMemberAdd", member);
-    });
-    this.#gateway.on("GUILD_MEMBER_UPDATE", (data) => {
-      const member = data;
-      this.users.set(member.user.id, new User(member.user));
-      this.emit("guildMemberUpdate", member);
-    });
-    this.#gateway.on("GUILD_MEMBER_REMOVE", (data) => this.emit("guildMemberRemove", data));
-    this.#gateway.on("MESSAGE_REACTION_ADD", (data) => this.emit("messageReactionAdd", data));
-    this.#gateway.on("MESSAGE_REACTION_REMOVE", (data) => this.emit("messageReactionRemove", data));
-    this.#gateway.on("MESSAGE_REACTION_REMOVE_ALL", (data) => this.emit("messageReactionRemoveAll", data));
-    this.#gateway.on("INTERACTION_CREATE", (data) => this.emit("interactionCreate", createInteraction(this, data)));
-    this.#gateway.on("GUILD_ROLE_CREATE", (data) => this.emit("guildRoleCreate", data));
-    this.#gateway.on("GUILD_ROLE_UPDATE", (data) => this.emit("guildRoleUpdate", data));
-    this.#gateway.on("GUILD_ROLE_DELETE", (data) => this.emit("guildRoleDelete", data));
-    this.#gateway.on("GUILD_BAN_ADD", (data) => this.emit("guildBanAdd", data));
-    this.#gateway.on("GUILD_BAN_REMOVE", (data) => this.emit("guildBanRemove", data));
-    this.#gateway.on("GUILD_EMOJIS_UPDATE", (data) => this.emit("guildEmojisUpdate", data));
-    for (const event of [
-      "READY",
-      "MESSAGE_CREATE",
-      "MESSAGE_UPDATE",
-      "MESSAGE_DELETE",
-      "MESSAGE_DELETE_BULK",
-      "GUILD_CREATE",
-      "GUILD_UPDATE",
-      "GUILD_DELETE",
-      "CHANNEL_CREATE",
-      "CHANNEL_UPDATE",
-      "CHANNEL_DELETE",
-      "THREAD_CREATE",
-      "THREAD_UPDATE",
-      "THREAD_DELETE",
-      "GUILD_MEMBER_ADD",
-      "GUILD_MEMBER_UPDATE",
-      "GUILD_MEMBER_REMOVE",
-      "MESSAGE_REACTION_ADD",
-      "MESSAGE_REACTION_REMOVE",
-      "MESSAGE_REACTION_REMOVE_ALL",
-      "INTERACTION_CREATE",
-      "GUILD_ROLE_CREATE",
-      "GUILD_ROLE_UPDATE",
-      "GUILD_ROLE_DELETE",
-      "GUILD_BAN_ADD",
-      "GUILD_BAN_REMOVE",
-      "GUILD_EMOJIS_UPDATE"
-    ])
-      this.#gateway.on(event, (data) => this.emit("raw", { event, data }));
-    this.#gateway.on("error", (data) => this.emit("error", data));
-  }
-  isReady() {
-    return this.state === "ready" && this.user !== undefined && this.readyAt !== undefined;
-  }
-  async login() {
+    this.#gateway.on("THREAD_LIST_SYNC", (data) => this.emit("threadListSync" /* ThreadListSync */, data));
+    this.#gateway.on("THREAD_MEMBERS_UPDATE", (data) => this.emit("threadMembersUpdate" /* ThreadMembersUpdate */, data));
+    this.#gateway.on("THREAD_MEMBER_UPDATE", (data) => this.emit("threadMemberUpdate" /* ThreadMemberUpdate */, data));
+    this.#gateway.on("STAGE_INSTANCE_CREATE", (data) => this.emit("stageInstanceCreate" /* StageInstanceCreate */, data));
+    this.#gateway.on("STAGE_INSTANCE_UPDATE", (data) => this.emit("stageInstanceUpdate" /* StageInstanceUpdate */, data));
+    this.#gateway.on("STAGE_INSTANCE_DELETE", (data) => this.emit("stageInstanceDelete" /* StageInstanceDelete */, data));
+    this.#gateway.on("INVITE_CREATE", (data) => this.emit("inviteCreate" /* InviteCreate */, data));
+    this.#gateway.on("INVITE_DELETE", (data) => this.emit("inviteDelete" /* InviteDelete */, data));
+    this.#gateway.on("WEBHOOKS_UPDATE", (data) => this.emit("webhooksUpdate" /* WebhooksUpdate */, data));
+    this.#gateway.on("VOICE_STATE_UPDATE", (data) => this.emit("voiceStateUpdate" /* VoiceStateUpdate */, data));
+    this.#gateway.on("VOICE_SERVER_UPDATE", (data) => this.emit("voiceServerUpdate" /* VoiceServerUpdate */, data));
+    this.#gateway.on("PRESENCE_UPDATE", (data) => this.emit("presenceUpdate" /* PresenceUpdate */, data));
+    this.#gateway.on("TYPING_START", (data) => this.emit("typingStart" /* TypingStart */, data));
+    this.#gateway.on("INTERACTION_CREATE", (data) => this.emit("interactionCreate" /* InteractionCreate */, createInteraction(this, data)));
+    this.#gateway.on("RAW", (data) => this.emit("raw" /* Raw */, data));
+    this.#gateway.on("error", (error) => this.emit("error" /* Error */, error));
+  }
+  async login(token) {
     if (this.state === "destroyed")
       throw new Error("Cannot login a destroyed client.");
-    if (this.state === "connecting" || this.state === "ready")
-      return;
-    this.state = "connecting";
-    try {
-      this.user = await this.rest.get(Routes.user());
-      this.users.set(this.user.id, new User(this.user));
-      await this.#gateway.connect();
-    } catch (error) {
-      this.state = "idle";
-      throw error;
+    if (token?.trim()) {
+      this.rest.setToken(token);
+      this.options.token = token;
     }
+    const usedToken = this.options.token;
+    if (!usedToken?.trim())
+      throw new TypeError("A bot token is required to log in.");
+    this.state = "connecting";
+    await this.#gateway.connect();
+    return usedToken;
   }
   destroy() {
-    if (this.state === "destroyed")
-      return;
-    this.#gateway.close();
-    this.users.clear();
-    this.guilds.clear();
-    this.channels.clear();
     this.state = "destroyed";
-    this.readyAt = undefined;
-    this.user = undefined;
+    this.#gateway.close();
   }
   postInteractionResponse(id, token, response) {
     return this.rest.post(Routes.interactionCallback(id, token), response.toJSON());
   }
   editInteractionReply(token, data) {
-    if (!this.user?.id)
-      throw new Error("Client user is unavailable; login is required.");
+    if (!this.user)
+      return Promise.reject(new Error("Client is unauthenticated."));
     return this.rest.patch(Routes.interactionOriginalResponse(this.user.id, token), data);
   }
-  async deleteInteractionReply(token) {
-    if (!this.user?.id)
-      throw new Error("Client user is unavailable; login is required.");
-    await this.rest.delete(Routes.interactionOriginalResponse(this.user.id, token));
-  }
-  setPresence(presence) {
-    return this.#gateway.setPresence(presence);
+  deleteInteractionReply(token) {
+    if (!this.user)
+      return Promise.reject(new Error("Client is unauthenticated."));
+    return this.rest.delete(Routes.interactionOriginalResponse(this.user.id, token));
   }
   followUpInteraction(token, data) {
-    if (!this.user?.id)
-      throw new Error("Client user is unavailable; login is required.");
-    return this.rest.post(Routes.webhook(this.user.id, token), data);
+    if (!this.user)
+      return Promise.reject(new Error("Client is unauthenticated."));
+    return this.rest.post(`/webhooks/${this.user.id}/${token}`, data);
+  }
+  fetchWebhook(id, token) {
+    return this.rest.get(token ? `/webhooks/${id}/${token}` : `/webhooks/${id}`);
+  }
+  fetchGuildPreview(guildId) {
+    return this.rest.get(`/guilds/${guildId}/preview`);
+  }
+  fetchVoiceRegions() {
+    return this.rest.get("/voice/regions");
+  }
+  fetchInvite(code, options) {
+    const query = new URLSearchParams;
+    if (options?.withCounts)
+      query.set("with_counts", "true");
+    if (options?.withExpiration)
+      query.set("with_expiration", "true");
+    if (options?.guildScheduledEventId)
+      query.set("guild_scheduled_event_id", options.guildScheduledEventId);
+    const qs = query.toString();
+    return this.rest.get(`/invites/${code}${qs ? `?${qs}` : ""}`);
+  }
+  fetchSticker(id) {
+    return this.rest.get(`/stickers/${id}`);
+  }
+  fetchPremiumStickerPacks() {
+    return this.rest.get(`/sticker-packs`);
+  }
+  fetchGuildTemplate(code) {
+    return this.rest.get(`/guilds/templates/${code}`);
+  }
+  generateInvite(options) {
+    if (!this.user)
+      throw new Error("Client must be ready to generate invite.");
+    const params = new URLSearchParams({
+      client_id: this.user.id,
+      scopes: (options?.scopes ?? ["bot"]).join(" ")
+    });
+    if (options?.permissions) {
+      params.set("permissions", String(options.permissions));
+    }
+    return `https://discord.com/api/oauth2/authorize?${params.toString()}`;
   }
 }
 export {
-  ActionRowBuilder,
-  ApplicationCommandManager,
-  ApplicationCommandOptionType,
-  ApplicationCommandType,
-  ButtonBuilder,
-  Channel,
-  ChannelManager,
-  ChannelType,
   Client,
-  Collection,
+  ClientEvent,
   Collector,
-  EmbedBuilder,
-  Gateway,
-  GatewayError,
   GatewayIntentBits,
-  GatewayOpcodes,
-  Guild,
-  GuildManager,
   IntentBits,
   Intents,
-  Manager,
-  Message,
-  MessageCreateOptions,
-  MessageEditOptions,
-  MessageFetchOptions,
-  MessageFlags,
-  MessageThreadOptions,
   Permission,
   PermissionFlagsBits,
   PermissionOverwriteType,
   PermissionSet,
   Permissions,
   PermissionsBitField,
-  REST,
-  RESTError,
-  ReactionFetchOptions,
-  ResourceManager,
-  Routes,
-  SlashCommandBuilder,
-  StringOptionBuilder,
-  StringSelectBuilder,
-  User,
-  UserManager,
   resolveGatewayIntents
 };
 
-//# debugId=8E6F3C716D06EF5664756E2164756E21
+//# debugId=5F8825194034E27864756E2164756E21