lunibee 0.1.8 → 0.2.1

package/dist/core/index.js

@@ -53,8 +53,11 @@ var Permission = {
   createEvents: 1n << 44n,
   useExternalSounds: 1n << 45n,
   sendVoiceMessages: 1n << 46n,
+  setVoiceChannelStatus: 1n << 48n,
   sendPolls: 1n << 49n,
-  useExternalApps: 1n << 50n
+  useExternalApps: 1n << 50n,
+  pinMessages: 1n << 51n,
+  bypassSlowmode: 1n << 52n
 };
 var Permissions = {
   CreateInstantInvite: 1n << 0n,
@@ -104,8 +107,11 @@ var Permissions = {
   CreateEvents: 1n << 44n,
   UseExternalSounds: 1n << 45n,
   SendVoiceMessages: 1n << 46n,
+  SetVoiceChannelStatus: 1n << 48n,
   SendPolls: 1n << 49n,
-  UseExternalApps: 1n << 50n
+  UseExternalApps: 1n << 50n,
+  PinMessages: 1n << 51n,
+  BypassSlowmode: 1n << 52n
 };
 var PermissionFlagsBits = {
   CreateInstantInvite: 1n << 0n,
@@ -155,8 +161,11 @@ var PermissionFlagsBits = {
   CreateEvents: 1n << 44n,
   UseExternalSounds: 1n << 45n,
   SendVoiceMessages: 1n << 46n,
+  SetVoiceChannelStatus: 1n << 48n,
   SendPolls: 1n << 49n,
-  UseExternalApps: 1n << 50n
+  UseExternalApps: 1n << 50n,
+  PinMessages: 1n << 51n,
+  BypassSlowmode: 1n << 52n
 };
 
 class PermissionSet {
@@ -358,6 +367,10 @@ class PermissionSet {
     }
     return false;
   }
+  missing(...permissions) {
+    const wanted = new PermissionSet(permissions);
+    return wanted.toArray().filter((name) => !this.has(name));
+  }
   add(...permissions) {
     let bitfield = this.bitfield;
     for (let i = 0;i < permissions.length; i++) {
@@ -383,6 +396,11 @@ class PermissionSet {
   toArray() {
     return Object.keys(Permission).filter((permission) => this.has(permission));
   }
+  static #renamed = {
+    ManageEmojisAndStickers: "ManageGuildExpressions",
+    ManageEmojis: "ManageGuildExpressions",
+    UseSlashCommands: "UseApplicationCommands"
+  };
   #resolve(permission) {
     if (typeof permission === "bigint")
       return permission;
@@ -397,6 +415,9 @@ class PermissionSet {
       return bit;
     }
     if (typeof permission === "string") {
+      const renamed = PermissionSet.#renamed[permission];
+      if (renamed)
+        return this.#resolve(renamed);
       if (permission in Permission)
         return Permission[permission];
       if (permission in Permissions)
@@ -419,6 +440,35 @@ class PermissionsBitField extends PermissionSet {
     super(value);
   }
 }
+var ALL_PERMISSIONS = Object.values(Permission).reduce((bits, bit) => bits | bit, 0n);
+var bits = (value) => new PermissionSet(value).bitfield;
+function computePermissions(context) {
+  if (context.ownerId !== undefined && context.ownerId === context.memberId)
+    return new PermissionSet(ALL_PERMISSIONS);
+  const roles = new Map(context.roles.map((role) => [role.id, role]));
+  let base = bits(roles.get(context.guildId)?.permissions ?? 0n);
+  for (const id of context.memberRoleIds)
+    base |= bits(roles.get(id)?.permissions ?? 0n);
+  if (base & Permission.administrator)
+    return new PermissionSet(ALL_PERMISSIONS);
+  const overwrites = context.overwrites ?? [];
+  const everyone = overwrites.find((o) => o.id === context.guildId);
+  if (everyone)
+    base = base & ~bits(everyone.deny) | bits(everyone.allow);
+  const memberRoles = new Set(context.memberRoleIds);
+  let allow = 0n;
+  let deny = 0n;
+  for (const overwrite of overwrites)
+    if (overwrite.type === 0 /* Role */ && overwrite.id !== context.guildId && memberRoles.has(overwrite.id)) {
+      allow |= bits(overwrite.allow);
+      deny |= bits(overwrite.deny);
+    }
+  base = base & ~deny | allow;
+  const member = overwrites.find((o) => o.type === 1 /* Member */ && o.id === context.memberId);
+  if (member)
+    base = base & ~bits(member.deny) | bits(member.allow);
+  return new PermissionSet(base);
+}
 // packages/core/src/events.ts
 var ClientEvent;
 ((ClientEvent) => {
@@ -455,6 +505,13 @@ var ClientEvent;
   ClientEvent["GuildRoleDelete"] = "guildRoleDelete";
   ClientEvent["GuildEmojisUpdate"] = "guildEmojisUpdate";
   ClientEvent["GuildStickersUpdate"] = "guildStickersUpdate";
+  ClientEvent["EntitlementCreate"] = "entitlementCreate";
+  ClientEvent["EntitlementUpdate"] = "entitlementUpdate";
+  ClientEvent["EntitlementDelete"] = "entitlementDelete";
+  ClientEvent["SoundboardSoundCreate"] = "soundboardSoundCreate";
+  ClientEvent["SoundboardSoundUpdate"] = "soundboardSoundUpdate";
+  ClientEvent["SoundboardSoundDelete"] = "soundboardSoundDelete";
+  ClientEvent["SoundboardSoundsUpdate"] = "soundboardSoundsUpdate";
   ClientEvent["GuildIntegrationsUpdate"] = "guildIntegrationsUpdate";
   ClientEvent["GuildScheduledEventCreate"] = "guildScheduledEventCreate";
   ClientEvent["GuildScheduledEventUpdate"] = "guildScheduledEventUpdate";
@@ -497,6 +554,9 @@ class Collector extends EventEmitter {
   endReason;
   totalProcessed = 0;
   #timeoutTimer;
+  #idleTimer;
+  #onAbort = () => this.stop("abort");
+  #cleanup = [];
   constructor(options = {}) {
     super();
     this.options = options;
@@ -505,6 +565,27 @@ class Collector extends EventEmitter {
         this.stop("time");
       }, options.time);
     }
+    this.#resetIdle();
+    if (options.signal?.aborted)
+      this.stop("abort");
+    else
+      options.signal?.addEventListener("abort", this.#onAbort, {
+        once: true
+      });
+  }
+  onDispose(cleanup) {
+    if (this.ended)
+      cleanup();
+    else
+      this.#cleanup.push(cleanup);
+    return this;
+  }
+  #resetIdle() {
+    if (!this.options.idle || this.options.idle <= 0)
+      return;
+    if (this.#idleTimer)
+      clearTimeout(this.#idleTimer);
+    this.#idleTimer = setTimeout(() => this.stop("idle"), this.options.idle);
   }
   async handle(key, item) {
     if (this.ended)
@@ -522,6 +603,7 @@ class Collector extends EventEmitter {
       return false;
     }
     this.collected.set(key, item);
+    this.#resetIdle();
     this.emit("collect", item);
     if (this.options.max && this.collected.size >= this.options.max) {
       this.stop("limit");
@@ -540,9 +622,53 @@ class Collector extends EventEmitter {
     this.endReason = reason;
     if (this.#timeoutTimer)
       clearTimeout(this.#timeoutTimer);
+    if (this.#idleTimer)
+      clearTimeout(this.#idleTimer);
+    this.options.signal?.removeEventListener("abort", this.#onAbort);
+    for (const cleanup of this.#cleanup.splice(0)) {
+      try {
+        cleanup();
+      } catch {}
+    }
     this.emit("end", this.collected, reason);
     this.removeAllListeners();
   }
+  wait() {
+    if (this.ended)
+      return Promise.resolve(this.collected);
+    return new Promise((resolve) => this.once("end", (collected) => resolve(collected)));
+  }
+  async* [Symbol.asyncIterator]() {
+    const queue = [];
+    let wake;
+    const onCollect = (item) => {
+      queue.push(item);
+      wake?.();
+    };
+    const onEnd = () => wake?.();
+    if (!this.ended) {
+      this.on("collect", onCollect);
+      this.on("end", onEnd);
+    }
+    try {
+      for (;; ) {
+        if (queue.length > 0) {
+          yield queue.shift();
+          continue;
+        }
+        if (this.ended)
+          return;
+        await new Promise((resolve) => wake = resolve);
+        wake = undefined;
+      }
+    } finally {
+      this.off("collect", onCollect);
+      this.off("end", onEnd);
+    }
+  }
+  [Symbol.dispose]() {
+    this.stop("disposed");
+  }
   next() {
     return new Promise((resolve, reject) => {
       if (this.ended) {
@@ -686,7 +812,340 @@ var InteractionResponseType = {
   Modal: 9
 };
 // packages/collection/src/index.ts
+class RecencyList {
+  #nodes = new Map;
+  #oldest;
+  #newest;
+  get size() {
+    return this.#nodes.size;
+  }
+  oldest() {
+    return this.#oldest?.key;
+  }
+  touch(key) {
+    const node = this.#nodes.get(key);
+    if (node)
+      return this.#moveNewest(node);
+    const created = { key, older: this.#newest };
+    if (this.#newest)
+      this.#newest.newer = created;
+    else
+      this.#oldest = created;
+    this.#newest = created;
+    this.#nodes.set(key, created);
+  }
+  promote(key) {
+    const node = this.#nodes.get(key);
+    if (node)
+      this.#moveNewest(node);
+  }
+  delete(key) {
+    const node = this.#nodes.get(key);
+    if (!node)
+      return false;
+    this.#unlink(node);
+    this.#nodes.delete(key);
+    return true;
+  }
+  clear() {
+    this.#nodes.clear();
+    this.#oldest = this.#newest = undefined;
+  }
+  #unlink(node) {
+    if (node.older)
+      node.older.newer = node.newer;
+    else
+      this.#oldest = node.newer;
+    if (node.newer)
+      node.newer.older = node.older;
+    else
+      this.#newest = node.older;
+    node.older = node.newer = undefined;
+  }
+  #moveNewest(node) {
+    if (node === this.#newest)
+      return;
+    this.#unlink(node);
+    node.older = this.#newest;
+    if (this.#newest)
+      this.#newest.newer = node;
+    else
+      this.#oldest = node;
+    this.#newest = node;
+  }
+}
+function assertTTL(ttl) {
+  if (ttl !== undefined && (!Number.isFinite(ttl) || ttl <= 0))
+    throw new RangeError("TTL must be a positive number, or omitted.");
+}
+
 class Collection extends Map {
+  #ttl;
+  #maxSize;
+  #onEvict;
+  #expiry = new Map;
+  #lru = new RecencyList;
+  #stats = {
+    hits: 0,
+    misses: 0,
+    expired: 0,
+    evicted: 0
+  };
+  #heap = [];
+  #timer;
+  #armedFor = Infinity;
+  constructor(entries, options = {}) {
+    super();
+    assertTTL(options.ttl);
+    if (options.maxSize !== undefined && (!Number.isInteger(options.maxSize) || options.maxSize <= 0))
+      throw new RangeError("maxSize must be a positive integer.");
+    this.#ttl = options.ttl;
+    this.#maxSize = options.maxSize;
+    this.#onEvict = options.onEvict;
+    if (entries)
+      for (const [key, value] of entries)
+        this.set(key, value);
+  }
+  set(key, value, ttl) {
+    assertTTL(ttl);
+    const window = ttl ?? this.#ttl;
+    if (this.#maxSize !== undefined) {
+      this.#lru.touch(key);
+    }
+    super.set(key, value);
+    if (window !== undefined)
+      this.#schedule(key, window);
+    else if (this.#expiry.size > 0)
+      this.#expiry.delete(key);
+    this.#enforceCap();
+    return this;
+  }
+  setWithoutTTL(key, value) {
+    if (this.#expiry.size > 0)
+      this.#expiry.delete(key);
+    if (this.#lru.size > 0)
+      this.#lru.delete(key);
+    super.set(key, value);
+    return this;
+  }
+  get(key) {
+    if (this.#expireIfDue(key)) {
+      this.#stats.misses++;
+      return;
+    }
+    const value = super.get(key);
+    if (value === undefined && !super.has(key)) {
+      this.#stats.misses++;
+      return;
+    }
+    this.#stats.hits++;
+    const expiry = this.#expiry.get(key);
+    if (expiry)
+      expiry.deadline = Date.now() + expiry.window;
+    this.#lru.promote(key);
+    return value;
+  }
+  peek(key) {
+    if (!this.#expireIfDue(key) && super.has(key)) {
+      this.#stats.hits++;
+      return super.get(key);
+    }
+    this.#stats.misses++;
+    return;
+  }
+  get stats() {
+    return { ...this.#stats };
+  }
+  has(key) {
+    return !this.#expireIfDue(key) && super.has(key);
+  }
+  delete(key) {
+    if (this.#expireIfDue(key))
+      return false;
+    this.#expiry.delete(key);
+    this.#lru.delete(key);
+    return super.delete(key);
+  }
+  clear() {
+    super.clear();
+    this.#expiry.clear();
+    this.#lru.clear();
+    this.#heap.length = 0;
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+    this.#armedFor = Infinity;
+  }
+  get size() {
+    this.purge();
+    return super.size;
+  }
+  entries() {
+    this.purge();
+    return super.entries();
+  }
+  keys() {
+    this.purge();
+    return super.keys();
+  }
+  values() {
+    this.purge();
+    return super.values();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  forEach(callback, thisArg) {
+    this.purge();
+    super.forEach(callback, thisArg);
+  }
+  ttlRemaining(key) {
+    if (this.#expireIfDue(key))
+      return;
+    const expiry = this.#expiry.get(key);
+    return expiry && Math.max(0, expiry.deadline - Date.now());
+  }
+  purge() {
+    if (this.#expiry.size === 0)
+      return 0;
+    const now = Date.now();
+    let removed = 0;
+    const dropped = [];
+    while (this.#nextDeadline() <= now) {
+      const due = this.#heapPop();
+      dropped.push([due.key, super.get(due.key)]);
+      this.#remove(due.key);
+      removed++;
+    }
+    this.#stats.expired += removed;
+    this.#rearm();
+    for (const [key, value] of dropped)
+      this.#notify(key, value, "expired");
+    return removed;
+  }
+  #expireIfDue(key) {
+    const expiry = this.#expiry.get(key);
+    if (!expiry || expiry.deadline > Date.now())
+      return false;
+    const value = super.get(key);
+    this.#remove(key);
+    this.#stats.expired++;
+    this.#notify(key, value, "expired");
+    return true;
+  }
+  #remove(key) {
+    this.#expiry.delete(key);
+    this.#lru.delete(key);
+    super.delete(key);
+  }
+  #notify(key, value, reason) {
+    if (!this.#onEvict)
+      return;
+    try {
+      this.#onEvict(key, value, reason);
+    } catch {}
+  }
+  #enforceCap() {
+    if (this.#maxSize === undefined)
+      return;
+    while (this.#lru.size > this.#maxSize) {
+      const oldest = this.#lru.oldest();
+      const value = super.get(oldest);
+      this.#remove(oldest);
+      this.#stats.evicted++;
+      this.#notify(oldest, value, "evicted");
+    }
+  }
+  #schedule(key, window) {
+    const deadline = Date.now() + window;
+    const expiry = this.#expiry.get(key);
+    if (expiry) {
+      expiry.deadline = deadline;
+      expiry.window = window;
+      if (deadline >= expiry.filed)
+        return;
+      expiry.filed = deadline;
+    } else
+      this.#expiry.set(key, { deadline, window, filed: deadline });
+    this.#heapPush({ key, deadline });
+    if (this.#heap.length > 2 * this.#expiry.size + 8)
+      this.#compact();
+    this.#rearm();
+  }
+  #nextDeadline() {
+    for (;; ) {
+      const top = this.#heap[0];
+      if (top === undefined)
+        return Infinity;
+      const expiry = this.#expiry.get(top.key);
+      if (!expiry || expiry.filed !== top.deadline) {
+        this.#heapPop();
+        continue;
+      }
+      if (expiry.deadline === top.deadline)
+        return top.deadline;
+      this.#heapPop();
+      expiry.filed = expiry.deadline;
+      this.#heapPush({ key: top.key, deadline: expiry.deadline });
+    }
+  }
+  #compact() {
+    const live = this.#heap.filter((record) => this.#expiry.get(record.key)?.filed === record.deadline);
+    this.#heap.length = 0;
+    for (const record of live)
+      this.#heapPush(record);
+  }
+  #rearm() {
+    const deadline = this.#nextDeadline();
+    if (this.#timer !== undefined && deadline >= this.#armedFor)
+      return;
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+    this.#armedFor = deadline;
+    if (deadline === Infinity)
+      return;
+    this.#timer = setTimeout(() => {
+      this.#timer = undefined;
+      this.#armedFor = Infinity;
+      this.purge();
+    }, Math.max(0, deadline - Date.now()));
+    this.#timer.unref?.();
+  }
+  #heapPush(record) {
+    const heap = this.#heap;
+    heap.push(record);
+    let i = heap.length - 1;
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (heap[parent].deadline <= heap[i].deadline)
+        break;
+      [heap[parent], heap[i]] = [heap[i], heap[parent]];
+      i = parent;
+    }
+  }
+  #heapPop() {
+    const heap = this.#heap;
+    const top = heap[0];
+    const last = heap.pop();
+    if (top === undefined || heap.length === 0)
+      return top;
+    heap[0] = last;
+    for (let i = 0;; ) {
+      const left = 2 * i + 1;
+      const right = left + 1;
+      let smallest = i;
+      if (left < heap.length && heap[left].deadline < heap[smallest].deadline)
+        smallest = left;
+      if (right < heap.length && heap[right].deadline < heap[smallest].deadline)
+        smallest = right;
+      if (smallest === i)
+        break;
+      [heap[smallest], heap[i]] = [heap[i], heap[smallest]];
+      i = smallest;
+    }
+    return top;
+  }
   first() {
     for (const value of this.values())
       return value;
@@ -911,11 +1370,40 @@ class Manager {
   has(id) {
     return this.cache.has(id);
   }
+  #inflight = new Map;
+  fetchOnce(id, load, store = (value) => {
+    this.set(id, value);
+    return value;
+  }) {
+    const pending = this.#inflight.get(id);
+    if (pending)
+      return pending.promise;
+    const entry = {
+      promise: new Promise((resolve) => resolve(load())),
+      dirty: false
+    };
+    this.#inflight.set(id, entry);
+    entry.promise = entry.promise.then((value) => {
+      this.#inflight.delete(id);
+      return entry.dirty ? this.get(id) ?? value : store(value);
+    }, (error) => {
+      this.#inflight.delete(id);
+      throw error;
+    });
+    return entry.promise;
+  }
+  #markDirty(id) {
+    const pending = this.#inflight.get(id);
+    if (pending)
+      pending.dirty = true;
+  }
   set(id, value) {
-    this.cache.set(id, value);
+    this.#markDirty(id);
+    this.cache.setWithoutTTL(id, value);
     return this;
   }
   delete(id) {
+    this.#markDirty(id);
     return this.cache.delete(id);
   }
   clear() {
@@ -951,16 +1439,20 @@ class ResourceManager extends Manager {
   async resolve(id) {
     return this.get(id) ?? this.fetch(id);
   }
-  async fetch(id) {
-    const resource = await this.#fetcher(id);
-    this.set(id, resource);
-    return resource;
+  fetch(id) {
+    return this.fetchOnce(id, () => this.#fetcher(id));
   }
   async fetchMany(ids) {
     return Promise.all([...ids].map((id) => this.resolve(id)));
   }
   upsert(resource) {
     const key = this.#key(resource);
+    const existing = this.get(key);
+    if (existing !== undefined && existing !== resource && typeof existing === "object" && existing !== null) {
+      Object.assign(existing, resource);
+      this.set(key, existing);
+      return existing;
+    }
     this.set(key, resource);
     return resource;
   }
@@ -971,7 +1463,7 @@ class ResourceManager extends Manager {
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.1.8",
+  version: "0.2.1",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -1031,7 +1523,29 @@ class MemoryRateLimitStore {
 }
 
 // packages/rest/src/errors.ts
+function kindFromStatus(status) {
+  if (status === 429)
+    return "rateLimited";
+  if (status === 401)
+    return "authentication";
+  if (status === 403)
+    return "permission";
+  if (status === 404)
+    return "notFound";
+  if (status === 400 || status === 422)
+    return "validation";
+  if (status >= 500)
+    return "server";
+  if (status === 0)
+    return "network";
+  return "client";
+}
+function redactPath(path) {
+  return path.replace(/^(\/webhooks\/[^/?]+\/)[^/?]+/, "$1:token").replace(/^(\/interactions\/[^/?]+\/)[^/?]+/, "$1:token");
+}
+
 class RESTError extends Error {
+  kind;
   status;
   code;
   errors;
@@ -1041,14 +1555,18 @@ class RESTError extends Error {
     super(message, options.cause === undefined ? undefined : { cause: options.cause });
     this.name = "RESTError";
     this.status = status;
+    this.kind = options.kind ?? kindFromStatus(status);
     this.code = code;
     this.errors = errors;
     this.method = options.method;
-    this.path = options.path;
+    this.path = options.path === undefined ? undefined : redactPath(options.path);
+  }
+  get retryable() {
+    return this.kind === "rateLimited" || this.kind === "server" || this.kind === "network" || this.kind === "timeout";
   }
 }
 function abortError(path, reason) {
-  return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason });
+  return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason, kind: "aborted" });
 }
 async function sleep(delay, signal, path) {
   if (delay <= 0)
@@ -1383,8 +1901,23 @@ var Routes = {
   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`
+  applicationEmoji: (applicationId, emojiId) => emojiId ? `/applications/${snowflake(applicationId, "Application ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/emojis`,
+  pollExpire: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/polls/${snowflake(messageId, "Message ID")}/expire`,
+  pollAnswerVoters: (channelId, messageId, answerId) => `/channels/${snowflake(channelId, "Channel ID")}/polls/${snowflake(messageId, "Message ID")}/answers/${integer(answerId, "Answer ID")}`,
+  guildSticker: (guildId, stickerId) => stickerId ? `/guilds/${snowflake(guildId, "Guild ID")}/stickers/${snowflake(stickerId, "Sticker ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/stickers`,
+  sendSoundboardSound: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/send-soundboard-sound`,
+  soundboardDefaultSounds: () => "/soundboard-default-sounds",
+  guildSoundboardSound: (guildId, soundId) => soundId ? `/guilds/${snowflake(guildId, "Guild ID")}/soundboard-sounds/${snowflake(soundId, "Sound ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/soundboard-sounds`,
+  applicationSkus: (applicationId) => `/applications/${snowflake(applicationId, "Application ID")}/skus`,
+  applicationEntitlement: (applicationId, entitlementId) => entitlementId ? `/applications/${snowflake(applicationId, "Application ID")}/entitlements/${snowflake(entitlementId, "Entitlement ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/entitlements`,
+  consumeEntitlement: (applicationId, entitlementId) => `/applications/${snowflake(applicationId, "Application ID")}/entitlements/${snowflake(entitlementId, "Entitlement ID")}/consume`,
+  skuSubscription: (skuId, subscriptionId) => subscriptionId ? `/skus/${snowflake(skuId, "SKU ID")}/subscriptions/${snowflake(subscriptionId, "Subscription ID")}` : `/skus/${snowflake(skuId, "SKU ID")}/subscriptions`
 };
+function integer(value, field) {
+  if (!Number.isInteger(value) || value < 0)
+    throw new TypeError(`${field} must be a non-negative integer.`);
+  return String(value);
+}
 function snowflake(value, field) {
   if (!/^\d{1,20}$/.test(value))
     throw new TypeError(`${field} must be a valid Discord snowflake.`);
@@ -1521,7 +2054,8 @@ class REST {
         throw new RESTError(failure.message, 0, undefined, undefined, {
           method,
           path,
-          cause: failure.cause ?? failure
+          cause: failure.cause ?? failure,
+          kind: failure.timedOut ? "timeout" : "network"
         });
       }
       this.#emit(this.#hooks.onResponse, {
@@ -1620,6 +2154,9 @@ class REST {
   #emit(hook, ctx) {
     if (!hook)
       return;
+    const withPath = ctx;
+    if (typeof withPath.path === "string")
+      ctx = { ...ctx, path: redactPath(withPath.path) };
     Promise.resolve().then(() => hook(ctx)).catch(() => {});
   }
 }
@@ -1696,6 +2233,7 @@ class Channel extends BaseStructure {
   nsfw;
   rateLimitPerUser;
   position;
+  permissionOverwrites;
   #context;
   constructor(data, context) {
     super(data.id);
@@ -1709,6 +2247,7 @@ class Channel extends BaseStructure {
     this.nsfw = data.nsfw;
     this.rateLimitPerUser = data.rate_limit_per_user;
     this.position = data.position;
+    this.permissionOverwrites = (data.permission_overwrites ?? []).map((overwrite) => ({ ...overwrite }));
     this.#context = context;
   }
   sendMessage(options) {
@@ -1732,6 +2271,11 @@ class Channel extends BaseStructure {
   editTopic(topic) {
     return this.edit({ topic });
   }
+  editPermissionOverwrite(targetId, changes, options) {
+    if (!this.#context?.editPermissionOverwrite)
+      throw new Error("This channel is not attached to a client.");
+    return this.#context.editPermissionOverwrite(this.id, targetId, changes, options);
+  }
   editParent(parentId) {
     return this.edit({ parent_id: parentId });
   }
@@ -1866,7 +2410,148 @@ class Guild extends BaseStructure {
     return this.name;
   }
 }
+
 // packages/structures/src/resources.ts
+function toDateOrNull(value) {
+  if (!value)
+    return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+class GuildMember {
+  user;
+  guildId;
+  nickname;
+  roleIds;
+  pending;
+  joinedAt;
+  avatarHash;
+  premiumSince;
+  timedOutUntil;
+  flags;
+  #suppliedPermissions;
+  #context;
+  constructor(data, context) {
+    this.user = new User(data.user);
+    this.#context = context;
+    if (!/^\d{1,20}$/.test(data.guild_id))
+      throw new TypeError("Member guild_id must be a valid snowflake.");
+    this.guildId = data.guild_id;
+    this.nickname = data.nick ?? null;
+    this.roleIds = [...data.roles ?? []];
+    this.pending = data.pending ?? false;
+    this.joinedAt = data.joined_at ? new Date(data.joined_at) : undefined;
+    if (this.joinedAt?.toString() === "Invalid Date")
+      throw new RangeError("Member joined_at must be a valid date.");
+    if (data.permissions !== undefined)
+      this.#suppliedPermissions = new PermissionsBitField(data.permissions);
+    this.avatarHash = data.avatar ?? null;
+    this.premiumSince = toDateOrNull(data.premium_since);
+    this.timedOutUntil = toDateOrNull(data.communication_disabled_until);
+    this.flags = data.flags ?? 0;
+  }
+  get permissions() {
+    if (this.#suppliedPermissions)
+      return this.#suppliedPermissions;
+    return new PermissionsBitField(this.#context?.memberPermissions?.(this.guildId, this.user.id, this.roleIds) ?? 0n);
+  }
+  permissionsIn(channelId) {
+    const computed = this.#context?.memberPermissions?.(this.guildId, this.user.id, this.roleIds, channelId);
+    return computed ? new PermissionsBitField(computed) : null;
+  }
+  #action(name) {
+    const action = this.#context?.[name];
+    if (!action)
+      throw new Error("This member is not attached to a client.");
+    return action;
+  }
+  kick(reason) {
+    return this.#action("kickMember")(this.guildId, this.user.id, reason);
+  }
+  ban(options = {}) {
+    return this.#action("banMember")(this.guildId, this.user.id, options);
+  }
+  edit(options, reason) {
+    return this.#action("editMember")(this.guildId, this.user.id, options, reason);
+  }
+  timeout(milliseconds, reason) {
+    if (milliseconds !== null && !(milliseconds > 0))
+      throw new RangeError("Timeout length must be a positive number of milliseconds.");
+    return this.edit({
+      communication_disabled_until: milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString()
+    }, reason);
+  }
+  setNickname(nickname, reason) {
+    return this.edit({ nick: nickname }, reason);
+  }
+  addRole(roleId, reason) {
+    return this.#action("addMemberRole")(this.guildId, this.user.id, roleId, reason);
+  }
+  removeRole(roleId, reason) {
+    return this.#action("removeMemberRole")(this.guildId, this.user.id, roleId, reason);
+  }
+  get displayName() {
+    return this.nickname ?? this.user.displayName;
+  }
+  get isTimedOut() {
+    return this.timedOutUntil !== null && this.timedOutUntil > new Date;
+  }
+  avatarURL(options = {}) {
+    if (this.avatarHash)
+      return cdnURL(`/guilds/${this.guildId}/users/${this.user.id}/avatars`, this.avatarHash, options);
+    return this.user.avatarURL(options);
+  }
+  displayAvatarURL(options = {}) {
+    return this.avatarURL(options) ?? this.user.displayAvatarURL(options);
+  }
+  toString() {
+    return this.user.toString();
+  }
+}
+
+class Role extends BaseStructure {
+  name;
+  color;
+  hoist;
+  permissions;
+  managed;
+  mentionable;
+  position;
+  unicodeEmoji;
+  iconHash;
+  tags;
+  constructor(data) {
+    super(data.id);
+    if (!data.name)
+      throw new TypeError("Role name cannot be empty.");
+    this.name = data.name;
+    this.color = data.color ?? 0;
+    this.hoist = data.hoist ?? false;
+    this.permissions = new PermissionsBitField(data.permissions ?? 0n);
+    this.managed = data.managed ?? false;
+    this.mentionable = data.mentionable ?? false;
+    this.position = data.position ?? 0;
+    this.unicodeEmoji = data.unicode_emoji ?? null;
+    this.iconHash = data.icon ?? null;
+    this.tags = data.tags ?? null;
+  }
+  get colorHex() {
+    return `#${this.color.toString(16).padStart(6, "0").toUpperCase()}`;
+  }
+  iconURL(options = {}) {
+    if (!this.iconHash)
+      return null;
+    return cdnURL(`/role-icons/${this.id}`, this.iconHash, options);
+  }
+  isEveryone(guildId) {
+    return this.id === guildId;
+  }
+  toString() {
+    return `<@&${this.id}>`;
+  }
+}
+
 class TextChannel extends Channel {
   constructor(data, context) {
     super(data, context);
@@ -1875,6 +2560,38 @@ class TextChannel extends Channel {
     return `<#${this.id}>`;
   }
 }
+class Emoji extends BaseStructure {
+  name;
+  roleIds;
+  user;
+  requireColons;
+  managed;
+  animated;
+  available;
+  constructor(data) {
+    super(data.id ?? "0");
+    if (data.id === null)
+      this.id = "unicode";
+    this.name = data.name;
+    this.roleIds = data.roles ?? [];
+    this.user = data.user ? new User(data.user) : null;
+    this.requireColons = data.require_colons ?? false;
+    this.managed = data.managed ?? false;
+    this.animated = data.animated ?? false;
+    this.available = data.available ?? true;
+  }
+  url(options = {}) {
+    if (!this.id || this.id === "unicode")
+      return null;
+    const ext = options.extension ?? (this.animated ? "gif" : "png");
+    const size = options.size ? `?size=${options.size}` : "";
+    return `${CDN_BASE}/emojis/${this.id}.${ext}${size}`;
+  }
+  toString() {
+    return this.id !== "unicode" ? `<${this.animated ? "a" : ""}:${this.name}:${this.id}>` : this.name ?? "";
+  }
+}
+
 class AutoModerationRule extends BaseStructure {
   guildId;
   name;
@@ -2167,6 +2884,17 @@ class CommandOptions {
       throw new TypeError(`Resolved mentionable for option "${name}" is missing.`);
     return resolved;
   }
+  getMentionableType(name) {
+    const opt = this.#get(name);
+    if (!opt || opt.type !== OptionType.Mentionable)
+      return null;
+    const id = String(opt.value);
+    if (this.#resolved?.users?.[id])
+      return "user";
+    if (this.#resolved?.roles?.[id])
+      return "role";
+    return null;
+  }
   getAttachment(name, required = false) {
     const opt = this.#get(name);
     if (!opt || opt.type !== OptionType.Attachment) {
@@ -2192,6 +2920,17 @@ var InteractionType = {
   ApplicationCommandAutocomplete: 4,
   ModalSubmit: 5
 };
+var EPHEMERAL = 64;
+var TOKEN_LIFETIME_MS = 15 * 60000;
+var DISCORD_EPOCH = 1420070400000n;
+function toMessageData(options) {
+  if (typeof options === "string")
+    return { content: options };
+  const { ephemeral, ...data } = options;
+  if (ephemeral)
+    data.flags = (typeof data.flags === "number" ? data.flags : 0) | EPHEMERAL;
+  return data;
+}
 
 class InteractionResponse {
   type;
@@ -2206,14 +2945,10 @@ class InteractionResponse {
     return this.data === undefined ? { type: this.type } : { type: this.type, data: this.data };
   }
   static message(options) {
-    const data = { ...options };
-    if (options.ephemeral) {
-      data.flags = (typeof options.flags === "number" ? options.flags : 0) | 64;
-    }
-    return new InteractionResponse(InteractionResponseType.ChannelMessage, data);
+    return new InteractionResponse(InteractionResponseType.ChannelMessage, toMessageData(options));
   }
   static defer(ephemeral = false) {
-    return new InteractionResponse(InteractionResponseType.DeferredChannelMessage, ephemeral ? { flags: 64 } : undefined);
+    return new InteractionResponse(InteractionResponseType.DeferredChannelMessage, ephemeral ? { flags: EPHEMERAL } : undefined);
   }
   static pong() {
     return new InteractionResponse(InteractionResponseType.Pong);
@@ -2231,6 +2966,7 @@ class Interaction {
   replied = false;
   deferred = false;
   #client;
+  #acknowledging = false;
   constructor(client, data) {
     if (!data.id || !data.token)
       throw new TypeError("Interaction ID and token are required.");
@@ -2246,6 +2982,20 @@ class Interaction {
   isChatInputCommand() {
     return this.type === InteractionType.ApplicationCommand;
   }
+  awaitModalSubmit(options) {
+    const collect = this.#client.resourceContext?.collectInteractions;
+    if (!collect)
+      return Promise.reject(new Error("This interaction is not attached to a client."));
+    if (!(options.time > 0))
+      return Promise.reject(new RangeError("awaitModalSubmit needs a positive time."));
+    const userId = this.user?.id;
+    const collector = collect({
+      time: options.time,
+      max: 1,
+      filter: async (interaction) => interaction.isModalSubmit() && interaction.user?.id === userId && (options.customId === undefined || interaction.customId === options.customId) && (options.filter ? await options.filter(interaction) : true)
+    });
+    return collector.next();
+  }
   isMessageComponent() {
     return this.type === InteractionType.MessageComponent;
   }
@@ -2280,9 +3030,57 @@ class Interaction {
     return [3, 5, 6, 7, 8].includes(this.#componentType());
   }
   assertUnacknowledged() {
-    if (this.replied || this.deferred)
+    if (this.replied || this.deferred || this.#acknowledging)
       throw new Error("Interaction has already been acknowledged.");
   }
+  async acknowledge(response, state) {
+    this.assertUnacknowledged();
+    this.#acknowledging = true;
+    try {
+      const result = await this.postResponse(response);
+      this[state] = true;
+      return result;
+    } finally {
+      this.#acknowledging = false;
+    }
+  }
+  get user() {
+    const raw = this.data.member?.user ?? this.data.user;
+    return raw ? new User(raw) : null;
+  }
+  get member() {
+    const raw = this.data.member;
+    if (!raw || !this.guildId)
+      return null;
+    return new GuildMember({
+      ...raw,
+      guild_id: this.guildId
+    }, this.#client.resourceContext);
+  }
+  get createdTimestamp() {
+    return Number((BigInt(this.id) >> 22n) + DISCORD_EPOCH);
+  }
+  get expiresAt() {
+    return new Date(this.createdTimestamp + TOKEN_LIFETIME_MS);
+  }
+  get isExpired() {
+    return Date.now() >= this.createdTimestamp + TOKEN_LIFETIME_MS;
+  }
+  #webhookMessage(method, messageId, data) {
+    if (!this.#client.interactionWebhookMessage)
+      return Promise.reject(new Error("This interaction client does not support webhook message access."));
+    return this.#client.interactionWebhookMessage(method, this.applicationId, this.token, messageId, data);
+  }
+  fetchReply() {
+    this.assertAcknowledged();
+    return this.#webhookMessage("GET", "@original");
+  }
+  editFollowUp(messageId, options) {
+    return this.#webhookMessage("PATCH", messageId, toMessageData(options));
+  }
+  async deleteFollowUp(messageId) {
+    await this.#webhookMessage("DELETE", messageId);
+  }
   assertAcknowledged() {
     if (!this.replied && !this.deferred)
       throw new Error("Interaction has not been acknowledged.");
@@ -2291,41 +3089,29 @@ class Interaction {
     return this.#client.postInteractionResponse(this.id, this.token, response);
   }
   async reply(options) {
-    this.assertUnacknowledged();
-    const payload = typeof options === "string" ? { content: options } : options;
-    const result = await this.#client.postInteractionResponse(this.id, this.token, InteractionResponse.message(payload));
-    this.replied = true;
-    return result;
+    return this.acknowledge(InteractionResponse.message(toMessageData(options)), "replied");
   }
-  async deferReply(ephemeral = false) {
-    this.assertUnacknowledged();
-    await this.#client.postInteractionResponse(this.id, this.token, InteractionResponse.defer(ephemeral));
-    this.deferred = true;
+  async deferReply(options = false) {
+    const ephemeral = typeof options === "boolean" ? options : options.ephemeral === true;
+    await this.acknowledge(InteractionResponse.defer(ephemeral), "deferred");
   }
   editReply(options) {
     this.assertAcknowledged();
-    return this.#client.editInteractionReply(this.token, options);
+    return this.#client.editInteractionReply(this.token, toMessageData(options));
   }
   deleteReply() {
     this.assertAcknowledged();
     return this.#client.deleteInteractionReply(this.token);
   }
   followUp(options) {
-    const payload = typeof options === "string" ? { content: options } : options;
-    return this.#client.followUpInteraction(this.token, payload);
+    return this.#client.followUpInteraction(this.token, toMessageData(options));
   }
   async update(options) {
-    this.assertUnacknowledged();
-    const payload = typeof options === "string" ? { content: options } : options;
-    const result = await this.#client.postInteractionResponse(this.id, this.token, new InteractionResponse(InteractionResponseType.MessageUpdate, payload));
-    this.replied = true;
-    return result;
+    return this.acknowledge(new InteractionResponse(InteractionResponseType.MessageUpdate, toMessageData(options)), "replied");
   }
   async showModal(modal) {
-    this.assertUnacknowledged();
-    const result = await this.#client.postInteractionResponse(this.id, this.token, new InteractionResponse(InteractionResponseType.Modal, modal));
-    this.replied = true;
-    return result;
+    const data = "toJSON" in modal && typeof modal.toJSON === "function" ? modal.toJSON() : modal;
+    return this.acknowledge(new InteractionResponse(InteractionResponseType.Modal, data), "replied");
   }
 }
 
@@ -2346,6 +3132,9 @@ class ComponentInteraction extends Interaction {
   get customId() {
     return this.data?.data?.custom_id ?? "";
   }
+  get messageId() {
+    return this.data?.message?.id;
+  }
   get componentType() {
     return this.data?.data?.component_type ?? 0;
   }
@@ -2353,16 +3142,10 @@ class ComponentInteraction extends Interaction {
     return this.data?.data?.values ?? [];
   }
   async deferUpdate() {
-    this.assertUnacknowledged();
-    await this.postResponse(new InteractionResponse(InteractionResponseType.DeferredMessageUpdate));
-    this.deferred = true;
+    await this.acknowledge(new InteractionResponse(InteractionResponseType.DeferredMessageUpdate), "deferred");
   }
   async update(options) {
-    this.assertUnacknowledged();
-    const payload = typeof options === "string" ? { content: options } : options;
-    const result = await this.postResponse(new InteractionResponse(InteractionResponseType.MessageUpdate, payload));
-    this.replied = true;
-    return result;
+    return this.acknowledge(new InteractionResponse(InteractionResponseType.MessageUpdate, toMessageData(options)), "replied");
   }
 }
 
@@ -2405,8 +3188,7 @@ class AutocompleteInteraction extends Interaction {
     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;
+    await this.acknowledge(response, "replied");
   }
 }
 function findFocused(options) {
@@ -2437,6 +3219,7 @@ function createInteraction(client, data) {
 }
 
 // packages/structures/src/index.ts
+var COMPONENT_COLLECTOR_DEFAULT_TIME = 15 * 60000;
 var NON_SYSTEM_MESSAGE_TYPES = new Set([0, 19, 20, 23]);
 
 class Message extends BaseStructure {
@@ -2457,6 +3240,7 @@ class Message extends BaseStructure {
   reference;
   components;
   referencedMessage;
+  member;
   #context;
   constructor(data, context) {
     super(data.id);
@@ -2479,6 +3263,11 @@ class Message extends BaseStructure {
     this.reference = data.message_reference;
     this.referencedMessage = data.referenced_message ? new Message(data.referenced_message, context) : data.referenced_message === null ? null : undefined;
     this.#context = context;
+    this.member = data.member && data.guild_id ? new GuildMember({
+      ...data.member,
+      user: data.member.user ?? data.author,
+      guild_id: data.guild_id
+    }, context) : null;
     this.channel = new Channel({ id: data.channel_id, type: 0, guild_id: data.guild_id }, context);
   }
   get embedsSuppressed() {
@@ -2519,6 +3308,20 @@ class Message extends BaseStructure {
       throw new Error("This message is not attached to a client.");
     return this.#context.crosspostMessage(this.channelId, this.id);
   }
+  createComponentCollector(options = {}) {
+    const collect = this.#context?.collectInteractions;
+    if (!collect)
+      throw new Error("This message is not attached to a client.");
+    const { componentType, filter, ...rest } = options;
+    return collect({
+      ...rest,
+      time: rest.time ?? (rest.idle ? undefined : COMPONENT_COLLECTOR_DEFAULT_TIME),
+      filter: async (interaction) => interaction.isMessageComponent() && interaction.messageId === this.id && (componentType === undefined || interaction.componentType === componentType) && (filter ? await filter(interaction) : true)
+    });
+  }
+  awaitComponent(options = {}) {
+    return this.createComponentCollector({ ...options, max: 1 }).next();
+  }
   react(emoji) {
     if (!this.#context?.addReaction)
       throw new Error("This message is not attached to a client.");
@@ -2592,23 +3395,43 @@ class Message extends BaseStructure {
 }
 
 // packages/managers/src/message.ts
+function toRequest(options) {
+  const { files, ...body } = options;
+  if (!files?.length)
+    return body;
+  return {
+    body,
+    files: files.map((file) => ({
+      name: file.name,
+      data: typeof file.data === "string" ? new TextEncoder().encode(file.data) : file.data,
+      contentType: file.contentType
+    }))
+  };
+}
+
 class MessageManager {
-  cache = new Collection;
+  cache;
+  #caching;
   #rest;
   #context;
   #channelId;
-  constructor(rest, context, channelId) {
+  constructor(rest, context, channelId, cache) {
     if (!channelId)
       throw new TypeError("Channel ID is required.");
     this.#rest = rest;
     this.#context = context;
     this.#channelId = channelId;
+    this.#caching = cache !== undefined;
+    this.cache = new Collection(null, {
+      ttl: cache?.ttl,
+      maxSize: cache ? cache.maxSize ?? 100 : undefined
+    });
   }
   async resolve(messageId) {
     return this.cache.get(messageId) ?? this.fetch(messageId);
   }
   async send(options) {
-    const data = await this.#rest.post(Routes.channelMessages(this.#channelId), options);
+    const data = await this.#rest.post(Routes.channelMessages(this.#channelId), toRequest(options));
     return this.upsert(data);
   }
   async fetch(messageId) {
@@ -2619,13 +3442,14 @@ class MessageManager {
     return Promise.all(Array.from(messageIds, (messageId) => this.fetch(messageId)));
   }
   upsert(data) {
-    const existing = this.cache.get(data.id);
+    const existing = this.cache.peek(data.id);
     const message = new Message(data, this.#context);
     if (existing) {
       Object.assign(existing, message);
       return existing;
     }
-    this.cache.set(message.id, message);
+    if (this.#caching)
+      this.cache.set(message.id, message);
     return message;
   }
   delete(messageId) {
@@ -2679,8 +3503,301 @@ class UserManager extends ResourceManager {
     });
   }
 }
+// packages/managers/src/emoji.ts
+class EmojiManager extends Manager {
+  #rest;
+  #guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.#guildId = guildId;
+  }
+  fetch(emojiId) {
+    return this.fetchOnce(emojiId, async () => new Emoji(await this.#rest.get(Routes.guildEmoji(this.#guildId, emojiId))), (emoji) => this.#merge(emojiId, emoji));
+  }
+  async fetchAll() {
+    const data = await this.#rest.get(Routes.guildEmoji(this.#guildId));
+    return data.map((item) => this.upsert(item));
+  }
+  async create(options) {
+    return this.upsert(await this.#rest.post(Routes.guildEmoji(this.#guildId), options));
+  }
+  async edit(emojiId, options) {
+    return this.upsert(await this.#rest.patch(Routes.guildEmoji(this.#guildId, emojiId), options));
+  }
+  async deleteEmoji(emojiId) {
+    await this.#rest.delete(Routes.guildEmoji(this.#guildId, emojiId));
+    this.delete(emojiId);
+  }
+  upsert(data) {
+    const key = data.id != null ? data.id : `unicode:${data.name ?? ""}`;
+    return this.#merge(key, new Emoji(data));
+  }
+  #merge(key, emoji) {
+    const existing = this.get(key);
+    if (existing) {
+      Object.assign(existing, emoji);
+      return existing;
+    }
+    this.set(key, emoji);
+    return emoji;
+  }
+}
+
+// packages/managers/src/advanced.ts
+function withQuery(path, query) {
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(query))
+    if (value !== undefined)
+      params.set(key, String(value));
+  const suffix = params.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+class GuildStickerManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(sticker) {
+    this.set(sticker.id, sticker);
+    return sticker;
+  }
+  async fetchAll() {
+    const stickers = await this.#rest.get(Routes.guildSticker(this.guildId));
+    this.clear();
+    return stickers.map((sticker) => this.#store(sticker));
+  }
+  async fetch(stickerId) {
+    return this.#store(await this.#rest.get(Routes.guildSticker(this.guildId, stickerId)));
+  }
+  async create(options) {
+    const form = new FormData;
+    form.set("name", options.name);
+    form.set("description", options.description);
+    form.set("tags", options.tags);
+    form.set("file", options.file);
+    return this.#store(await this.#rest.post(Routes.guildSticker(this.guildId), form, { reason: options.reason }));
+  }
+  async edit(stickerId, options) {
+    const { reason, ...body } = options;
+    return this.#store(await this.#rest.patch(Routes.guildSticker(this.guildId, stickerId), body, { reason }));
+  }
+  async remove(stickerId, reason) {
+    await this.#rest.delete(Routes.guildSticker(this.guildId, stickerId), {
+      reason
+    });
+    this.delete(stickerId);
+  }
+  sync(stickers) {
+    this.clear();
+    for (const sticker of stickers)
+      this.#store(sticker);
+  }
+}
+
+class GuildSoundboardManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(sound) {
+    this.set(sound.sound_id, sound);
+    return sound;
+  }
+  async fetchAll() {
+    const { items } = await this.#rest.get(Routes.guildSoundboardSound(this.guildId));
+    this.clear();
+    return items.map((sound) => this.#store(sound));
+  }
+  async fetch(soundId) {
+    return this.#store(await this.#rest.get(Routes.guildSoundboardSound(this.guildId, soundId)));
+  }
+  async create(options) {
+    if (options.volume !== undefined && (options.volume < 0 || options.volume > 1))
+      throw new RangeError("Soundboard volume must be between 0 and 1.");
+    return this.#store(await this.#rest.post(Routes.guildSoundboardSound(this.guildId), {
+      name: options.name,
+      sound: options.sound,
+      volume: options.volume,
+      emoji_id: options.emojiId,
+      emoji_name: options.emojiName
+    }, { reason: options.reason }));
+  }
+  async edit(soundId, options) {
+    return this.#store(await this.#rest.patch(Routes.guildSoundboardSound(this.guildId, soundId), {
+      name: options.name,
+      volume: options.volume,
+      emoji_id: options.emojiId,
+      emoji_name: options.emojiName
+    }, { reason: options.reason }));
+  }
+  async remove(soundId, reason) {
+    await this.#rest.delete(Routes.guildSoundboardSound(this.guildId, soundId), { reason });
+    this.delete(soundId);
+  }
+}
+
+class MonetizationManager extends Manager {
+  #rest;
+  applicationId;
+  constructor(rest, applicationId) {
+    super();
+    this.#rest = rest;
+    this.applicationId = applicationId;
+  }
+  fetchSkus() {
+    return this.#rest.get(Routes.applicationSkus(this.applicationId));
+  }
+  async fetchEntitlements(query = {}) {
+    if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 100))
+      throw new RangeError("Entitlement limit must be 1-100.");
+    const entitlements = await this.#rest.get(withQuery(Routes.applicationEntitlement(this.applicationId), {
+      user_id: query.userId,
+      sku_ids: query.skuIds?.join(","),
+      guild_id: query.guildId,
+      before: query.before,
+      after: query.after,
+      limit: query.limit,
+      exclude_ended: query.excludeEnded,
+      exclude_deleted: query.excludeDeleted
+    }));
+    for (const entitlement of entitlements)
+      this.set(entitlement.id, entitlement);
+    return entitlements;
+  }
+  async fetch(entitlementId) {
+    const entitlement = await this.#rest.get(Routes.applicationEntitlement(this.applicationId, entitlementId));
+    this.set(entitlement.id, entitlement);
+    return entitlement;
+  }
+  async consume(entitlementId) {
+    await this.#rest.post(Routes.consumeEntitlement(this.applicationId, entitlementId));
+    const cached = this.get(entitlementId);
+    if (cached)
+      cached.consumed = true;
+  }
+  async createTestEntitlement(options) {
+    const entitlement = await this.#rest.post(Routes.applicationEntitlement(this.applicationId), {
+      sku_id: options.skuId,
+      owner_id: options.ownerId,
+      owner_type: options.ownerType
+    });
+    this.set(entitlement.id, entitlement);
+    return entitlement;
+  }
+  async deleteTestEntitlement(entitlementId) {
+    await this.#rest.delete(Routes.applicationEntitlement(this.applicationId, entitlementId));
+    this.delete(entitlementId);
+  }
+  fetchSubscriptions(skuId, query = {}) {
+    return this.#rest.get(withQuery(Routes.skuSubscription(skuId), {
+      user_id: query.userId,
+      before: query.before,
+      after: query.after,
+      limit: query.limit
+    }));
+  }
+  fetchSubscription(skuId, subscriptionId) {
+    return this.#rest.get(Routes.skuSubscription(skuId, subscriptionId));
+  }
+}
+
+// packages/managers/src/member.ts
+class GuildMemberManager extends ResourceManager {
+  #rest;
+  #context;
+  guildId;
+  constructor(guildId, rest, context = () => {
+    return;
+  }) {
+    super((id) => rest.get(Routes.guildMember(guildId, id)).then((data) => new GuildMember({ ...data, guild_id: guildId }, context())), (member) => member.user.id);
+    this.guildId = guildId;
+    this.#rest = rest;
+    this.#context = context;
+  }
+  async kick(userId, reason) {
+    await this.#rest.delete(Routes.guildMember(this.guildId, userId), {
+      reason
+    });
+    this.delete(userId);
+  }
+  async ban(userId, options = {}) {
+    await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
+    this.delete(userId);
+  }
+  async unban(userId) {
+    await this.#rest.delete(Routes.guildBan(this.guildId, userId));
+  }
+  async edit(userId, options, reason) {
+    const data = await this.#rest.patch(Routes.guildMember(this.guildId, userId), options, { reason });
+    const member = new GuildMember({ ...data, guild_id: this.guildId }, this.#context());
+    this.set(member.user.id, member);
+    return member;
+  }
+  async addRole(userId, roleId, reason) {
+    await this.#rest.put(Routes.guildMemberRole(this.guildId, userId, roleId), undefined, { reason });
+  }
+  async removeRole(userId, roleId, reason) {
+    await this.#rest.delete(Routes.guildMemberRole(this.guildId, userId, roleId), { reason });
+  }
+  async timeout(userId, milliseconds, reason) {
+    const timeoutDate = milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString();
+    return this.edit(userId, { communication_disabled_until: timeoutDate }, reason);
+  }
+}
+
+// packages/managers/src/role.ts
+class RoleManager extends ResourceManager {
+  #rest;
+  guildId;
+  constructor(guildId, rest) {
+    super((id) => rest.get(Routes.guildRole(guildId, id)).then((data) => new Role(data)), (role) => role.id);
+    this.guildId = guildId;
+    this.#rest = rest;
+  }
+  async fetchAll() {
+    const data = await this.#rest.get(Routes.guildRoles(this.guildId));
+    return data.map((item) => {
+      const role = new Role(item);
+      this.set(role.id, role);
+      return role;
+    });
+  }
+  async create(options) {
+    const { reason, ...payload } = options;
+    const data = await this.#rest.post(Routes.guildRoles(this.guildId), {
+      ...payload,
+      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
+    });
+    const role = new Role(data);
+    this.set(role.id, role);
+    return role;
+  }
+  async edit(roleId, options) {
+    const { reason, ...payload } = options;
+    const data = await this.#rest.patch(Routes.guildRole(this.guildId, roleId), {
+      ...payload,
+      permissions: payload.permissions !== undefined ? String(payload.permissions) : undefined
+    });
+    const role = new Role(data);
+    this.set(role.id, role);
+    return role;
+  }
+  async deleteRole(roleId) {
+    await this.#rest.delete(Routes.guildRole(this.guildId, roleId));
+    this.delete(roleId);
+  }
+}
+
 // packages/managers/src/guild-resources.ts
-function withQuery(path, params) {
+function withQuery2(path, params) {
   const query = new URLSearchParams;
   for (const [key, value] of Object.entries(params))
     if (value !== undefined)
@@ -2704,7 +3821,7 @@ class GuildBanManager extends Manager {
   }
   async fetchAll(options = {}) {
     const limit = options.limit === undefined ? undefined : Math.min(1000, Math.max(1, options.limit));
-    const bans = await this.#rest.get(withQuery(Routes.guildBans(this.guildId), {
+    const bans = await this.#rest.get(withQuery2(Routes.guildBans(this.guildId), {
       limit,
       before: options.before,
       after: options.after
@@ -2737,12 +3854,12 @@ class GuildScheduledEventManager extends Manager {
     return event;
   }
   async fetch(eventId, options = {}) {
-    return this.#store(await this.#rest.get(withQuery(Routes.guildScheduledEvent(this.guildId, eventId), {
+    return this.#store(await this.#rest.get(withQuery2(Routes.guildScheduledEvent(this.guildId, eventId), {
       with_user_count: options.withUserCount
     })));
   }
   async fetchAll(options = {}) {
-    const events = await this.#rest.get(withQuery(Routes.guildScheduledEvents(this.guildId), {
+    const events = await this.#rest.get(withQuery2(Routes.guildScheduledEvents(this.guildId), {
       with_user_count: options.withUserCount
     }));
     return events.map((event) => this.#store(event));
@@ -2759,7 +3876,7 @@ class GuildScheduledEventManager extends Manager {
   }
   async fetchSubscribers(eventId, options = {}) {
     const limit = options.limit === undefined ? undefined : Math.min(100, Math.max(1, options.limit));
-    return this.#rest.get(withQuery(Routes.guildScheduledEventUsers(this.guildId, eventId), {
+    return this.#rest.get(withQuery2(Routes.guildScheduledEventUsers(this.guildId, eventId), {
       limit,
       with_member: options.withMember,
       before: options.before,
@@ -2803,10 +3920,25 @@ class StageInstanceManager extends Manager {
 
 class PermissionOverwriteManager {
   #rest;
+  #current;
   channelId;
-  constructor(rest, channelId) {
+  constructor(rest, channelId, current = () => {
+    return;
+  }) {
     this.#rest = rest;
     this.channelId = channelId;
+    this.#current = current;
+  }
+  async update(overwriteId, changes, options = {}) {
+    const overwrites = this.#current() ?? (await this.#rest.get(Routes.channel(this.channelId))).permission_overwrites ?? [];
+    const existing = overwrites.find((entry) => entry.id === overwriteId);
+    const type = existing?.type ?? options.type;
+    if (type !== 0 && type !== 1)
+      throw new TypeError("A new permission overwrite needs a type: 0 for a role, 1 for a member.");
+    const touched = (changes.allow ?? 0n) | (changes.deny ?? 0n) | (changes.inherit ?? 0n);
+    const allow = BigInt(existing?.allow ?? 0) & ~touched | (changes.allow ?? 0n);
+    const deny = BigInt(existing?.deny ?? 0) & ~touched | (changes.deny ?? 0n);
+    await this.edit(overwriteId, { type, allow, deny }, options.reason);
   }
   async edit(overwriteId, options, reason) {
     await this.#rest.put(Routes.channelPermission(this.channelId, overwriteId), {
@@ -2821,7 +3953,7 @@ class PermissionOverwriteManager {
 }
 
 // packages/managers/src/guild.ts
-function withQuery2(path, params) {
+function withQuery3(path, params) {
   const suffix = params.toString();
   return suffix ? `${path}?${suffix}` : path;
 }
@@ -2830,6 +3962,24 @@ class GuildManager extends ResourceManager {
   #rest;
   #bans = new Map;
   #scheduledEvents = new Map;
+  #members = new Map;
+  #roles = new Map;
+  #emojis = new Map;
+  #stickers = new Map;
+  #soundboard = new Map;
+  #voiceStates = new Map;
+  #autoModerationRules = new Map;
+  #invites = new Map;
+  #context;
+  attachContext(context) {
+    this.#context = context;
+  }
+  #perGuild(map, guildId, create) {
+    let manager = map.get(guildId);
+    if (!manager)
+      map.set(guildId, manager = create());
+    return manager;
+  }
   constructor(rest) {
     super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
     this.#rest = rest;
@@ -2846,6 +3996,68 @@ class GuildManager extends ResourceManager {
       this.#scheduledEvents.set(guildId, manager = new GuildScheduledEventManager(this.#rest, guildId));
     return manager;
   }
+  members(guildId) {
+    let manager = this.#members.get(guildId);
+    if (!manager)
+      this.#members.set(guildId, manager = new GuildMemberManager(guildId, this.#rest, () => this.#context));
+    return manager;
+  }
+  roles(guildId) {
+    let manager = this.#roles.get(guildId);
+    if (!manager)
+      this.#roles.set(guildId, manager = new RoleManager(guildId, this.#rest));
+    return manager;
+  }
+  emojis(guildId) {
+    let manager = this.#emojis.get(guildId);
+    if (!manager)
+      this.#emojis.set(guildId, manager = new EmojiManager(this.#rest, guildId));
+    return manager;
+  }
+  stickers(guildId) {
+    let manager = this.#stickers.get(guildId);
+    if (!manager)
+      this.#stickers.set(guildId, manager = new GuildStickerManager(this.#rest, guildId));
+    return manager;
+  }
+  soundboard(guildId) {
+    let manager = this.#soundboard.get(guildId);
+    if (!manager)
+      this.#soundboard.set(guildId, manager = new GuildSoundboardManager(this.#rest, guildId));
+    return manager;
+  }
+  voiceStates(guildId) {
+    return this.#perGuild(this.#voiceStates, guildId, () => new Manager);
+  }
+  autoModerationRules(guildId) {
+    return this.#perGuild(this.#autoModerationRules, guildId, () => new Manager);
+  }
+  invites(guildId) {
+    return this.#perGuild(this.#invites, guildId, () => new Manager);
+  }
+  patch(data) {
+    const guild = new Guild(data);
+    const existing = this.get(guild.id);
+    if (!existing)
+      return this.upsert(guild);
+    for (const [key, value] of Object.entries(guild))
+      if (value !== undefined)
+        existing[key] = value;
+    return existing;
+  }
+  delete(id) {
+    this.#bans.delete(id);
+    this.#scheduledEvents.delete(id);
+    this.#members.delete(id);
+    this.#roles.delete(id);
+    this.#emojis.delete(id);
+    this.#stickers.delete(id);
+    this.#soundboard.delete(id);
+    this.#voiceStates.delete(id);
+    this.#autoModerationRules.delete(id);
+    this.#invites.delete(id);
+    return super.delete(id);
+  }
   async create(options) {
     const data = await this.#rest.post("/guilds", options);
     return this.upsert(new Guild(data));
@@ -2881,7 +4093,7 @@ class GuildManager extends ResourceManager {
       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(withQuery2(Routes.guildAuditLog(guildId), params));
+    return this.#rest.get(withQuery3(Routes.guildAuditLog(guildId), params));
   }
   async fetchMembers(guildId, options = {}) {
     const params = new URLSearchParams;
@@ -2889,7 +4101,7 @@ class GuildManager extends ResourceManager {
       params.set("limit", String(Math.min(1000, Math.max(1, options.limit))));
     if (options.after)
       params.set("after", options.after);
-    return this.#rest.get(withQuery2(Routes.guildMembers(guildId), params));
+    return this.#rest.get(withQuery3(Routes.guildMembers(guildId), params));
   }
   async fetchAutoModerationRules(guildId) {
     const rules = await this.#rest.get(Routes.guildAutoModerationRules(guildId));
@@ -2952,13 +4164,20 @@ class ApplicationCommandManager {
 }
 
 // packages/managers/src/index.ts
+var BULK_DELETE_MAX_AGE_MS = 14 * 24 * 60 * 60000;
+function snowflakeTime(id) {
+  return Number((BigInt(id) >> 22n) + 1420070400000n);
+}
+
 class ChannelManager extends Manager {
   #rest;
   #context;
   #messageManagers = new Map;
-  constructor(rest) {
+  #messageCache;
+  constructor(rest, options = {}) {
     super();
     this.#rest = rest;
+    this.#messageCache = options.messageCache;
     this.#context = {
       sendMessage: (channelId, options) => this.send(channelId, options),
       editMessage: (channelId, messageId, options) => this.editMessage(channelId, messageId, options),
@@ -2977,27 +4196,29 @@ class ChannelManager extends Manager {
   messages(channelId) {
     let manager = this.#messageManagers.get(channelId);
     if (!manager) {
-      manager = new MessageManager(this.#rest, this.#context, channelId);
+      manager = new MessageManager(this.#rest, this.#context, channelId, this.#messageCache);
       this.#messageManagers.set(channelId, manager);
     }
     return manager;
   }
   permissionOverwrites(channelId) {
-    return new PermissionOverwriteManager(this.#rest, channelId);
+    return new PermissionOverwriteManager(this.#rest, channelId, () => this.get(channelId)?.permissionOverwrites);
   }
   threads(channelId) {
     return new ThreadManager(this.#rest, this.#context, channelId);
   }
-  async fetch(channelId) {
-    return this.upsert(await this.#rest.get(Routes.channel(channelId)));
+  fetch(channelId) {
+    return this.fetchOnce(channelId, async () => createChannel(await this.#rest.get(Routes.channel(channelId)), this.#context), (channel) => this.#merge(channel));
   }
   async resolve(channelId) {
     return this.get(channelId) ?? this.fetch(channelId);
   }
   upsert(data) {
-    const existing = this.get(data.id);
-    const channel = createChannel(data, this.#context);
-    if (existing) {
+    return this.#merge(createChannel(data, this.#context));
+  }
+  #merge(channel) {
+    const existing = this.get(channel.id);
+    if (existing && existing.type === channel.type) {
       Object.assign(existing, channel);
       return existing;
     }
@@ -3007,6 +4228,37 @@ class ChannelManager extends Manager {
   update(channel) {
     return this.set(channel.id, channel);
   }
+  deleteGuildChannels(guildId) {
+    let removed = 0;
+    for (const channel of this.values())
+      if (channel.guildId === guildId && this.delete(channel.id))
+        removed++;
+    return removed;
+  }
+  async endPoll(channelId, messageId) {
+    return this.messages(channelId).upsert(await this.#rest.post(Routes.pollExpire(channelId, messageId)));
+  }
+  async fetchPollVoters(channelId, messageId, answerId, options = {}) {
+    if (options.limit !== undefined && (!Number.isInteger(options.limit) || options.limit < 1 || options.limit > 100))
+      throw new RangeError("Poll voter limit must be 1-100.");
+    const params = new URLSearchParams;
+    if (options.after)
+      params.set("after", options.after);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    const suffix = params.toString();
+    const { users } = await this.#rest.get(`${Routes.pollAnswerVoters(channelId, messageId, answerId)}${suffix ? `?${suffix}` : ""}`);
+    return users.map((user) => new User(user));
+  }
+  async sendSoundboardSound(channelId, options) {
+    await this.#rest.post(Routes.sendSoundboardSound(channelId), {
+      sound_id: options.soundId,
+      source_guild_id: options.sourceGuildId
+    });
+  }
+  cachedMessages(channelId) {
+    return this.#messageManagers.get(channelId);
+  }
   async create(guildId, options) {
     return this.upsert(await this.#rest.post(Routes.guildChannels(guildId), options));
   }
@@ -3050,7 +4302,7 @@ class ChannelManager extends Manager {
     return this.messages(data.channel_id).upsert(data);
   }
   async editMessage(channelId, messageId, options) {
-    return this.messages(channelId).upsert(await this.#rest.patch(Routes.message(channelId, messageId), options));
+    return this.messages(channelId).upsert(await this.#rest.patch(Routes.message(channelId, messageId), toRequest(options)));
   }
   async deleteMessage(channelId, messageId) {
     await this.#rest.delete(Routes.message(channelId, messageId));
@@ -3063,15 +4315,37 @@ class ChannelManager extends Manager {
     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.");
+    const ids = [...new Set(messageIds)];
+    if (ids.length < 1 || ids.length > 100)
+      throw new RangeError("bulkDelete requires between 1 and 100 message IDs.");
+    if (ids.length === 1)
+      return this.deleteMessage(channelId, ids[0]);
+    const cutoff = Date.now() - BULK_DELETE_MAX_AGE_MS;
+    const tooOld = ids.filter((id) => snowflakeTime(id) < cutoff);
+    if (tooOld.length)
+      throw new RangeError(`bulkDelete cannot delete messages older than 14 days: ${tooOld.join(", ")}`);
     await this.#rest.post(Routes.channelBulkDelete(channelId), {
       messages: ids
     });
     for (const id of ids)
       this.messages(channelId).delete(id);
   }
+  async* iterateMessages(channelId, options = {}) {
+    let before = options.before;
+    let remaining = options.limit ?? Infinity;
+    while (remaining > 0) {
+      const page = await this.fetchMessages(channelId, {
+        before,
+        limit: Math.min(100, remaining)
+      });
+      for (const message of page)
+        yield message;
+      remaining -= page.length;
+      if (page.length < 100)
+        return;
+      before = page.at(-1).id;
+    }
+  }
   async addReaction(channelId, messageId, emoji) {
     await this.#rest.put(`${Routes.messageReactions(channelId, messageId, emoji)}/@me`);
   }
@@ -3167,6 +4441,8 @@ class GatewaySession {
       return false;
     if (!Number.isInteger(sequence))
       return false;
+    if (this.#sequence !== null && sequence < this.#sequence)
+      return false;
     this.#sequence = sequence;
     return true;
   }
@@ -3265,8 +4541,11 @@ class GatewayHeartbeat {
     this.#clearBeatTimers();
     this.#interval = interval;
     this.#acknowledged = true;
-    this.#initialTimer = setTimeout(() => this.sendHeartbeat(), Math.random() * interval);
-    this.#timer = setInterval(() => this.sendHeartbeat(), interval);
+    this.#initialTimer = setTimeout(() => {
+      this.#initialTimer = undefined;
+      this.sendHeartbeat();
+      this.#timer = setInterval(() => this.sendHeartbeat(), interval);
+    }, Math.random() * interval);
   }
   stop() {
     this.#clearBeatTimers();
@@ -3292,6 +4571,8 @@ class GatewayHeartbeat {
     }, this.#options.ackTimeout);
   }
   acknowledge() {
+    if (this.#acknowledged)
+      return;
     this.#acknowledged = true;
     this.#latency = this.#now() - this.#sentAt;
     this.#clearAckTimer();
@@ -3860,6 +5141,7 @@ class SendBudget {
 }
 
 // packages/ws/src/index.ts
+var RESUMABLE_CLOSE_CODE = 4900;
 var DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
 
 class Gateway {
@@ -3945,7 +5227,7 @@ class Gateway {
     } else {
       this.#emitError(new GatewayError(`Gateway heartbeat acknowledgement timed out after ${timeout.elapsedMs}ms.`));
     }
-    this.#transport.close(1001, timeout.type === "zombie" ? "Zombie Gateway connection" : "Heartbeat timeout");
+    this.#transport.close(RESUMABLE_CLOSE_CODE, timeout.type === "zombie" ? "Zombie Gateway connection" : "Heartbeat timeout");
   }
   connect(url = DEFAULT_GATEWAY_URL) {
     if (this.state === "CLOSED" /* Closed */)
@@ -4081,7 +5363,7 @@ class Gateway {
         this.#emit("heartbeatAck", action.data);
         return;
       case "reconnect":
-        this.#transport.close(1001, "Server requested reconnect");
+        this.#transport.close(RESUMABLE_CLOSE_CODE, "Server requested reconnect");
         return;
       case "invalid-session": {
         if (!action.resumable)
@@ -4275,6 +5557,7 @@ class Client extends EventEmitter2 {
   channels;
   stageInstances;
   application;
+  monetization;
   get ws() {
     return this.#gateway;
   }
@@ -4306,6 +5589,7 @@ class Client extends EventEmitter2 {
     return this.#gateway.requestGuildMembers(data);
   }
   #gateway;
+  #cache;
   #resourceContext;
   constructor(options) {
     super();
@@ -4313,9 +5597,18 @@ class Client extends EventEmitter2 {
     if (!options.token?.trim())
       throw new TypeError("Client token is required.");
     this.rest = new REST({ token: options.token, ...options.rest });
+    this.#cache = {
+      users: true,
+      members: true,
+      roles: true,
+      emojis: true,
+      ...options.cache
+    };
     this.users = new UserManager(this.rest);
     this.guilds = new GuildManager(this.rest);
-    this.channels = new ChannelManager(this.rest);
+    this.channels = new ChannelManager(this.rest, {
+      messageCache: options.messageCache
+    });
     this.stageInstances = new StageInstanceManager(this.rest);
     const placeholderAppCommands = new ApplicationCommandManager(this.rest, "0");
     this.application = { commands: placeholderAppCommands };
@@ -4331,8 +5624,32 @@ class Client extends EventEmitter2 {
       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)
+      unpinMessage: (channelId, messageId) => this.channels.unpinMessage(channelId, messageId),
+      collectInteractions: (options) => this.createCollector("interactionCreate" /* InteractionCreate */, options),
+      memberPermissions: (guildId, memberId, roleIds, channelId) => this.#memberPermissions(guildId, memberId, roleIds, channelId),
+      kickMember: (guildId, userId, reason) => this.guilds.members(guildId).kick(userId, reason),
+      banMember: (guildId, userId, options) => this.guilds.members(guildId).ban(userId, options),
+      editMember: (guildId, userId, options, reason) => this.guilds.members(guildId).edit(userId, options, reason),
+      addMemberRole: (guildId, userId, roleId, reason) => this.guilds.members(guildId).addRole(userId, roleId, reason),
+      removeMemberRole: (guildId, userId, roleId, reason) => this.guilds.members(guildId).removeRole(userId, roleId, reason),
+      editPermissionOverwrite: async (channelId, targetId, changes, options) => {
+        const bits = { allow: 0n, deny: 0n, inherit: 0n };
+        for (const [name, value] of Object.entries(changes)) {
+          if (!/^[A-Za-z]+$/.test(name))
+            throw new TypeError(`Unknown permission: ${name}`);
+          let bit;
+          try {
+            bit = new PermissionSet(name).bitfield;
+          } catch {
+            throw new TypeError(`Unknown permission: ${name}`);
+          }
+          const key = value === true ? "allow" : value === false ? "deny" : "inherit";
+          bits[key] |= bit;
+        }
+        return this.channels.permissionOverwrites(channelId).update(targetId, bits, options);
+      }
     };
+    this.guilds.attachContext(this.#resourceContext);
     this.#gateway = new Gateway({
       token: options.token,
       intents: options.intents,
@@ -4346,6 +5663,8 @@ class Client extends EventEmitter2 {
       this.state = "ready";
       const appId = ready.application?.id ?? this.user.id;
       this.application.commands = new ApplicationCommandManager(this.rest, appId);
+      if (this.monetization?.applicationId !== appId)
+        this.monetization = new MonetizationManager(this.rest, appId);
       this.emit("ready" /* Ready */, this.user);
     });
     this.#gateway.on("RESUMED", () => {
@@ -4362,19 +5681,46 @@ class Client extends EventEmitter2 {
       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" /* MessageCreate */, message);
+      const payload = data;
+      const message = new Message(payload, this.#resourceContext);
+      this.#observeMessage(message);
+      if (payload.member && payload.guild_id && this.guilds.has(payload.guild_id))
+        this.#upsertMember(payload.guild_id, {
+          ...payload.member,
+          user: payload.member.user ?? payload.author
+        });
+      const cached = this.options.messageCache ? this.channels.messages(message.channelId).upsert(data) : message;
+      this.emit("messageCreate" /* MessageCreate */, cached);
     });
     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" /* MessageUpdate */, message);
+      this.#observeMessage(message);
+      const messages = this.channels.cachedMessages(message.channelId);
+      const previous = messages?.cache.peek(message.id);
+      if (previous)
+        messages.cache.set(message.id, message);
+      this.emit("messageUpdate" /* MessageUpdate */, message, previous);
+    });
+    this.#gateway.on("MESSAGE_DELETE", (data) => {
+      const payload = data;
+      const messages = this.channels.cachedMessages(payload.channel_id);
+      const removed = messages?.cache.peek(payload.id);
+      messages?.delete(payload.id);
+      this.emit("messageDelete" /* MessageDelete */, payload, removed);
+    });
+    this.#gateway.on("MESSAGE_DELETE_BULK", (data) => {
+      const payload = data;
+      const messages = this.channels.cachedMessages(payload.channel_id);
+      const removed = [];
+      if (messages)
+        for (const id of payload.ids) {
+          const message = messages.cache.peek(id);
+          if (message)
+            removed.push(message);
+          messages.delete(id);
+        }
+      this.emit("messageDeleteBulk" /* MessageDeleteBulk */, payload, removed);
     });
-    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));
@@ -4388,20 +5734,27 @@ class Client extends EventEmitter2 {
         return;
       }
       const wasCached = this.guilds.has(payload.id);
-      const guild = new Guild(payload);
-      this.guilds.set(guild.id, guild);
+      this.guilds.patch(payload);
+      for (const role of payload.roles ?? [])
+        this.#upsertRole(payload.id, role);
+      if (this.#cache.emojis) {
+        const emojis = this.guilds.emojis(payload.id);
+        for (const emoji of payload.emojis ?? [])
+          emojis.upsert(emoji);
+      }
       for (const member of payload.members ?? [])
-        this.users.set(member.user.id, new User(member.user));
+        this.#upsertMember(payload.id, member);
+      for (const state of payload.voice_states ?? [])
+        this.#storeVoiceState(payload.id, state);
       for (const channelData of [
         ...payload.channels ?? [],
         ...payload.threads ?? []
       ])
-        this.channels.set(channelData.id, createChannel(channelData, this.#resourceContext));
+        this.channels.upsert({ ...channelData, guild_id: payload.id });
       this.emit(wasCached ? "guildAvailable" /* GuildAvailable */ : "guildCreate" /* GuildCreate */, payload);
     });
     this.#gateway.on("GUILD_UPDATE", (data) => {
-      const guild = new Guild(data);
-      this.guilds.update(guild);
+      this.guilds.patch(data);
       this.emit("guildUpdate" /* GuildUpdate */, data);
     });
     this.#gateway.on("GUILD_DELETE", (data) => {
@@ -4411,45 +5764,158 @@ class Client extends EventEmitter2 {
         return;
       }
       this.guilds.delete(payload.id);
+      this.channels.deleteGuildChannels(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.#upsertMember(member.guild_id, member);
       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.#upsertMember(member.guild_id, member);
       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_MEMBER_REMOVE", (data) => {
+      const member = data;
+      this.guilds.members(member.guild_id).delete(member.user.id);
+      this.emit("guildMemberRemove" /* GuildMemberRemove */, member);
+    });
+    this.#gateway.on("GUILD_MEMBERS_CHUNK", (data) => {
+      const chunk = data;
+      for (const member of chunk.members)
+        this.#upsertMember(chunk.guild_id, member);
+      this.emit("guildMembersChunk" /* GuildMembersChunk */, chunk);
+    });
+    this.#gateway.on("GUILD_BAN_ADD", (data) => {
+      const ban = data;
+      const bans = this.guilds.bans(ban.guild_id);
+      bans.set(ban.user.id, {
+        reason: bans.get(ban.user.id)?.reason ?? null,
+        user: ban.user
+      });
+      this.guilds.members(ban.guild_id).delete(ban.user.id);
+      this.emit("guildBanAdd" /* GuildBanAdd */, ban);
+    });
+    this.#gateway.on("GUILD_BAN_REMOVE", (data) => {
+      const ban = data;
+      this.guilds.bans(ban.guild_id).delete(ban.user.id);
+      this.emit("guildBanRemove" /* GuildBanRemove */, ban);
+    });
+    this.#gateway.on("GUILD_ROLE_CREATE", (data) => {
+      const event = data;
+      this.#upsertRole(event.guild_id, event.role);
+      this.emit("guildRoleCreate" /* GuildRoleCreate */, event);
+    });
+    this.#gateway.on("GUILD_ROLE_UPDATE", (data) => {
+      const event = data;
+      this.#upsertRole(event.guild_id, event.role);
+      this.emit("guildRoleUpdate" /* GuildRoleUpdate */, event);
+    });
+    this.#gateway.on("GUILD_ROLE_DELETE", (data) => {
+      const event = data;
+      this.guilds.roles(event.guild_id).delete(event.role_id);
+      this.emit("guildRoleDelete" /* GuildRoleDelete */, event);
+    });
+    this.#gateway.on("GUILD_EMOJIS_UPDATE", (data) => {
+      const event = data;
+      if (this.#cache.emojis) {
+        const emojis = this.guilds.emojis(event.guild_id);
+        const current = new Set(event.emojis.map((emoji) => emoji.id));
+        for (const id of [...emojis.cache.keys()])
+          if (!current.has(id))
+            emojis.delete(id);
+        for (const emoji of event.emojis)
+          emojis.upsert(emoji);
+      }
+      this.emit("guildEmojisUpdate" /* GuildEmojisUpdate */, event);
+    });
+    this.#gateway.on("GUILD_STICKERS_UPDATE", (data) => {
+      const event = data;
+      this.guilds.stickers(event.guild_id).sync(event.stickers);
+      this.emit("guildStickersUpdate" /* GuildStickersUpdate */, event);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUND_CREATE", (data) => {
+      const sound = data;
+      if (sound.guild_id)
+        this.guilds.soundboard(sound.guild_id).set(sound.sound_id, sound);
+      this.emit("soundboardSoundCreate" /* SoundboardSoundCreate */, sound);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUND_UPDATE", (data) => {
+      const sound = data;
+      if (sound.guild_id)
+        this.guilds.soundboard(sound.guild_id).set(sound.sound_id, sound);
+      this.emit("soundboardSoundUpdate" /* SoundboardSoundUpdate */, sound);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUND_DELETE", (data) => {
+      const event = data;
+      this.guilds.soundboard(event.guild_id).delete(event.sound_id);
+      this.emit("soundboardSoundDelete" /* SoundboardSoundDelete */, event);
+    });
+    this.#gateway.on("GUILD_SOUNDBOARD_SOUNDS_UPDATE", (data) => {
+      const event = data;
+      const sounds = this.guilds.soundboard(event.guild_id);
+      sounds.clear();
+      for (const sound of event.soundboard_sounds)
+        sounds.set(sound.sound_id, sound);
+      this.emit("soundboardSoundsUpdate" /* SoundboardSoundsUpdate */, event);
+    });
+    this.#gateway.on("ENTITLEMENT_CREATE", (data) => {
+      const entitlement = data;
+      this.monetization?.set(entitlement.id, entitlement);
+      this.emit("entitlementCreate" /* EntitlementCreate */, entitlement);
+    });
+    this.#gateway.on("ENTITLEMENT_UPDATE", (data) => {
+      const entitlement = data;
+      this.monetization?.set(entitlement.id, entitlement);
+      this.emit("entitlementUpdate" /* EntitlementUpdate */, entitlement);
+    });
+    this.#gateway.on("ENTITLEMENT_DELETE", (data) => {
+      const entitlement = data;
+      this.monetization?.delete(entitlement.id);
+      this.emit("entitlementDelete" /* EntitlementDelete */, entitlement);
+    });
     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_CREATE", (data) => {
+      const event = data;
+      this.guilds.scheduledEvents(event.guild_id).set(event.id, event);
+      this.emit("guildScheduledEventCreate" /* GuildScheduledEventCreate */, event);
+    });
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_UPDATE", (data) => {
+      const event = data;
+      this.guilds.scheduledEvents(event.guild_id).set(event.id, event);
+      this.emit("guildScheduledEventUpdate" /* GuildScheduledEventUpdate */, event);
+    });
+    this.#gateway.on("GUILD_SCHEDULED_EVENT_DELETE", (data) => {
+      const event = data;
+      this.guilds.scheduledEvents(event.guild_id).delete(event.id);
+      this.emit("guildScheduledEventDelete" /* GuildScheduledEventDelete */, event);
+    });
     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_RULE_CREATE", (data) => {
+      const rule = data;
+      this.guilds.autoModerationRules(rule.guild_id).set(rule.id, rule);
+      this.emit("autoModerationRuleCreate" /* AutoModerationRuleCreate */, rule);
+    });
+    this.#gateway.on("AUTO_MODERATION_RULE_UPDATE", (data) => {
+      const rule = data;
+      this.guilds.autoModerationRules(rule.guild_id).set(rule.id, rule);
+      this.emit("autoModerationRuleUpdate" /* AutoModerationRuleUpdate */, rule);
+    });
+    this.#gateway.on("AUTO_MODERATION_RULE_DELETE", (data) => {
+      const rule = data;
+      this.guilds.autoModerationRules(rule.guild_id).delete(rule.id);
+      this.emit("autoModerationRuleDelete" /* AutoModerationRuleDelete */, rule);
+    });
     this.#gateway.on("AUTO_MODERATION_ACTION_EXECUTION", (data) => this.emit("autoModerationActionExecution" /* AutoModerationActionExecution */, data));
     this.#gateway.on("CHANNEL_CREATE", (data) => {
-      const channel = createChannel(data, this.#resourceContext);
-      this.channels.update(channel);
+      const channel = this.channels.upsert(data);
       this.emit("channelCreate" /* ChannelCreate */, channel);
     });
     this.#gateway.on("CHANNEL_UPDATE", (data) => {
-      const channel = createChannel(data, this.#resourceContext);
-      this.channels.update(channel);
+      const channel = this.channels.upsert(data);
       this.emit("channelUpdate" /* ChannelUpdate */, channel);
     });
     this.#gateway.on("CHANNEL_DELETE", (data) => {
@@ -4459,13 +5925,11 @@ class Client extends EventEmitter2 {
     });
     this.#gateway.on("CHANNEL_PINS_UPDATE", (data) => this.emit("channelPinsUpdate" /* ChannelPinsUpdate */, data));
     this.#gateway.on("THREAD_CREATE", (data) => {
-      const channel = createChannel(data, this.#resourceContext);
-      this.channels.update(channel);
+      const channel = this.channels.upsert(data);
       this.emit("threadCreate" /* ThreadCreate */, channel);
     });
     this.#gateway.on("THREAD_UPDATE", (data) => {
-      const channel = createChannel(data, this.#resourceContext);
-      this.channels.update(channel);
+      const channel = this.channels.upsert(data);
       this.emit("threadUpdate" /* ThreadUpdate */, channel);
     });
     this.#gateway.on("THREAD_DELETE", (data) => {
@@ -4473,16 +5937,48 @@ class Client extends EventEmitter2 {
       this.channels.delete(payload.id);
       this.emit("threadDelete" /* ThreadDelete */, payload);
     });
-    this.#gateway.on("THREAD_LIST_SYNC", (data) => this.emit("threadListSync" /* ThreadListSync */, data));
+    this.#gateway.on("THREAD_LIST_SYNC", (data) => {
+      const sync = data;
+      for (const thread of sync.threads)
+        this.channels.upsert({ ...thread, guild_id: sync.guild_id });
+      this.emit("threadListSync" /* ThreadListSync */, sync);
+    });
     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("STAGE_INSTANCE_CREATE", (data) => {
+      const stage = data;
+      this.stageInstances.set(stage.channel_id, stage);
+      this.emit("stageInstanceCreate" /* StageInstanceCreate */, stage);
+    });
+    this.#gateway.on("STAGE_INSTANCE_UPDATE", (data) => {
+      const stage = data;
+      this.stageInstances.set(stage.channel_id, stage);
+      this.emit("stageInstanceUpdate" /* StageInstanceUpdate */, stage);
+    });
+    this.#gateway.on("STAGE_INSTANCE_DELETE", (data) => {
+      const stage = data;
+      this.stageInstances.delete(stage.channel_id);
+      this.emit("stageInstanceDelete" /* StageInstanceDelete */, stage);
+    });
+    this.#gateway.on("INVITE_CREATE", (data) => {
+      const invite = data;
+      if (invite.guild_id)
+        this.guilds.invites(invite.guild_id).set(invite.code, invite);
+      this.emit("inviteCreate" /* InviteCreate */, invite);
+    });
+    this.#gateway.on("INVITE_DELETE", (data) => {
+      const invite = data;
+      if (invite.guild_id)
+        this.guilds.invites(invite.guild_id).delete(invite.code);
+      this.emit("inviteDelete" /* InviteDelete */, invite);
+    });
     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_STATE_UPDATE", (data) => {
