lunibee 0.3.3 → 0.4.0

package/dist/chunks/index-jzg4bh99.js

@@ -0,0 +1,1533 @@
+// @bun
+import {
+  Collection2
+} from "./index-cnmsajvk.js";
+import {
+  Routes2
+} from "./index-7fp2hvmg.js";
+import {
+  User2,
+  Guild2,
+  GuildMember2,
+  Role2,
+  Emoji2,
+  AutoModerationRule2,
+  createChannel2,
+  AuditLog2,
+  Message2
+} from "./index-57c5n3ms.js";
+
+// packages/managers/src/base.ts
+function assignFields(into, from) {
+  const target = into;
+  const source = from;
+  for (const key of Object.keys(source))
+    target[key] = source[key];
+  return into;
+}
+function splitReason(options) {
+  const { reason, ...payload } = options;
+  return [payload, reason];
+}
+
+class Manager2 {
+  cache;
+  #bounded;
+  constructor(maxSize) {
+    this.#bounded = maxSize !== undefined;
+    this.cache = new Collection2(null, { maxSize });
+  }
+  get(id) {
+    return this.cache.get(id);
+  }
+  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.#markDirty(id);
+    if (this.#bounded)
+      this.cache.set(id, value);
+    else
+      this.cache.setWithoutTTL(id, value);
+    return this;
+  }
+  delete(id) {
+    this.#markDirty(id);
+    return this.cache.delete(id);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  first() {
+    return this.cache.first();
+  }
+  values() {
+    return this.cache.array();
+  }
+  find(predicate) {
+    return this.cache.find(predicate);
+  }
+  [Symbol.iterator]() {
+    return this.cache[Symbol.iterator]();
+  }
+}
+
+class ResourceManager2 extends Manager2 {
+  #fetcher;
+  #key;
+  constructor(fetcher, key, maxSize) {
+    super(maxSize);
+    if (typeof fetcher !== "function" || typeof key !== "function")
+      throw new TypeError("ResourceManager requires fetcher and key functions.");
+    this.#fetcher = fetcher;
+    this.#key = key;
+  }
+  async resolve(id) {
+    return this.get(id) ?? this.fetch(id);
+  }
+  fetch(id) {
+    return this.fetchOnce(id, () => this.#fetcher(id), (value) => this.upsert(value));
+  }
+  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) {
+      assignFields(existing, resource);
+      this.set(key, existing);
+      return existing;
+    }
+    this.set(key, resource);
+    return resource;
+  }
+  update(resource) {
+    return this.upsert(resource);
+  }
+}
+// packages/managers/src/message.ts
+function toAttachments(files) {
+  return files.map((file) => ("toBuffer" in file) ? { name: file.name, data: file.toBuffer() } : {
+    name: file.name,
+    data: typeof file.data === "string" ? new TextEncoder().encode(file.data) : file.data,
+    contentType: file.contentType
+  });
+}
+function assertAllowedMentions(mentions) {
+  const parse = mentions.parse ?? [];
+  for (const kind of parse)
+    if (!["roles", "users", "everyone"].includes(kind))
+      throw new TypeError(`allowed_mentions.parse has unknown value "${String(kind)}".`);
+  for (const [kind, list] of [
+    ["users", mentions.users],
+    ["roles", mentions.roles]
+  ]) {
+    if (list === undefined)
+      continue;
+    if (!Array.isArray(list) || list.some((id) => typeof id !== "string"))
+      throw new TypeError(`allowed_mentions.${kind} must be an array of ID strings.`);
+    if (list.length > 100)
+      throw new RangeError(`allowed_mentions.${kind} holds at most 100 IDs.`);
+    if (list.length > 0 && parse.includes(kind))
+      throw new TypeError(`allowed_mentions cannot list ${kind} by ID and also parse "${kind}".`);
+  }
+}
+function toRequest2(options, allowedMentions) {
+  const { files, ...body } = options;
+  if (allowedMentions !== undefined && body.allowed_mentions === undefined)
+    body.allowed_mentions = allowedMentions;
+  if (body.allowed_mentions)
+    assertAllowedMentions(body.allowed_mentions);
+  if (!files?.length)
+    return { body };
+  if (body.attachments === undefined && files.some((f) => f.description))
+    body.attachments = files.map((file, id) => file.description ? { id, description: file.description } : { id });
+  return {
+    body,
+    files: toAttachments(files)
+  };
+}
+
+class MessageManager2 {
+  cache;
+  #caching;
+  #rest;
+  #context;
+  #channelId;
+  #allowedMentions;
+  constructor(rest, context, channelId, cache, allowedMentions) {
+    if (!channelId)
+      throw new TypeError("Channel ID is required.");
+    this.#allowedMentions = allowedMentions;
+    this.#rest = rest;
+    this.#context = context;
+    this.#channelId = channelId;
+    this.#caching = cache !== undefined;
+    this.cache = new Collection2(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 { body, files } = toRequest2(options, this.#allowedMentions);
+    const data = await this.#rest.post(Routes2.channelMessages(this.#channelId), body, { files });
+    return this.upsert(data);
+  }
+  #inflight = new Map;
+  fetch(messageId) {
+    const pending = this.#inflight.get(messageId);
+    if (pending)
+      return pending.promise;
+    const entry = {
+      promise: Promise.resolve(null),
+      dirty: false
+    };
+    this.#inflight.set(messageId, entry);
+    entry.promise = this.#rest.get(Routes2.message(this.#channelId, messageId)).then((data) => {
+      this.#inflight.delete(messageId);
+      return entry.dirty ? this.cache.peek(messageId) ?? new Message2(data, this.#context) : this.upsert(data);
+    }, (error) => {
+      this.#inflight.delete(messageId);
+      throw error;
+    });
+    return entry.promise;
+  }
+  #markDirty(messageId) {
+    const pending = this.#inflight.get(messageId);
+    if (pending)
+      pending.dirty = true;
+  }
+  set(messageId, message) {
+    this.#markDirty(messageId);
+    if (this.#caching)
+      this.cache.set(messageId, message);
+    return this;
+  }
+  fetchMany(messageIds) {
+    return Promise.all(Array.from(messageIds, (messageId) => this.fetch(messageId)));
+  }
+  upsert(data) {
+    this.#markDirty(data.id);
+    const existing = this.cache.peek(data.id);
+    const message = new Message2(data, this.#context);
+    if (existing) {
+      assignFields(existing, message);
+      return existing;
+    }
+    if (this.#caching)
+      this.cache.set(message.id, message);
+    return message;
+  }
+  delete(messageId) {
+    this.#markDirty(messageId);
+    return this.cache.delete(messageId);
+  }
+}
+
+// packages/managers/src/thread.ts
+class ThreadManager2 {
+  #rest;
+  #context;
+  #channelId;
+  #allowedMentions;
+  constructor(rest, context, channelId, allowedMentions) {
+    if (!channelId)
+      throw new TypeError("Channel ID is required.");
+    this.#rest = rest;
+    this.#context = context;
+    this.#channelId = channelId;
+    this.#allowedMentions = allowedMentions;
+  }
+  async createFromMessage(messageId, options) {
+    const data = await this.#rest.post(Routes2.messageThread(this.#channelId, messageId), {
+      name: options.name,
+      auto_archive_duration: options.autoArchiveDuration,
+      rate_limit_per_user: options.rateLimitPerUser
+    });
+    return createChannel2(data, this.#context);
+  }
+  async create(options) {
+    const data = await this.#rest.post(Routes2.channelThreads(this.#channelId), {
+      name: options.name,
+      type: options.type ?? 12,
+      auto_archive_duration: options.autoArchiveDuration,
+      rate_limit_per_user: options.rateLimitPerUser,
+      invitable: options.invitable
+    }, { reason: options.reason });
+    return createChannel2(data, this.#context);
+  }
+  async createForumPost(options) {
+    const { message, appliedTags, reason, ...thread } = options;
+    const { body: content, files } = toRequest2(message, this.#allowedMentions);
+    const data = await this.#rest.post(Routes2.channelThreads(this.#channelId), {
+      name: thread.name,
+      auto_archive_duration: thread.autoArchiveDuration,
+      rate_limit_per_user: thread.rateLimitPerUser,
+      applied_tags: appliedTags,
+      message: content
+    }, { files, reason });
+    return createChannel2(data, this.#context);
+  }
+  async fetchArchived(scope, options = {}) {
+    const route = scope === "public" ? Routes2.channelPublicArchivedThreads(this.#channelId) : scope === "private" ? Routes2.channelPrivateArchivedThreads(this.#channelId) : Routes2.channelJoinedPrivateArchivedThreads(this.#channelId);
+    const params = new URLSearchParams;
+    if (options.before)
+      params.set("before", options.before);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
+    const query = params.toString();
+    const page = await this.#rest.get(`${route}${query ? `?${query}` : ""}`);
+    return {
+      threads: page.threads.map((thread) => createChannel2(thread, this.#context)),
+      members: page.members,
+      hasMore: page.has_more
+    };
+  }
+  async join(threadId) {
+    await this.#rest.put(Routes2.threadMember(threadId, "@me"));
+  }
+  async leave(threadId) {
+    await this.#rest.delete(Routes2.threadMember(threadId, "@me"));
+  }
+  async addMember(threadId, userId) {
+    await this.#rest.put(Routes2.threadMember(threadId, userId));
+  }
+  async removeMember(threadId, userId) {
+    await this.#rest.delete(Routes2.threadMember(threadId, userId));
+  }
+  async fetchMember(threadId, userId, query = {}) {
+    const suffix = query.withMember ? "?with_member=true" : "";
+    return this.#rest.get(`${Routes2.threadMember(threadId, userId)}${suffix}`);
+  }
+  async fetchMembers(threadId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.withMember)
+      params.set("with_member", "true");
+    if (options.after)
+      params.set("after", options.after);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
+    const query = params.toString();
+    return this.#rest.get(`${Routes2.threadMembers(threadId)}${query ? `?${query}` : ""}`);
+  }
+}
+
+// packages/managers/src/user.ts
+class UserManager2 extends ResourceManager2 {
+  #rest;
+  constructor(rest, options = {}) {
+    super(async (id) => new User2(await rest.get(Routes2.userById(id))), (user) => user.id, options.maxSize);
+    this.#rest = rest;
+  }
+  async fetchMe() {
+    const data = await this.#rest.get("/users/@me");
+    return this.upsert(new User2(data));
+  }
+  async editMe(options) {
+    const data = await this.#rest.patch("/users/@me", options);
+    return this.upsert(new User2(data));
+  }
+  async fetchGuilds(options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(200, Math.max(1, options.limit))));
+    if (options.before)
+      params.set("before", options.before);
+    if (options.after)
+      params.set("after", options.after);
+    if (options.withCounts)
+      params.set("with_counts", "true");
+    const query = params.toString();
+    return this.#rest.get(`${Routes2.userGuilds()}${query ? `?${query}` : ""}`);
+  }
+  async leaveGuild(guildId) {
+    await this.#rest.delete(Routes2.currentUserGuild(guildId));
+  }
+  async createDM(userId) {
+    return this.#rest.post("/users/@me/channels", {
+      recipient_id: userId
+    });
+  }
+}
+// packages/managers/src/emoji.ts
+class EmojiManager2 extends Manager2 {
+  #rest;
+  #guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.#guildId = guildId;
+  }
+  fetch(emojiId) {
+    return this.fetchOnce(emojiId, async () => new Emoji2(await this.#rest.get(Routes2.guildEmoji(this.#guildId, emojiId))), (emoji) => this.#merge(emojiId, emoji));
+  }
+  async fetchAll() {
+    const data = await this.#rest.get(Routes2.guildEmoji(this.#guildId));
+    return data.map((item) => this.upsert(item));
+  }
+  async create(options) {
+    const [payload, reason] = splitReason(options);
+    return this.upsert(await this.#rest.post(Routes2.guildEmoji(this.#guildId), payload, { reason }));
+  }
+  async edit(emojiId, options) {
+    const [payload, reason] = splitReason(options);
+    return this.upsert(await this.#rest.patch(Routes2.guildEmoji(this.#guildId, emojiId), payload, { reason }));
+  }
+  async remove(emojiId, reason) {
+    await this.#rest.delete(Routes2.guildEmoji(this.#guildId, emojiId), {
+      reason
+    });
+    this.delete(emojiId);
+  }
+  upsert(data) {
+    const key = data.id != null ? data.id : `unicode:${data.name ?? ""}`;
+    return this.#merge(key, new Emoji2(data));
+  }
+  #merge(key, emoji) {
+    const existing = this.get(key);
+    if (existing) {
+      assignFields(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 GuildStickerManager2 extends Manager2 {
+  #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(Routes2.guildSticker(this.guildId));
+    this.clear();
+    return stickers.map((sticker) => this.#store(sticker));
+  }
+  async fetch(stickerId) {
+    return this.#store(await this.#rest.get(Routes2.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(Routes2.guildSticker(this.guildId), form, { reason: options.reason }));
+  }
+  async edit(stickerId, options) {
+    const { reason, ...body } = options;
+    return this.#store(await this.#rest.patch(Routes2.guildSticker(this.guildId, stickerId), body, { reason }));
+  }
+  async remove(stickerId, reason) {
+    await this.#rest.delete(Routes2.guildSticker(this.guildId, stickerId), {
+      reason
+    });
+    this.delete(stickerId);
+  }
+  sync(stickers) {
+    this.clear();
+    for (const sticker of stickers)
+      this.#store(sticker);
+  }
+}
+
+class GuildSoundboardManager2 extends Manager2 {
+  #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(Routes2.guildSoundboardSound(this.guildId));
+    this.clear();
+    return items.map((sound) => this.#store(sound));
+  }
+  async fetch(soundId) {
+    return this.#store(await this.#rest.get(Routes2.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(Routes2.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(Routes2.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(Routes2.guildSoundboardSound(this.guildId, soundId), { reason });
+    this.delete(soundId);
+  }
+}
+
+class MonetizationManager2 extends Manager2 {
+  #rest;
+  applicationId;
+  constructor(rest, applicationId) {
+    super();
+    this.#rest = rest;
+    this.applicationId = applicationId;
+  }
+  fetchSkus() {
+    return this.#rest.get(Routes2.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(Routes2.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(Routes2.applicationEntitlement(this.applicationId, entitlementId));
+    this.set(entitlement.id, entitlement);
+    return entitlement;
+  }
+  async consume(entitlementId) {
+    await this.#rest.post(Routes2.consumeEntitlement(this.applicationId, entitlementId));
+    const cached = this.get(entitlementId);
+    if (cached)
+      cached.consumed = true;
+  }
+  async createTestEntitlement(options) {
+    const entitlement = await this.#rest.post(Routes2.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(Routes2.applicationEntitlement(this.applicationId, entitlementId));
+    this.delete(entitlementId);
+  }
+  fetchSubscriptions(skuId, query = {}) {
+    return this.#rest.get(withQuery(Routes2.skuSubscription(skuId), {
+      user_id: query.userId,
+      before: query.before,
+      after: query.after,
+      limit: query.limit
+    }));
+  }
+  fetchSubscription(skuId, subscriptionId) {
+    return this.#rest.get(Routes2.skuSubscription(skuId, subscriptionId));
+  }
+}
+
+class ApplicationEmojiManager2 extends Manager2 {
+  #rest;
+  applicationId;
+  constructor(rest, applicationId) {
+    super();
+    this.#rest = rest;
+    this.applicationId = applicationId;
+  }
+  #store(emoji) {
+    if (emoji.id)
+      this.set(emoji.id, emoji);
+    return emoji;
+  }
+  async fetchAll() {
+    const { items } = await this.#rest.get(Routes2.applicationEmoji(this.applicationId));
+    this.clear();
+    return items.map((emoji) => this.#store(emoji));
+  }
+  async fetch(emojiId) {
+    return this.#store(await this.#rest.get(Routes2.applicationEmoji(this.applicationId, emojiId)));
+  }
+  async create(options) {
+    return this.#store(await this.#rest.post(Routes2.applicationEmoji(this.applicationId), options));
+  }
+  async edit(emojiId, options) {
+    return this.#store(await this.#rest.patch(Routes2.applicationEmoji(this.applicationId, emojiId), options));
+  }
+  async remove(emojiId) {
+    await this.#rest.delete(Routes2.applicationEmoji(this.applicationId, emojiId));
+    this.delete(emojiId);
+  }
+}
+
+// packages/managers/src/member.ts
+class GuildMemberManager2 extends ResourceManager2 {
+  #rest;
+  #context;
+  guildId;
+  constructor(guildId, rest, context = () => {
+    return;
+  }, maxSize) {
+    super((id) => rest.get(Routes2.guildMember(guildId, id)).then((data) => new GuildMember2({ ...data, guild_id: guildId }, context())), (member) => member.user.id, maxSize);
+    this.guildId = guildId;
+    this.#rest = rest;
+    this.#context = context;
+  }
+  async search(query, limit = 1) {
+    if (!query.trim())
+      throw new TypeError("A search query is required.");
+    const params = new URLSearchParams({
+      query,
+      limit: String(Math.min(1000, Math.max(1, limit)))
+    });
+    const found = await this.#rest.get(`${Routes2.guildMembersSearch(this.guildId)}?${params}`);
+    return found.map((data) => {
+      return this.upsert(new GuildMember2({ ...data, guild_id: this.guildId }, this.#context()));
+    });
+  }
+  async editMe(options) {
+    const [payload, reason] = splitReason(options);
+    const data = await this.#rest.patch(Routes2.guildMemberMe(this.guildId), payload, { reason });
+    return this.upsert(new GuildMember2({ ...data, guild_id: this.guildId }, this.#context()));
+  }
+  async kick(userId, reason) {
+    await this.#rest.delete(Routes2.guildMember(this.guildId, userId), {
+      reason
+    });
+    this.delete(userId);
+  }
+  async ban(userId, options = {}) {
+    await this.#rest.put(Routes2.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
+    this.delete(userId);
+  }
+  async unban(userId, reason) {
+    await this.#rest.delete(Routes2.guildBan(this.guildId, userId), {
+      reason
+    });
+  }
+  async edit(userId, options) {
+    const [payload, optionsReason] = splitReason(options);
+    const data = await this.#rest.patch(Routes2.guildMember(this.guildId, userId), payload, {
+      reason: optionsReason
+    });
+    return this.upsert(new GuildMember2({ ...data, guild_id: this.guildId }, this.#context()));
+  }
+  async addRole(userId, roleId, reason) {
+    await this.#rest.put(Routes2.guildMemberRole(this.guildId, userId, roleId), undefined, { reason });
+  }
+  async removeRole(userId, roleId, reason) {
+    await this.#rest.delete(Routes2.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 RoleManager2 extends ResourceManager2 {
+  #rest;
+  guildId;
+  constructor(guildId, rest) {
+    super((id) => rest.get(Routes2.guildRole(guildId, id)).then((data) => new Role2(data)), (role) => role.id);
+    this.guildId = guildId;
+    this.#rest = rest;
+  }
+  async fetchAll() {
+    const data = await this.#rest.get(Routes2.guildRoles(this.guildId));
+    return data.map((item) => this.upsert(new Role2(item)));
+  }
+  async create(options) {
+    const { reason, ...payload } = options;
+    const data = await this.#rest.post(Routes2.guildRoles(this.guildId), rolePayload(payload), { reason });
+    return this.#store(data);
+  }
+  async edit(roleId, options) {
+    const { reason, ...payload } = options;
+    const data = await this.#rest.patch(Routes2.guildRole(this.guildId, roleId), rolePayload(payload), { reason });
+    return this.#store(data);
+  }
+  #store(data) {
+    return this.upsert(new Role2(data));
+  }
+  async remove(roleId, reason) {
+    await this.#rest.delete(Routes2.guildRole(this.guildId, roleId), {
+      reason
+    });
+    this.delete(roleId);
+  }
+  async setPositions(positions, reason) {
+    const data = await this.#rest.patch(Routes2.guildRoles(this.guildId), positions.map(({ id, position }) => ({ id, position })), { reason });
+    return data.map((item) => this.upsert(new Role2(item)));
+  }
+}
+function rolePayload(options) {
+  const { permissions, colors, unicodeEmoji, ...rest } = options;
+  return {
+    ...rest,
+    permissions: permissions !== undefined ? String(permissions) : undefined,
+    colors: colors && {
+      primary_color: colors.primary,
+      secondary_color: colors.secondary ?? null,
+      tertiary_color: colors.tertiary ?? null
+    },
+    unicode_emoji: unicodeEmoji
+  };
+}
+
+// packages/managers/src/guild-resources.ts
+function withQuery2(path, params) {
+  const query = new URLSearchParams;
+  for (const [key, value] of Object.entries(params))
+    if (value !== undefined)
+      query.set(key, String(value));
+  const suffix = query.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+class GuildBanManager2 extends Manager2 {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  async fetch(userId) {
+    const ban = await this.#rest.get(Routes2.guildBan(this.guildId, userId));
+    this.set(ban.user.id, ban);
+    return ban;
+  }
+  async fetchAll(options = {}) {
+    const limit = options.limit === undefined ? undefined : Math.min(1000, Math.max(1, options.limit));
+    const bans = await this.#rest.get(withQuery2(Routes2.guildBans(this.guildId), {
+      limit,
+      before: options.before,
+      after: options.after
+    }));
+    for (const ban of bans)
+      this.set(ban.user.id, ban);
+    return bans;
+  }
+  async create(userId, options = {}) {
+    await this.#rest.put(Routes2.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
+  }
+  async bulk(userIds, options = {}) {
+    if (userIds.length < 1 || userIds.length > 200)
+      throw new RangeError("Bulk ban takes 1 to 200 user IDs.");
+    const result = await this.#rest.post(Routes2.guildBulkBan(this.guildId), {
+      user_ids: userIds,
+      delete_message_seconds: options.deleteMessageSeconds
+    }, { reason: options.reason });
+    return {
+      banned: result.banned_users ?? [],
+      failed: result.failed_users ?? []
+    };
+  }
+  async remove(userId, reason) {
+    await this.#rest.delete(Routes2.guildBan(this.guildId, userId), {
+      reason
+    });
+    this.delete(userId);
+  }
+}
+
+class GuildScheduledEventManager2 extends Manager2 {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(event) {
+    this.set(event.id, event);
+    return event;
+  }
+  async fetch(eventId, options = {}) {
+    return this.#store(await this.#rest.get(withQuery2(Routes2.guildScheduledEvent(this.guildId, eventId), {
+      with_user_count: options.withUserCount
+    })));
+  }
+  async fetchAll(options = {}) {
+    const events = await this.#rest.get(withQuery2(Routes2.guildScheduledEvents(this.guildId), {
+      with_user_count: options.withUserCount
+    }));
+    return events.map((event) => this.#store(event));
+  }
+  async create(options) {
+    const [payload, optionsReason] = splitReason(options);
+    return this.#store(await this.#rest.post(Routes2.guildScheduledEvents(this.guildId), payload, { reason: optionsReason }));
+  }
+  async edit(eventId, options) {
+    const [payload, optionsReason] = splitReason(options);
+    return this.#store(await this.#rest.patch(Routes2.guildScheduledEvent(this.guildId, eventId), payload, { reason: optionsReason }));
+  }
+  async remove(eventId, reason) {
+    await this.#rest.delete(Routes2.guildScheduledEvent(this.guildId, eventId), { reason });
+    this.delete(eventId);
+  }
+  async fetchSubscribers(eventId, options = {}) {
+    const limit = options.limit === undefined ? undefined : Math.min(100, Math.max(1, options.limit));
+    return this.#rest.get(withQuery2(Routes2.guildScheduledEventUsers(this.guildId, eventId), {
+      limit,
+      with_member: options.withMember,
+      before: options.before,
+      after: options.after
+    }));
+  }
+}
+
+class StageInstanceManager2 extends Manager2 {
+  #rest;
+  constructor(rest) {
+    super();
+    this.#rest = rest;
+  }
+  #store(stage) {
+    this.set(stage.channel_id, stage);
+    return stage;
+  }
+  async create(channelId, options) {
+    return this.#store(await this.#rest.post(Routes2.stageInstances(), {
+      channel_id: channelId,
+      topic: options.topic,
+      privacy_level: options.privacyLevel,
+      send_start_notification: options.sendStartNotification,
+      guild_scheduled_event_id: options.guildScheduledEventId
+    }, { reason: options.reason }));
+  }
+  async fetch(channelId) {
+    return this.#store(await this.#rest.get(Routes2.stageInstanceByChannel(channelId)));
+  }
+  async edit(channelId, options) {
+    return this.#store(await this.#rest.patch(Routes2.stageInstanceByChannel(channelId), { topic: options.topic, privacy_level: options.privacyLevel }, { reason: options.reason }));
+  }
+  async remove(channelId, reason) {
+    await this.#rest.delete(Routes2.stageInstanceByChannel(channelId), {
+      reason
+    });
+    this.delete(channelId);
+  }
+}
+
+class PermissionOverwriteManager2 {
+  #rest;
+  #current;
+  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(Routes2.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,
+      reason: options.reason
+    });
+  }
+  async edit(overwriteId, options) {
+    await this.#rest.put(Routes2.channelPermission(this.channelId, overwriteId), {
+      type: options.type,
+      allow: BigInt(options.allow ?? 0).toString(),
+      deny: BigInt(options.deny ?? 0).toString()
+    }, { reason: options.reason });
+  }
+  async remove(overwriteId, reason) {
+    await this.#rest.delete(Routes2.channelPermission(this.channelId, overwriteId), { reason });
+  }
+}
+
+// packages/managers/src/guild.ts
+function withQuery3(path, params) {
+  const suffix = params.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+class GuildManager2 extends ResourceManager2 {
+  #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;
+  #presences = 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;
+  }
+  #maxMembers;
+  constructor(rest, options = {}) {
+    super(async (id) => new Guild2(await rest.get(Routes2.guild(id))), (guild) => guild.id);
+    this.#rest = rest;
+    this.#maxMembers = options.maxMembers;
+  }
+  bans(guildId) {
+    let manager = this.#bans.get(guildId);
+    if (!manager)
+      this.#bans.set(guildId, manager = new GuildBanManager2(this.#rest, guildId));
+    return manager;
+  }
+  scheduledEvents(guildId) {
+    let manager = this.#scheduledEvents.get(guildId);
+    if (!manager)
+      this.#scheduledEvents.set(guildId, manager = new GuildScheduledEventManager2(this.#rest, guildId));
+    return manager;
+  }
+  members(guildId) {
+    let manager = this.#members.get(guildId);
+    if (!manager)
+      this.#members.set(guildId, manager = new GuildMemberManager2(guildId, this.#rest, () => this.#context, this.#maxMembers));
+    return manager;
+  }
+  roles(guildId) {
+    let manager = this.#roles.get(guildId);
+    if (!manager)
+      this.#roles.set(guildId, manager = new RoleManager2(guildId, this.#rest));
+    return manager;
+  }
+  emojis(guildId) {
+    let manager = this.#emojis.get(guildId);
+    if (!manager)
+      this.#emojis.set(guildId, manager = new EmojiManager2(this.#rest, guildId));
+    return manager;
+  }
+  stickers(guildId) {
+    let manager = this.#stickers.get(guildId);
+    if (!manager)
+      this.#stickers.set(guildId, manager = new GuildStickerManager2(this.#rest, guildId));
+    return manager;
+  }
+  soundboard(guildId) {
+    let manager = this.#soundboard.get(guildId);
+    if (!manager)
+      this.#soundboard.set(guildId, manager = new GuildSoundboardManager2(this.#rest, guildId));
+    return manager;
+  }
+  voiceStates(guildId) {
+    return this.#perGuild(this.#voiceStates, guildId, () => new Manager2);
+  }
+  presences(guildId) {
+    return this.#perGuild(this.#presences, guildId, () => new Manager2);
+  }
+  autoModerationRules(guildId) {
+    return this.#perGuild(this.#autoModerationRules, guildId, () => new Manager2);
+  }
+  invites(guildId) {
+    return this.#perGuild(this.#invites, guildId, () => new Manager2);
+  }
+  patch(data) {
+    const guild = new Guild2(data);
+    const existing = this.get(guild.id);
+    if (!existing)
+      return this.upsert(guild);
+    const from = guild;
+    const into = existing;
+    for (const key of Object.keys(from)) {
+      const value = from[key];
+      if (value !== undefined)
+        into[key] = value;
+    }
+    this.set(existing.id, existing);
+    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.#presences.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 Guild2(data));
+  }
+  async edit(id, options) {
+    const [payload, reason] = splitReason(options);
+    const data = await this.#rest.patch(Routes2.guild(id), payload, { reason });
+    return this.upsert(new Guild2(data));
+  }
+  async remove(id) {
+    await this.#rest.delete(Routes2.guild(id));
+  }
+  async fetchPreview(id) {
+    return this.#rest.get(Routes2.guildPreview(id));
+  }
+  async fetchWelcomeScreen(id) {
+    return this.#rest.get(Routes2.guildWelcomeScreen(id));
+  }
+  async editWelcomeScreen(id, options) {
+    const { reason, welcomeChannels, ...rest } = options;
+    return this.#rest.patch(Routes2.guildWelcomeScreen(id), { ...rest, welcome_channels: welcomeChannels }, { reason });
+  }
+  async fetchOnboarding(id) {
+    return this.#rest.get(Routes2.guildOnboarding(id));
+  }
+  async editOnboarding(id, options) {
+    const { reason, defaultChannelIds, ...rest } = options;
+    return this.#rest.put(Routes2.guildOnboarding(id), { ...rest, default_channel_ids: defaultChannelIds }, { reason });
+  }
+  async editVoiceState(id, userId, options) {
+    await this.#rest.patch(Routes2.guildVoiceState(id, userId), {
+      channel_id: options.channelId,
+      suppress: options.suppress,
+      request_to_speak_timestamp: options.requestToSpeakTimestamp
+    });
+  }
+  async removeIntegration(id, integrationId, reason) {
+    await this.#rest.delete(Routes2.guildIntegration(id, integrationId), {
+      reason
+    });
+  }
+  async fetchActiveThreads(id) {
+    return this.#rest.get(Routes2.guildActiveThreads(id));
+  }
+  async fetchWebhooks(id) {
+    return this.#rest.get(Routes2.guildWebhooks(id));
+  }
+  async fetchInvites(id) {
+    return this.#rest.get(Routes2.guildInvites(id));
+  }
+  async fetchAuditLog(guildId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.userId)
+      params.set("user_id", options.userId);
+    if (options.actionType !== undefined)
+      params.set("action_type", String(options.actionType));
+    if (options.before)
+      params.set("before", options.before);
+    if (options.after)
+      params.set("after", options.after);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
+    return this.#rest.get(withQuery3(Routes2.guildAuditLog(guildId), params));
+  }
+  async fetchAuditLogEntries(guildId, options = {}) {
+    return new AuditLog2(await this.fetchAuditLog(guildId, options));
+  }
+  async fetchMembers(guildId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(1000, Math.max(1, options.limit))));
+    if (options.after)
+      params.set("after", options.after);
+    return this.#rest.get(withQuery3(Routes2.guildMembers(guildId), params));
+  }
+  async fetchAutoModerationRules(guildId) {
+    const rules = await this.#rest.get(Routes2.guildAutoModerationRules(guildId));
+    return rules.map((r) => new AutoModerationRule2(r));
+  }
+  async fetchAutoModerationRule(guildId, ruleId) {
+    const rule = await this.#rest.get(Routes2.guildAutoModerationRule(guildId, ruleId));
+    return new AutoModerationRule2(rule);
+  }
+  async createAutoModerationRule(guildId, options) {
+    const [payload, reason] = splitReason(options);
+    const rule = await this.#rest.post(Routes2.guildAutoModerationRules(guildId), payload, { reason });
+    return new AutoModerationRule2(rule);
+  }
+  async editAutoModerationRule(guildId, ruleId, options) {
+    const [payload, reason] = splitReason(options);
+    const rule = await this.#rest.patch(Routes2.guildAutoModerationRule(guildId, ruleId), payload, { reason });
+    return new AutoModerationRule2(rule);
+  }
+  async deleteAutoModerationRule(guildId, ruleId, reason) {
+    await this.#rest.delete(Routes2.guildAutoModerationRule(guildId, ruleId), { reason });
+  }
+}
+var AuditLogEvent2 = {
+  GuildUpdate: 1,
+  ChannelCreate: 10,
+  ChannelUpdate: 11,
+  ChannelDelete: 12,
+  ChannelOverwriteCreate: 13,
+  ChannelOverwriteUpdate: 14,
+  ChannelOverwriteDelete: 15,
+  MemberKick: 20,
+  MemberPrune: 21,
+  MemberBanAdd: 22,
+  MemberBanRemove: 23,
+  MemberUpdate: 24,
+  MemberRoleUpdate: 25,
+  MemberMove: 26,
+  MemberDisconnect: 27,
+  BotAdd: 28,
+  RoleCreate: 30,
+  RoleUpdate: 31,
+  RoleDelete: 32,
+  InviteCreate: 40,
+  InviteUpdate: 41,
+  InviteDelete: 42,
+  WebhookCreate: 50,
+  WebhookUpdate: 51,
+  WebhookDelete: 52,
+  EmojiCreate: 60,
+  EmojiUpdate: 61,
+  EmojiDelete: 62,
+  MessageDelete: 72,
+  MessageBulkDelete: 73,
+  MessagePin: 74,
+  MessageUnpin: 75,
+  IntegrationCreate: 80,
+  IntegrationUpdate: 81,
+  IntegrationDelete: 82,
+  StageInstanceCreate: 83,
+  StageInstanceUpdate: 84,
+  StageInstanceDelete: 85,
+  StickerCreate: 90,
+  StickerUpdate: 91,
+  StickerDelete: 92,
+  ScheduledEventCreate: 100,
+  ScheduledEventUpdate: 101,
+  ScheduledEventDelete: 102,
+  ThreadCreate: 110,
+  ThreadUpdate: 111,
+  ThreadDelete: 112,
+  AutoModerationRuleCreate: 140,
+  AutoModerationRuleUpdate: 141,
+  AutoModerationRuleDelete: 142,
+  AutoModerationBlockMessage: 143
+};
+// packages/managers/src/application.ts
+function commandPayload(command) {
+  return "toJSON" in command && typeof command.toJSON === "function" ? command.toJSON() : command;
+}
+
+class ApplicationCommandManager2 {
+  #rest;
+  #applicationId;
+  constructor(rest, applicationId) {
+    this.#rest = rest;
+    this.#applicationId = applicationId;
+  }
+  fetch() {
+    return this.#rest.get(Routes2.applicationCommands(this.#applicationId));
+  }
+  create(data) {
+    return this.#rest.post(Routes2.applicationCommands(this.#applicationId), commandPayload(data));
+  }
+  set(commands) {
+    return this.#rest.put(Routes2.applicationCommands(this.#applicationId), commands.map(commandPayload));
+  }
+  edit(commandId, data) {
+    return this.#rest.patch(Routes2.applicationCommand(this.#applicationId, commandId), commandPayload(data));
+  }
+  async delete(commandId) {
+    await this.#rest.delete(Routes2.applicationCommand(this.#applicationId, commandId));
+  }
+  fetchGuild(guildId) {
+    return this.#rest.get(Routes2.guildApplicationCommands(this.#applicationId, guildId));
+  }
+  createGuild(guildId, data) {
+    return this.#rest.post(Routes2.guildApplicationCommands(this.#applicationId, guildId), commandPayload(data));
+  }
+  setGuild(guildId, commands) {
+    return this.#rest.put(Routes2.guildApplicationCommands(this.#applicationId, guildId), commands.map(commandPayload));
+  }
+  editGuild(guildId, commandId, data) {
+    return this.#rest.patch(Routes2.guildApplicationCommand(this.#applicationId, guildId, commandId), commandPayload(data));
+  }
+  async deleteGuild(guildId, commandId) {
+    await this.#rest.delete(Routes2.guildApplicationCommand(this.#applicationId, guildId, commandId));
+  }
+}
+
+// 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 ChannelManager2 extends Manager2 {
+  #rest;
+  #context;
+  #messageManagers = new Map;
+  #messageCache;
+  #allowedMentions;
+  constructor(rest, options = {}) {
+    super();
+    this.#rest = rest;
+    this.#messageCache = options.messageCache;
+    this.#allowedMentions = options.allowedMentions;
+    this.#context = {
+      sendMessage: (channelId, options) => this.send(channelId, options),
+      editMessage: (channelId, messageId, options) => this.editMessage(channelId, messageId, options),
+      deleteMessage: (channelId, messageId, reason) => this.deleteMessage(channelId, messageId, reason),
+      crosspostMessage: (channelId, messageId) => this.crosspostMessage(channelId, messageId),
+      editChannel: (channelId, options) => this.edit(channelId, options),
+      deleteChannel: (channelId, reason) => this.remove(channelId, reason),
+      addReaction: (channelId, messageId, emoji) => this.addReaction(channelId, messageId, emoji),
+      removeOwnReaction: (channelId, messageId, emoji) => this.removeOwnReaction(channelId, messageId, emoji),
+      removeReaction: (channelId, messageId, emoji, userId) => this.removeReaction(channelId, messageId, emoji, userId),
+      removeAllReactions: (channelId, messageId) => this.removeAllReactions(channelId, messageId),
+      pinMessage: (channelId, messageId, reason) => this.pinMessage(channelId, messageId, reason),
+      unpinMessage: (channelId, messageId, reason) => this.unpinMessage(channelId, messageId, reason)
+    };
+  }
+  messages(channelId) {
+    let manager = this.#messageManagers.get(channelId);
+    if (!manager) {
+      manager = new MessageManager2(this.#rest, this.#context, channelId, this.#messageCache, this.#allowedMentions);
+      this.#messageManagers.set(channelId, manager);
+    }
+    return manager;
+  }
+  permissionOverwrites(channelId) {
+    return new PermissionOverwriteManager2(this.#rest, channelId, () => {
+      const channel = this.get(channelId);
+      return channel && !channel.partial ? channel.permissionOverwrites : undefined;
+    });
+  }
+  threads(channelId) {
+    return new ThreadManager2(this.#rest, this.#context, channelId, this.#allowedMentions);
+  }
+  fetch(channelId) {
+    return this.fetchOnce(channelId, async () => createChannel2(await this.#rest.get(Routes2.channel(channelId)), this.#context), (channel) => this.#merge(channel));
+  }
+  async resolve(channelId) {
+    return this.get(channelId) ?? this.fetch(channelId);
+  }
+  upsert(data) {
+    return this.#merge(createChannel2(data, this.#context));
+  }
+  #merge(channel) {
+    const existing = this.get(channel.id);
+    if (existing && existing.type === channel.type) {
+      assignFields(existing, channel);
+      this.set(existing.id, existing);
+      return existing;
+    }
+    this.set(channel.id, channel);
+    return channel;
+  }
+  update(channel) {
+    return this.set(channel.id, channel);
+  }
+  deleteGuildChannels(guildId) {
+    const ids = [];
+    this.cache.forEach((channel, id) => {
+      if (channel.guildId === guildId)
+        ids.push(id);
+    });
+    let removed = 0;
+    for (const id of ids)
+      if (this.delete(id))
+        removed++;
+    return removed;
+  }
+  async endPoll(channelId, messageId) {
+    return this.messages(channelId).upsert(await this.#rest.post(Routes2.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(`${Routes2.pollAnswerVoters(channelId, messageId, answerId)}${suffix ? `?${suffix}` : ""}`);
+    return users.map((user) => new User2(user));
+  }
+  async sendSoundboardSound(channelId, options) {
+    await this.#rest.post(Routes2.sendSoundboardSound(channelId), {
+      sound_id: options.soundId,
+      source_guild_id: options.sourceGuildId
+    });
+  }
+  cachedMessages(channelId) {
+    return this.#messageManagers.get(channelId);
+  }
+  async create(guildId, options) {
+    const [payload, reason] = splitReason(options);
+    return this.upsert(await this.#rest.post(Routes2.guildChannels(guildId), payload, { reason }));
+  }
+  async edit(channelId, options) {
+    const [payload, reason] = splitReason(options);
+    return this.upsert(await this.#rest.patch(Routes2.channel(channelId), payload, { reason }));
+  }
+  async remove(channelId, reason) {
+    await this.#rest.delete(Routes2.channel(channelId), { reason });
+    this.delete(channelId);
+  }
+  delete(channelId) {
+    this.#messageManagers.delete(channelId);
+    return super.delete(channelId);
+  }
+  send(channelId, options) {
+    return this.messages(channelId).send(options);
+  }
+  async fetchMessage(channelId, messageId, options = {}) {
+    return this.messages(channelId).fetch(messageId);
+  }
+  fetchMessages(channelId, query) {
+    if (isMessageQuery(query)) {
+      const params = new URLSearchParams;
+      if (query.before)
+        params.set("before", query.before);
+      if (query.after)
+        params.set("after", query.after);
+      if (query.around)
+        params.set("around", query.around);
+      if (query.limit !== undefined)
+        params.set("limit", String(query.limit));
+      const suffix = params.toString();
+      return this.#rest.get(`${Routes2.channelMessages(channelId)}${suffix ? `?${suffix}` : ""}`).then((data) => data.map((item) => this.messages(channelId).upsert(item)));
+    }
+    return this.messages(channelId).fetchMany(query);
+  }
+  upsertMessage(data) {
+    return this.messages(data.channel_id).upsert(data);
+  }
+  async editMessage(channelId, messageId, options) {
+    const { body, files } = toRequest2(options, this.#allowedMentions);
+    return this.messages(channelId).upsert(await this.#rest.patch(Routes2.message(channelId, messageId), body, { files }));
+  }
+  async deleteMessage(channelId, messageId, reason) {
+    await this.#rest.delete(Routes2.message(channelId, messageId), {
+      reason
+    });
+    this.messages(channelId).delete(messageId);
+  }
+  deleteCachedMessage(channelId, messageId) {
+    return this.messages(channelId).delete(messageId);
+  }
+  async crosspostMessage(channelId, messageId) {
+    return this.messages(channelId).upsert(await this.#rest.post(Routes2.crosspostMessage(channelId, messageId)));
+  }
+  async bulkDeleteMessages(channelId, messageIds, reason) {
+    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], reason);
+    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(Routes2.channelBulkDelete(channelId), { messages: ids }, { reason });
+    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(Routes2.messageReactionMe(channelId, messageId, emoji));
+  }
+  async fetchReactions(channelId, messageId, emoji, options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    if (options.after)
+      params.set("after", options.after);
+    const suffix = params.toString();
+    const data = await this.#rest.get(`${Routes2.messageReactions(channelId, messageId, emoji)}${suffix ? `?${suffix}` : ""}`);
+    return data.map((user) => new User2(user));
+  }
+  async removeOwnReaction(channelId, messageId, emoji) {
+    await this.#rest.delete(Routes2.messageReactionMe(channelId, messageId, emoji));
+  }
+  async removeReaction(channelId, messageId, emoji, userId) {
+    await this.#rest.delete(Routes2.messageReactionUser(channelId, messageId, emoji, userId));
+  }
+  async removeAllReactions(channelId, messageId) {
+    await this.#rest.delete(Routes2.messageReactionsAll(channelId, messageId));
+  }
+  async fetchPinnedMessages(channelId) {
+    const data = await this.#rest.get(Routes2.channelMessagesPins(channelId));
+    return data.items.map((item) => this.messages(channelId).upsert(item.message));
+  }
+  async fetchPins(channelId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.before)
+      params.set("before", options.before);
+    if (options.limit !== undefined)
+      params.set("limit", String(Math.min(50, Math.max(1, options.limit))));
+    const query = params.toString();
+    const data = await this.#rest.get(`${Routes2.channelMessagesPins(channelId)}${query ? `?${query}` : ""}`);
+    return {
+      messages: data.items.map((item) => this.messages(channelId).upsert(item.message)),
+      hasMore: data.has_more
+    };
+  }
+  async triggerTyping(channelId) {
+    await this.#rest.post(Routes2.channelTyping(channelId));
+  }
+  async createForumTag(channelId, tag, reason) {
+    const tags = await this.#forumTags(channelId);
+    return this.#saveForumTags(channelId, [...tags, tag], reason);
+  }
+  async editForumTag(channelId, tagId, changes, reason) {
+    const tags = await this.#forumTags(channelId);
+    if (!tags.some((tag) => tag.id === tagId))
+      throw new Error(`Channel ${channelId} has no tag ${tagId}.`);
+    return this.#saveForumTags(channelId, tags.map((tag) => tag.id === tagId ? { ...tag, ...changes } : tag), reason);
+  }
+  async removeForumTag(channelId, tagId, reason) {
+    const tags = await this.#forumTags(channelId);
+    if (!tags.some((tag) => tag.id === tagId))
+      throw new Error(`Channel ${channelId} has no tag ${tagId}.`);
+    return this.#saveForumTags(channelId, tags.filter((tag) => tag.id !== tagId), reason);
+  }
+  async#forumTags(channelId) {
+    const channel = await this.#rest.get(Routes2.channel(channelId));
+    return channel.available_tags ?? [];
+  }
+  async#saveForumTags(channelId, tags, reason) {
+    const updated = await this.#rest.patch(Routes2.channel(channelId), { available_tags: tags }, { reason });
+    return updated.available_tags ?? [];
+  }
+  async pinMessage(channelId, messageId, reason) {
+    await this.#rest.put(Routes2.channelMessagesPin(channelId, messageId), undefined, { reason });
+  }
+  async unpinMessage(channelId, messageId, reason) {
+    await this.#rest.delete(Routes2.channelMessagesPin(channelId, messageId), { reason });
+  }
+  async createWebhook(channelId, options) {
+    const [payload, reason] = splitReason(options);
+    return this.#rest.post(Routes2.channelWebhooks(channelId), payload, {
+      reason
+    });
+  }
+  createThreadFromMessage(channelId, messageId, options) {
+    return this.threads(channelId).createFromMessage(messageId, options);
+  }
+  async fetchPage(channelId, options = {}) {
+    const limit = Math.min(100, Math.max(1, options.limit ?? 50));
+    const messages = await this.fetchMessages(channelId, {
+      ...options,
+      limit
+    });
+    return {
+      messages,
+      before: messages[0]?.id,
+      after: messages[messages.length - 1]?.id,
+      hasMore: messages.length === limit
+    };
+  }
+  clear() {
+    this.#messageManagers.clear();
+    super.clear();
+  }
+}
+function isMessageQuery(value) {
+  return typeof value === "object" && value !== null && !(Symbol.iterator in value);
+}
+
+export { Manager2, ResourceManager2, toRequest2, MessageManager2, ThreadManager2, UserManager2, EmojiManager2, GuildStickerManager2, GuildSoundboardManager2, MonetizationManager2, ApplicationEmojiManager2, GuildMemberManager2, RoleManager2, GuildBanManager2, GuildScheduledEventManager2, StageInstanceManager2, PermissionOverwriteManager2, GuildManager2, AuditLogEvent2, ApplicationCommandManager2, ChannelManager2 };
+
+//# debugId=594E37102F1B43CE64756E2164756E21