lunibee 0.1.0 → 0.1.2

package/dist/managers/index.js

@@ -0,0 +1,947 @@
+// @bun
+// packages/collection/src/index.ts
+class Collection extends Map {
+  first() {
+    for (const value of this.values())
+      return value;
+    return;
+  }
+  firstKey() {
+    for (const key of this.keys())
+      return key;
+    return;
+  }
+  last() {
+    let value;
+    for (const item of this.values())
+      value = item;
+    return value;
+  }
+  lastKey() {
+    let key;
+    for (const item of this.keys())
+      key = item;
+    return key;
+  }
+  find(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        return value;
+    }
+    return;
+  }
+  filter(predicate) {
+    const result = new Collection;
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        result.set(key, value);
+    }
+    return result;
+  }
+  map(transform) {
+    const result = [];
+    for (const [key, value] of this) {
+      result.push(transform(value, key, this));
+    }
+    return result;
+  }
+  some(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        return true;
+    }
+    return false;
+  }
+  every(predicate) {
+    for (const [key, value] of this) {
+      if (!predicate(value, key, this))
+        return false;
+    }
+    return true;
+  }
+  each(callback) {
+    for (const [key, value] of this) {
+      callback(value, key, this);
+    }
+    return this;
+  }
+  array() {
+    return [...this.values()];
+  }
+  keyArray() {
+    return [...this.keys()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  clone() {
+    const copy = new Collection;
+    for (const [key, value] of this)
+      copy.set(key, value);
+    return copy;
+  }
+  hasAll(...keys) {
+    for (let i = 0;i < keys.length; i++) {
+      if (!this.has(keys[i]))
+        return false;
+    }
+    return true;
+  }
+  hasAny(...keys) {
+    for (let i = 0;i < keys.length; i++) {
+      if (this.has(keys[i]))
+        return true;
+    }
+    return false;
+  }
+  findKey(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        return key;
+    }
+    return;
+  }
+  someEntry(predicate) {
+    return this.some(predicate);
+  }
+  sweep(predicate) {
+    let removed = 0;
+    for (const [key, value] of this) {
+      if (predicate(value, key, this) && this.delete(key))
+        removed++;
+    }
+    return removed;
+  }
+  firstEntry() {
+    for (const [key, value] of this)
+      return [key, value];
+    return;
+  }
+  lastEntry() {
+    let entry;
+    for (const item of this)
+      entry = [item[0], item[1]];
+    return entry;
+  }
+}
+
+// packages/managers/src/base.ts
+class Manager {
+  cache = new Collection;
+  get(id) {
+    return this.cache.get(id);
+  }
+  has(id) {
+    return this.cache.has(id);
+  }
+  set(id, value) {
+    this.cache.set(id, value);
+    return this;
+  }
+  delete(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 ResourceManager extends Manager {
+  #fetcher;
+  #key;
+  constructor(fetcher, key) {
+    super();
+    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);
+  }
+  async fetch(id) {
+    const resource = await this.#fetcher(id);
+    this.set(id, resource);
+    return resource;
+  }
+  async fetchMany(ids) {
+    return Promise.all([...ids].map((id) => this.resolve(id)));
+  }
+  upsert(resource) {
+    const key = this.#key(resource);
+    this.set(key, resource);
+    return resource;
+  }
+  update(resource) {
+    return this.upsert(resource);
+  }
+}
+// packages/rest/src/routes.ts
+var Routes = {
+  user: () => "/users/@me",
+  userById: (userId) => `/users/${snowflake(userId, "User ID")}`,
+  guild: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}`,
+  guildChannels: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/channels`,
+  guildMember: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}`,
+  guildRoles: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles`,
+  guildRole: (guildId, roleId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles/${snowflake(roleId, "Role ID")}`,
+  guildMemberRole: (guildId, userId, roleId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}/roles/${snowflake(roleId, "Role ID")}`,
+  guildBans: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/bans`,
+  guildBan: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/bans/${snowflake(userId, "User ID")}`,
+  channel: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}`,
+  channelMessages: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages`,
+  message: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/${snowflake(messageId, "Message ID")}`,
+  crosspostMessage: (channelId, messageId) => `${Routes.message(channelId, messageId)}/crosspost`,
+  messageReactions: (channelId, messageId, emoji) => `${Routes.message(channelId, messageId)}/reactions/${encodeURIComponent(emoji)}`,
+  messageReactionsAll: (channelId, messageId) => `${Routes.message(channelId, messageId)}/reactions`,
+  channelPins: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/pins`,
+  channelPin: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/pins/${snowflake(messageId, "Message ID")}`,
+  messageThread: (channelId, messageId) => `${Routes.message(channelId, messageId)}/threads`,
+  channelBulkDelete: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/bulk-delete`,
+  channelWebhooks: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/webhooks`,
+  channelInvites: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/invites`,
+  webhook: (webhookId, token) => `/webhooks/${snowflake(webhookId, "Webhook ID")}${token ? `/${encodeURIComponent(token)}` : ""}`,
+  webhookMessage: (webhookId, token, messageId) => `/webhooks/${snowflake(webhookId, "Webhook ID")}/${encodeURIComponent(token)}/messages/${snowflake(messageId, "Message ID")}`,
+  applicationCommands: (applicationId) => `/applications/${snowflake(applicationId, "Application ID")}/commands`,
+  applicationCommand: (applicationId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/commands/${snowflake(commandId, "Command ID")}`,
+  guildApplicationCommands: (applicationId, guildId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands`,
+  guildApplicationCommand: (applicationId, guildId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands/${snowflake(commandId, "Command ID")}`,
+  interactionCallback: (interactionId, token) => `/interactions/${snowflake(interactionId, "Interaction ID")}/${encodeURIComponent(token)}/callback`,
+  interactionOriginalResponse: (applicationId, token) => `/webhooks/${snowflake(applicationId, "Application ID")}/${encodeURIComponent(token)}/messages/@original`,
+  guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
+  channelPublicArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/public`,
+  channelPrivateArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/private`,
+  threadMembers: (threadId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members`,
+  guildScheduledEvents: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events`,
+  guildScheduledEvent: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}`,
+  guildAutoModerationRules: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules`,
+  guildAutoModerationRule: (guildId, ruleId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules/${snowflake(ruleId, "Rule ID")}`,
+  voiceRegions: () => "/voice/regions",
+  gateway: () => "/gateway",
+  gatewayBot: () => "/gateway/bot"
+};
+function snowflake(value, field) {
+  if (!/^\d{1,20}$/.test(value))
+    throw new TypeError(`${field} must be a valid Discord snowflake.`);
+  return value;
+}
+// packages/structures/src/base.ts
+class BaseStructure {
+  id;
+  constructor(id) {
+    if (!/^\d{1,20}$/.test(id))
+      throw new TypeError("A Discord structure requires a valid snowflake ID.");
+    this.id = id;
+  }
+  toString() {
+    return this.id;
+  }
+}
+
+class User extends BaseStructure {
+  username;
+  globalName;
+  avatar;
+  bot;
+  system;
+  flags;
+  constructor(data) {
+    super(data.id);
+    if (!data.username)
+      throw new TypeError("A Discord user requires a username.");
+    this.username = data.username;
+    this.globalName = data.global_name ?? null;
+    this.avatar = data.avatar ?? null;
+    this.bot = data.bot ?? false;
+    this.system = data.system ?? false;
+    this.flags = data.public_flags ?? 0;
+  }
+  get displayName() {
+    return this.globalName ?? this.username;
+  }
+  avatarURL(options = {}) {
+    if (!this.avatar)
+      return null;
+    const extension = options.extension ?? (this.avatar.startsWith("a_") ? "gif" : "png");
+    return `https://cdn.discordapp.com/avatars/${this.id}/${this.avatar}.${extension}${options.size ? `?size=${options.size}` : ""}`;
+  }
+  defaultAvatarURL() {
+    return `https://cdn.discordapp.com/embed/avatars/${Number(BigInt(this.id) % 5n)}.png`;
+  }
+  displayAvatarURL(options = {}) {
+    return this.avatarURL(options) ?? this.defaultAvatarURL();
+  }
+}
+
+class Channel extends BaseStructure {
+  type;
+  name;
+  guildId;
+  #context;
+  constructor(data, context) {
+    super(data.id);
+    if (!Number.isInteger(data.type) || data.type < 0)
+      throw new RangeError("A Discord channel requires a valid channel type.");
+    this.type = data.type;
+    this.name = data.name;
+    this.guildId = data.guild_id;
+    this.#context = context;
+  }
+  sendMessage(options) {
+    if (!this.#context)
+      throw new Error("This channel is not attached to a client.");
+    return this.#context.sendMessage(this.id, options);
+  }
+}
+
+class Guild extends BaseStructure {
+  name;
+  preferredLocale;
+  ownerId;
+  constructor(data) {
+    super(data.id);
+    if (!data.name)
+      throw new TypeError("A Discord guild requires a name.");
+    this.name = data.name;
+    this.preferredLocale = data.preferred_locale;
+    this.ownerId = data.owner_id;
+  }
+}
+// packages/structures/src/permissions.ts
+var Permissions = {
+  CreateInstantInvite: 1n << 0n,
+  KickMembers: 1n << 1n,
+  BanMembers: 1n << 2n,
+  Administrator: 1n << 3n,
+  ManageChannels: 1n << 4n,
+  ManageGuild: 1n << 5n,
+  AddReactions: 1n << 6n,
+  ViewAuditLog: 1n << 7n,
+  PrioritySpeaker: 1n << 8n,
+  Stream: 1n << 9n,
+  ViewChannel: 1n << 10n,
+  SendMessages: 1n << 11n,
+  SendTTSMessages: 1n << 12n,
+  ManageMessages: 1n << 13n,
+  EmbedLinks: 1n << 14n,
+  AttachFiles: 1n << 15n,
+  ReadMessageHistory: 1n << 16n,
+  MentionEveryone: 1n << 17n,
+  UseExternalEmojis: 1n << 18n,
+  ViewGuildInsights: 1n << 19n,
+  Connect: 1n << 20n,
+  Speak: 1n << 21n,
+  MuteMembers: 1n << 22n,
+  DeafenMembers: 1n << 23n,
+  MoveMembers: 1n << 24n,
+  UseVAD: 1n << 25n,
+  ChangeNickname: 1n << 26n,
+  ManageNicknames: 1n << 27n,
+  ManageRoles: 1n << 28n,
+  ManageWebhooks: 1n << 29n,
+  ManageGuildExpressions: 1n << 30n,
+  UseApplicationCommands: 1n << 31n,
+  RequestToSpeak: 1n << 32n,
+  ManageEvents: 1n << 33n,
+  ManageThreads: 1n << 34n,
+  CreatePublicThreads: 1n << 35n,
+  CreatePrivateThreads: 1n << 36n,
+  UseExternalStickers: 1n << 37n,
+  SendMessagesInThreads: 1n << 38n,
+  UseEmbeddedActivities: 1n << 39n,
+  ModerateMembers: 1n << 40n,
+  ViewCreatorMonetizationAnalytics: 1n << 41n,
+  UseSoundboard: 1n << 42n,
+  CreateGuildExpressions: 1n << 43n,
+  CreateEvents: 1n << 44n,
+  UseExternalSounds: 1n << 45n,
+  SendVoiceMessages: 1n << 46n,
+  SendPolls: 1n << 49n,
+  UseExternalApps: 1n << 50n
+};
+
+class PermissionSet {
+  bitfield;
+  constructor(value = 0n) {
+    try {
+      if (Array.isArray(value)) {
+        let bit = 0n;
+        for (const item of value)
+          bit |= this.#resolve(item);
+        this.bitfield = bit;
+      } else if (value instanceof PermissionSet) {
+        this.bitfield = value.bitfield;
+      } else {
+        const bitfield = this.#resolve(value);
+        if (bitfield < 0n)
+          throw new RangeError("Permission bitfield cannot be negative.");
+        this.bitfield = bitfield;
+      }
+    } catch (error) {
+      if (error instanceof RangeError)
+        throw error;
+      throw new TypeError("Permission bitfield must be a valid non-negative integer.", { cause: error });
+    }
+  }
+  has(...permissions) {
+    return permissions.every((permission) => (this.bitfield & this.#resolve(permission)) === this.#resolve(permission));
+  }
+  any(...permissions) {
+    return permissions.some((permission) => (this.bitfield & this.#resolve(permission)) !== 0n);
+  }
+  add(...permissions) {
+    let bitfield = this.bitfield;
+    for (const permission of permissions)
+      bitfield |= this.#resolve(permission);
+    return new PermissionSet(bitfield);
+  }
+  remove(...permissions) {
+    let bitfield = this.bitfield;
+    for (const permission of permissions)
+      bitfield &= ~this.#resolve(permission);
+    return new PermissionSet(bitfield);
+  }
+  equals(other) {
+    return this.bitfield === (other instanceof PermissionSet ? other.bitfield : new PermissionSet(other).bitfield);
+  }
+  toString() {
+    return this.bitfield.toString();
+  }
+  toArray() {
+    return Object.keys(Permissions).filter((permission) => this.has(permission));
+  }
+  #resolve(permission) {
+    if (permission instanceof PermissionSet)
+      return permission.bitfield;
+    if (typeof permission === "bigint")
+      return permission;
+    if (typeof permission === "number")
+      return BigInt(permission);
+    if (Array.isArray(permission)) {
+      let bit = 0n;
+      for (const p of permission)
+        bit |= this.#resolve(p);
+      return bit;
+    }
+    if (typeof permission === "string") {
+      if (permission in Permissions)
+        return Permissions[permission];
+      const matchedKey = Object.keys(Permissions).find((k) => k.toLowerCase() === permission.toLowerCase());
+      if (matchedKey)
+        return Permissions[matchedKey];
+      return BigInt(permission);
+    }
+    return 0n;
+  }
+}
+
+class PermissionsBitField extends PermissionSet {
+  constructor(value = 0n) {
+    super(value);
+  }
+}
+
+// packages/structures/src/resources.ts
+class GuildMember {
+  user;
+  guildId;
+  nickname;
+  roleIds;
+  pending;
+  joinedAt;
+  permissions;
+  constructor(data) {
+    this.user = new User(data.user);
+    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.");
+    this.permissions = new PermissionsBitField(data.permissions ?? 0n);
+  }
+  get displayName() {
+    return this.nickname ?? this.user.displayName;
+  }
+}
+
+class Role extends BaseStructure {
+  name;
+  color;
+  hoist;
+  permissions;
+  managed;
+  mentionable;
+  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;
+  }
+  toString() {
+    return `<@&${this.id}>`;
+  }
+}
+
+// packages/structures/src/index.ts
+class Message extends BaseStructure {
+  content;
+  author;
+  channelId;
+  channel;
+  guildId;
+  flags;
+  createdAt;
+  attachments;
+  embeds;
+  mentions;
+  mentionRoles;
+  pinned;
+  mentionEveryone;
+  type;
+  reference;
+  referencedMessage;
+  #context;
+  constructor(data, context) {
+    super(data.id);
+    if (!/^\d{1,20}$/.test(data.channel_id))
+      throw new TypeError("Message channel_id must be a valid snowflake.");
+    this.content = data.content ?? "";
+    this.author = new User(data.author);
+    this.channelId = data.channel_id;
+    this.guildId = data.guild_id;
+    this.flags = data.flags ?? 0;
+    this.createdAt = new Date(data.timestamp ?? Number((BigInt(this.id) >> 22n) + 1420070400000n));
+    this.attachments = data.attachments ?? [];
+    this.embeds = data.embeds ?? [];
+    this.mentions = (data.mentions ?? []).map((user) => new User(user));
+    this.mentionRoles = data.mention_roles ?? [];
+    this.pinned = data.pinned ?? false;
+    this.mentionEveryone = data.mention_everyone ?? false;
+    this.type = data.type ?? 0;
+    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.channel = new Channel({ id: data.channel_id, type: 0, guild_id: data.guild_id }, context);
+  }
+  get embedsSuppressed() {
+    return (this.flags & 4) !== 0;
+  }
+  edit(options) {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.editMessage(this.channelId, this.id, options);
+  }
+  delete() {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.deleteMessage(this.channelId, this.id);
+  }
+  crosspost() {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.crosspostMessage(this.channelId, this.id);
+  }
+  reply(options) {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    const payload = typeof options === "string" ? { content: options } : { ...options };
+    payload.message_reference = {
+      message_id: this.id,
+      channel_id: this.channelId,
+      guild_id: this.guildId
+    };
+    return this.#context.sendMessage(this.channelId, payload);
+  }
+}
+
+// packages/managers/src/message.ts
+class MessageManager {
+  cache = new Collection;
+  #rest;
+  #context;
+  #channelId;
+  constructor(rest, context, channelId) {
+    if (!channelId)
+      throw new TypeError("Channel ID is required.");
+    this.#rest = rest;
+    this.#context = context;
+    this.#channelId = channelId;
+  }
+  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);
+    return this.upsert(data);
+  }
+  async fetch(messageId) {
+    const data = await this.#rest.get(Routes.message(this.#channelId, messageId));
+    const message = Array.isArray(data) ? data[0] : data;
+    if (!message)
+      throw new Error("Discord returned no message payload.");
+    return this.upsert(message);
+  }
+  fetchMany(messageIds) {
+    return Promise.all(Array.from(messageIds, (messageId) => this.fetch(messageId)));
+  }
+  upsert(data) {
+    const existing = this.cache.get(data.id);
+    const message = new Message(data, this.#context);
+    if (existing) {
+      Object.assign(existing, message);
+      return existing;
+    }
+    this.cache.set(message.id, message);
+    return message;
+  }
+  delete(messageId) {
+    return this.cache.delete(messageId);
+  }
+}
+
+// packages/managers/src/thread.ts
+class ThreadManager {
+  #rest;
+  #context;
+  #channelId;
+  constructor(rest, context, channelId) {
+    if (!channelId)
+      throw new TypeError("Channel ID is required.");
+    this.#rest = rest;
+    this.#context = context;
+    this.#channelId = channelId;
+  }
+  async createFromMessage(messageId, options) {
+    const data = await this.#rest.post(Routes.messageThread(this.#channelId, messageId), {
+      name: options.name,
+      auto_archive_duration: options.autoArchiveDuration,
+      rate_limit_per_user: options.rateLimitPerUser
+    });
+    return new Channel(data, this.#context);
+  }
+}
+// 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/member.ts
+class GuildMemberManager extends ResourceManager {
+  #rest;
+  guildId;
+  constructor(guildId, rest) {
+    super((id) => rest.get(Routes.guildMember(guildId, id)).then((data) => new GuildMember({ ...data, guild_id: guildId })), (member) => member.user.id);
+    this.guildId = guildId;
+    this.#rest = rest;
+  }
+  async kick(userId) {
+    await this.#rest.delete(Routes.guildMember(this.guildId, userId));
+    this.delete(userId);
+  }
+  async ban(userId, options = {}) {
+    await this.#rest.put(Routes.guildBan(this.guildId, userId), {
+      delete_message_seconds: options.deleteMessageSeconds
+    });
+    this.delete(userId);
+  }
+  async unban(userId) {
+    await this.#rest.delete(Routes.guildBan(this.guildId, userId));
+  }
+  async edit(userId, options) {
+    const data = await this.#rest.patch(Routes.guildMember(this.guildId, userId), options);
+    const member = new GuildMember({ ...data, guild_id: this.guildId });
+    this.set(member.user.id, member);
+    return member;
+  }
+  async addRole(userId, roleId) {
+    await this.#rest.put(Routes.guildMemberRole(this.guildId, userId, roleId));
+  }
+  async removeRole(userId, roleId) {
+    await this.#rest.delete(Routes.guildMemberRole(this.guildId, userId, roleId));
+  }
+  async timeout(userId, milliseconds) {
+    const timeoutDate = milliseconds === null ? null : new Date(Date.now() + milliseconds).toISOString();
+    return this.edit(userId, { communication_disabled_until: timeoutDate });
+  }
+}
+// packages/managers/src/application.ts
+class ApplicationCommandManager {
+  #rest;
+  #applicationId;
+  constructor(rest, applicationId) {
+    this.#rest = rest;
+    this.#applicationId = applicationId;
+  }
+  fetch() {
+    return this.#rest.get(Routes.applicationCommands(this.#applicationId));
+  }
+  create(data) {
+    return this.#rest.post(Routes.applicationCommands(this.#applicationId), data);
+  }
+  set(commands) {
+    return this.#rest.put(Routes.applicationCommands(this.#applicationId), commands);
+  }
+  edit(commandId, data) {
+    return this.#rest.patch(Routes.applicationCommand(this.#applicationId, commandId), data);
+  }
+  async delete(commandId) {
+    await this.#rest.delete(Routes.applicationCommand(this.#applicationId, commandId));
+  }
+  fetchGuild(guildId) {
+    return this.#rest.get(Routes.guildApplicationCommands(this.#applicationId, guildId));
+  }
+  createGuild(guildId, data) {
+    return this.#rest.post(Routes.guildApplicationCommands(this.#applicationId, guildId), data);
+  }
+  setGuild(guildId, commands) {
+    return this.#rest.put(Routes.guildApplicationCommands(this.#applicationId, guildId), commands);
+  }
+  editGuild(guildId, commandId, data) {
+    return this.#rest.patch(Routes.guildApplicationCommand(this.#applicationId, guildId, commandId), data);
+  }
+  async deleteGuild(guildId, commandId) {
+    await this.#rest.delete(Routes.guildApplicationCommand(this.#applicationId, guildId, commandId));
+  }
+}
+
+// packages/managers/src/index.ts
+class UserManager extends ResourceManager {
+  constructor(rest) {
+    super(async (id) => new User(await rest.get(Routes.userById(id))), (user) => user.id);
+  }
+}
+
+class GuildManager extends ResourceManager {
+  constructor(rest) {
+    super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
+  }
+}
+var MessageCreateOptions = undefined;
+var MessageEditOptions = undefined;
+var MessageFetchOptions = undefined;
+var MessageThreadOptions = undefined;
+var ReactionFetchOptions = undefined;
+
+class ChannelManager extends Manager {
+  #rest;
+  #context;
+  #messageManagers = new Map;
+  constructor(rest) {
+    super();
+    this.#rest = rest;
+    this.#context = {
+      sendMessage: (channelId, options) => this.send(channelId, options),
+      editMessage: (channelId, messageId, options) => this.editMessage(channelId, messageId, options),
+      deleteMessage: (channelId, messageId) => this.deleteMessage(channelId, messageId),
+      crosspostMessage: (channelId, messageId) => this.crosspostMessage(channelId, messageId)
+    };
+  }
+  messages(channelId) {
+    let manager = this.#messageManagers.get(channelId);
+    if (!manager) {
+      manager = new MessageManager(this.#rest, this.#context, channelId);
+      this.#messageManagers.set(channelId, manager);
+    }
+    return manager;
+  }
+  threads(channelId) {
+    return new ThreadManager(this.#rest, this.#context, channelId);
+  }
+  async fetch(channelId) {
+    const data = await this.#rest.get(Routes.channel(channelId));
+    return this.upsert(data);
+  }
+  async resolve(channelId) {
+    return this.get(channelId) ?? this.fetch(channelId);
+  }
+  upsert(data) {
+    const existing = this.get(data.id);
+    const channel = new Channel(data, this.#context);
+    if (existing) {
+      Object.assign(existing, channel);
+      return existing;
+    }
+    this.set(channel.id, channel);
+    return channel;
+  }
+  update(channel) {
+    return this.set(channel.id, channel);
+  }
+  send(channelId, options) {
+    return this.messages(channelId).send(options);
+  }
+  sendMessage(channelId, options) {
+    return this.send(channelId, 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(`${Routes.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 data = await this.#rest.patch(Routes.message(channelId, messageId), options);
+    return this.messages(channelId).upsert(data);
+  }
+  async deleteMessage(channelId, messageId) {
+    await this.#rest.delete(Routes.message(channelId, messageId));
+    this.messages(channelId).delete(messageId);
+  }
+  deleteCachedMessage(channelId, messageId) {
+    return this.messages(channelId).delete(messageId);
+  }
+  async crosspostMessage(channelId, messageId) {
+    const data = await this.#rest.post(Routes.crosspostMessage(channelId, messageId));
+    return this.messages(channelId).upsert(data);
+  }
+  async bulkDeleteMessages(channelId, messageIds) {
+    const ids = [...messageIds];
+    await this.#rest.post(Routes.channelBulkDelete(channelId), {
+      messages: ids
+    });
+    for (const id of ids)
+      this.messages(channelId).delete(id);
+  }
+  async addReaction(channelId, messageId, emoji) {
+    await this.#rest.put(Routes.messageReactions(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(`${Routes.messageReactions(channelId, messageId, emoji)}${suffix ? `?${suffix}` : ""}`);
+    return data.map((user) => new User(user));
+  }
+  async removeOwnReaction(channelId, messageId, emoji) {
+    await this.#rest.delete(Routes.messageReactions(channelId, messageId, emoji) + "/@me");
+  }
+  async removeReaction(channelId, messageId, emoji, userId) {
+    await this.#rest.delete(`${Routes.messageReactions(channelId, messageId, emoji)}/${userId}`);
+  }
+  async removeAllReactions(channelId, messageId) {
+    await this.#rest.delete(Routes.messageReactionsAll(channelId, messageId));
+  }
+  async fetchPinnedMessages(channelId) {
+    const data = await this.#rest.get(Routes.channelPins(channelId));
+    return data.map((item) => this.messages(channelId).upsert(item));
+  }
+  async pinMessage(channelId, messageId) {
+    await this.#rest.put(Routes.channelPin(channelId, messageId));
+  }
+  async unpinMessage(channelId, messageId) {
+    await this.#rest.delete(Routes.channelPin(channelId, messageId));
+  }
+  createThreadFromMessage(channelId, messageId, options) {
+    return this.threads(channelId).createFromMessage(messageId, options);
+  }
+  delete(channelId) {
+    this.#messageManagers.delete(channelId);
+    return super.delete(channelId);
+  }
+  clear() {
+    this.#messageManagers.clear();
+    super.clear();
+  }
+}
+function isMessageQuery(value) {
+  return typeof value === "object" && value !== null && !(Symbol.iterator in value);
+}
+export {
+  ApplicationCommandManager,
+  ChannelManager,
+  GuildManager,
+  GuildMemberManager,
+  Manager,
+  MessageCreateOptions,
+  MessageEditOptions,
+  MessageFetchOptions,
+  MessageManager,
+  MessageThreadOptions,
+  ReactionFetchOptions,
+  ResourceManager,
+  RoleManager,
+  ThreadManager,
+  UserManager
+};
+
+//# debugId=B1F523C9C7EE890964756E2164756E21