+      const state = data;
+      if (state.guild_id)
+        this.#storeVoiceState(state.guild_id, state);
+      this.emit("voiceStateUpdate" /* VoiceStateUpdate */, state);
+    });
     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));
@@ -4490,6 +5986,103 @@ class Client extends EventEmitter2 {
     this.#gateway.on("RAW", (data) => this.emit("raw" /* Raw */, data));
     this.#gateway.on("error", (error) => this.emit("error" /* Error */, error));
   }
+  #observeMessage(message) {
+    if (!this.channels.has(message.channelId))
+      this.channels.set(message.channelId, message.channel);
+    if (this.#cache.users)
+      this.#merge(this.users, message.author.id, message.author);
+  }
+  #upsertMember(guildId, data) {
+    const member = new GuildMember({ ...data, guild_id: guildId }, this.#resourceContext);
+    if (this.#cache.users)
+      this.#merge(this.users, member.user.id, member.user);
+    if (!this.#cache.members)
+      return member;
+    return this.#merge(this.guilds.members(guildId), member.user.id, member);
+  }
+  #storeVoiceState(guildId, state) {
+    const states = this.guilds.voiceStates(guildId);
+    if (state.channel_id)
+      states.set(state.user_id, state);
+    else
+      states.delete(state.user_id);
+  }
+  #upsertRole(guildId, data) {
+    if (!this.#cache.roles)
+      return new Role(data);
+    return this.#merge(this.guilds.roles(guildId), data.id, new Role(data));
+  }
+  #merge(manager, id, next) {
+    const existing = manager.get(id);
+    if (!existing) {
+      manager.set(id, next);
+      return next;
+    }
+    for (const [key, value] of Object.entries(next))
+      if (value !== undefined)
+        existing[key] = value;
+    return existing;
+  }
+  createCollector(event, options = {}) {
+    const collector = new Collector(options);
+    let order = 0;
+    const listener = (...args) => {
+      const item = args[0];
+      const id = item?.id;
+      const key = options.key?.(item) ?? (typeof id === "string" ? id : String(order++));
+      collector.handle(key, item).catch((error) => this.emit("error" /* Error */, error instanceof Error ? error : new Error(String(error))));
+    };
+    this.on(event, listener);
+    collector.onDispose(() => this.off(event, listener));
+    return collector;
+  }
+  get resourceContext() {
+    return this.#resourceContext;
+  }
+  #memberPermissions(guildId, memberId, roleIds, channelId) {
+    const guild = this.guilds.get(guildId);
+    if (!guild)
+      return null;
+    let channel = channelId ? this.channels.get(channelId) : undefined;
+    if (channelId) {
+      if (channel?.isThread())
+        channel = channel.parentId ? this.channels.get(channel.parentId) : undefined;
+      if (!channel || channel.guildId !== guildId)
+        return null;
+    }
+    return computePermissions({
+      guildId,
+      ownerId: guild.ownerId,
+      memberId,
+      memberRoleIds: [...roleIds],
+      roles: this.guilds.roles(guildId).values(),
+      overwrites: channel?.permissionOverwrites
+    });
+  }
+  permissionsFor(memberId, guildOrChannelId) {
+    let channel = this.channels.get(guildOrChannelId);
+    if (channel?.isThread()) {
+      channel = channel.parentId ? this.channels.get(channel.parentId) : undefined;
+      if (!channel)
+        return null;
+    }
+    const guildId = channel?.guildId ?? guildOrChannelId;
+    const guild = this.guilds.get(guildId);
+    const member = this.guilds.members(guildId).get(memberId);
+    if (!guild || !member)
+      return null;
+    return computePermissions({
+      guildId,
+      ownerId: guild.ownerId,
+      memberId,
+      memberRoleIds: member.roleIds,
+      roles: this.guilds.roles(guildId).values(),
+      overwrites: channel?.permissionOverwrites
+    });
+  }
+  fetchDefaultSoundboardSounds() {
+    return this.rest.get(Routes.soundboardDefaultSounds());
+  }
   async login(token) {
     if (this.state === "destroyed")
       throw new Error("Cannot login a destroyed client.");
@@ -4509,12 +6102,21 @@ class Client extends EventEmitter2 {
     this.#gateway.close();
   }
   postInteractionResponse(id, token, response) {
-    return this.rest.post(Routes.interactionCallback(id, token), response.toJSON());
+    const json = response.toJSON();
+    const upload = json.data ? toRequest(json.data) : undefined;
+    if (upload && typeof upload === "object" && "files" in upload) {
+      const { body, files } = upload;
+      return this.rest.post(Routes.interactionCallback(id, token), {
+        body: { ...json, data: body },
+        files
+      });
+    }
+    return this.rest.post(Routes.interactionCallback(id, token), json);
   }
   editInteractionReply(token, data) {
     if (!this.user)
       return Promise.reject(new Error("Client is unauthenticated."));
-    return this.rest.patch(Routes.interactionOriginalResponse(this.user.id, token), data);
+    return this.rest.patch(Routes.interactionOriginalResponse(this.user.id, token), toRequest(data));
   }
   deleteInteractionReply(token) {
     if (!this.user)
@@ -4524,7 +6126,15 @@ class Client extends EventEmitter2 {
   followUpInteraction(token, data) {
     if (!this.user)
       return Promise.reject(new Error("Client is unauthenticated."));
-    return this.rest.post(`/webhooks/${this.user.id}/${token}`, data);
+    return this.rest.post(`/webhooks/${this.user.id}/${token}`, toRequest(data));
+  }
+  interactionWebhookMessage(method, applicationId, token, messageId, data) {
+    const path = messageId === "@original" ? Routes.interactionOriginalResponse(applicationId, token) : Routes.webhookMessage(applicationId, token, messageId);
+    if (method === "GET")
+      return this.rest.get(path);
+    if (method === "PATCH")
+      return this.rest.patch(path, data);
+    return this.rest.delete(path);
   }
   fetchWebhook(id, token) {
     return this.rest.get(token ? `/webhooks/${id}/${token}` : `/webhooks/${id}`);
@@ -4583,7 +6193,8 @@ export {
   PermissionSet,
   Permissions,
   PermissionsBitField,
+  computePermissions,
   resolveGatewayIntents
 };
 
-//# debugId=B9E28396E97D857564756E2164756E21
+//# debugId=C58DF09843ED07E364756E2164756E21