@fluxerjs/core 1.0.9 → 1.1.1

package/dist/chunk-RWFKZ3DF.mjs

@@ -0,0 +1,413 @@
+import {
+  ErrorCodes,
+  FluxerError
+} from "./chunk-V6T5VMWD.mjs";
+import {
+  Events
+} from "./chunk-AH7KYH2Z.mjs";
+import {
+  buildSendBody
+} from "./chunk-PM2IUGNR.mjs";
+import {
+  Base
+} from "./chunk-XNS4O6QJ.mjs";
+
+// src/client/MessageManager.ts
+import { Routes } from "@fluxerjs/types";
+import { FluxerAPIError, RateLimitError } from "@fluxerjs/rest";
+var MessageManager = class {
+  constructor(client, channelId) {
+    this.client = client;
+    this.channelId = channelId;
+  }
+  /**
+   * Fetch a message by ID from this channel.
+   * @param messageId - Snowflake of the message
+   * @returns The message
+   * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
+   */
+  async fetch(messageId) {
+    try {
+      const { Message } = await import("./Message-OFIVTTAZ.mjs");
+      const data = await this.client.rest.get(
+        Routes.channelMessage(this.channelId, messageId)
+      );
+      return new Message(this.client, data);
+    } catch (err) {
+      if (err instanceof RateLimitError) throw err;
+      if (err instanceof FluxerAPIError && err.statusCode === 404) {
+        throw new FluxerError(`Message ${messageId} not found in channel ${this.channelId}`, {
+          code: ErrorCodes.MessageNotFound,
+          cause: err
+        });
+      }
+      throw err instanceof FluxerError ? err : new FluxerError(String(err), { cause: err });
+    }
+  }
+};
+
+// src/util/MessageCollector.ts
+import { EventEmitter } from "events";
+import { Collection } from "@fluxerjs/collection";
+var MessageCollector = class extends EventEmitter {
+  client;
+  channelId;
+  options;
+  collected = new Collection();
+  _timeout = null;
+  _ended = false;
+  _listener;
+  constructor(client, channelId, options = {}) {
+    super();
+    this.client = client;
+    this.channelId = channelId;
+    this.options = {
+      filter: options.filter ?? (() => true),
+      time: options.time ?? 0,
+      max: options.max ?? 0
+    };
+    this._listener = (message) => {
+      if (this._ended || message.channelId !== this.channelId) return;
+      if (!this.options.filter(message)) return;
+      this.collected.set(message.id, message);
+      this.emit("collect", message);
+      if (this.options.max > 0 && this.collected.size >= this.options.max) {
+        this.stop("limit");
+      }
+    };
+    this.client.on(Events.MessageCreate, this._listener);
+    if (this.options.time > 0) {
+      this._timeout = setTimeout(() => this.stop("time"), this.options.time);
+    }
+  }
+  stop(reason = "user") {
+    if (this._ended) return;
+    this._ended = true;
+    this.client.off(Events.MessageCreate, this._listener);
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+      this._timeout = null;
+    }
+    this.emit("end", this.collected, reason);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+
+// src/structures/Channel.ts
+import { ChannelType, Routes as Routes2 } from "@fluxerjs/types";
+import { emitDeprecationWarning } from "@fluxerjs/util";
+var Channel = class _Channel extends Base {
+  /** Whether this channel has a send method (TextChannel, DMChannel). */
+  isSendable() {
+    return "send" in this;
+  }
+  /** Whether this channel is a DM or Group DM. */
+  isDM() {
+    return this.type === ChannelType.DM || this.type === ChannelType.GroupDM;
+  }
+  /** Whether this channel is voice-based (VoiceChannel). */
+  isVoice() {
+    return "bitrate" in this;
+  }
+  /** Create a DM channel from API data (type DM or GroupDM). */
+  static createDM(client, data) {
+    return new DMChannel(client, data);
+  }
+  client;
+  id;
+  type;
+  /** Channel name. Guild channels and Group DMs have names; 1:1 DMs are typically null. */
+  name;
+  /** Channel icon hash (Group DMs). Null if none. */
+  icon;
+  /** ISO timestamp when the last message was pinned. Null if never pinned. */
+  lastPinTimestamp;
+  /** @param data - API channel from GET /channels/{id} or GET /guilds/{id}/channels */
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.type = data.type;
+    this.name = data.name ?? null;
+    this.icon = data.icon ?? null;
+    this.lastPinTimestamp = data.last_pin_timestamp ?? null;
+  }
+  /**
+   * Create the appropriate channel subclass from API data.
+   * @param client - The client instance
+   * @param data - Channel data from the API
+   */
+  static from(client, data) {
+    const type = data.type ?? 0;
+    if (type === ChannelType.GuildText) return new TextChannel(client, data);
+    if (type === ChannelType.GuildCategory) return new CategoryChannel(client, data);
+    if (type === ChannelType.GuildVoice) return new VoiceChannel(client, data);
+    if (type === ChannelType.GuildLink || type === ChannelType.GuildLinkExtended)
+      return new LinkChannel(client, data);
+    return new GuildChannel(client, data);
+  }
+  /**
+   * Create a channel from API data, including DM and GroupDM.
+   * Used by ChannelManager.fetch() for GET /channels/{id}.
+   */
+  static fromOrCreate(client, data) {
+    const type = data.type ?? 0;
+    if (type === ChannelType.DM || type === ChannelType.GroupDM)
+      return _Channel.createDM(client, data);
+    return _Channel.from(client, data);
+  }
+  /**
+   * Bulk delete messages. Requires Manage Messages permission.
+   * @param messageIds - Array of message IDs to delete (2–100)
+   */
+  async bulkDeleteMessages(messageIds) {
+    await this.client.rest.post(Routes2.channelBulkDelete(this.id), {
+      body: { message_ids: messageIds },
+      auth: true
+    });
+  }
+  /**
+   * Send a typing indicator to the channel. Lasts ~10 seconds.
+   */
+  async sendTyping() {
+    await this.client.rest.post(Routes2.channelTyping(this.id), { auth: true });
+  }
+};
+var GuildChannel = class extends Channel {
+  guildId;
+  name;
+  position;
+  parentId;
+  /** Permission overwrites for roles and members. */
+  permissionOverwrites;
+  constructor(client, data) {
+    super(client, data);
+    this.guildId = data.guild_id ?? "";
+    this.name = data.name ?? null;
+    this.position = data.position;
+    this.parentId = data.parent_id ?? null;
+    this.permissionOverwrites = data.permission_overwrites ?? [];
+  }
+  /**
+   * Create a webhook in this channel.
+   * @param options - Webhook name and optional avatar URL
+   * @returns The webhook with token (required for send()). Requires Manage Webhooks permission.
+   */
+  async createWebhook(options) {
+    const { Webhook } = await import("./Webhook-RWDDYW2Q.mjs");
+    const data = await this.client.rest.post(Routes2.channelWebhooks(this.id), {
+      body: options,
+      auth: true
+    });
+    return new Webhook(this.client, data);
+  }
+  /**
+   * Fetch all webhooks in this channel.
+   * @returns Webhooks (includes token when listing from channel; can send via send())
+   */
+  async fetchWebhooks() {
+    const { Webhook } = await import("./Webhook-RWDDYW2Q.mjs");
+    const data = await this.client.rest.get(Routes2.channelWebhooks(this.id));
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    return list.map((w) => new Webhook(this.client, w));
+  }
+  /**
+   * Create an invite for this channel.
+   * @param options - max_uses (0–100), max_age (0–604800 seconds), unique, temporary
+   * Requires Create Instant Invite permission.
+   */
+  async createInvite(options) {
+    const { Invite } = await import("./Invite-UM5BU5A6.mjs");
+    const body = {};
+    if (options?.max_uses != null) body.max_uses = options.max_uses;
+    if (options?.max_age != null) body.max_age = options.max_age;
+    if (options?.unique != null) body.unique = options.unique;
+    if (options?.temporary != null) body.temporary = options.temporary;
+    const data = await this.client.rest.post(Routes2.channelInvites(this.id), {
+      body: Object.keys(body).length ? body : void 0,
+      auth: true
+    });
+    return new Invite(this.client, data);
+  }
+  /**
+   * Fetch invites for this channel.
+   * Requires Manage Channel permission.
+   */
+  async fetchInvites() {
+    const { Invite } = await import("./Invite-UM5BU5A6.mjs");
+    const data = await this.client.rest.get(Routes2.channelInvites(this.id));
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    return list.map((i) => new Invite(this.client, i));
+  }
+};
+var TextChannel = class extends GuildChannel {
+  topic;
+  nsfw;
+  rateLimitPerUser;
+  lastMessageId;
+  constructor(client, data) {
+    super(client, data);
+    this.topic = data.topic ?? null;
+    this.nsfw = data.nsfw ?? false;
+    this.rateLimitPerUser = data.rate_limit_per_user ?? 0;
+    this.lastMessageId = data.last_message_id ?? null;
+  }
+  /**
+   * Send a message to this channel.
+   * @param options - Text content or object with content, embeds, and/or files
+   */
+  async send(options) {
+    const opts = typeof options === "string" ? { content: options } : options;
+    const body = buildSendBody(options);
+    const { Message } = await import("./Message-OFIVTTAZ.mjs");
+    const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+    const data = await this.client.rest.post(Routes2.channelMessages(this.id), postOptions);
+    return new Message(this.client, data);
+  }
+  /** Message manager for this channel. Use channel.messages.fetch(messageId). */
+  get messages() {
+    return new MessageManager(this.client, this.id);
+  }
+  /**
+   * Create a message collector for this channel.
+   * Collects messages matching the filter until time expires or max is reached.
+   * @param options - Filter, time (ms), and max count
+   * @example
+   * const collector = channel.createMessageCollector({ filter: m => m.author.id === userId, time: 10000 });
+   * collector.on('collect', m => console.log(m.content));
+   * collector.on('end', (collected, reason) => { ... });
+   */
+  createMessageCollector(options) {
+    return new MessageCollector(this.client, this.id, options);
+  }
+  /**
+   * Fetch pinned messages in this channel.
+   * @returns Pinned messages
+   */
+  async fetchPinnedMessages() {
+    const { Message } = await import("./Message-OFIVTTAZ.mjs");
+    const data = await this.client.rest.get(Routes2.channelPins(this.id));
+    const list = Array.isArray(data) ? data : data?.items ?? [];
+    return list.map((item) => {
+      const msg = typeof item === "object" && item && "message" in item ? item.message : item;
+      return new Message(this.client, msg);
+    });
+  }
+  /**
+   * Fetch a message by ID from this channel.
+   * @param messageId - Snowflake of the message
+   * @returns The message, or null if not found
+   * @deprecated Use channel.messages.fetch(messageId) instead.
+   */
+  async fetchMessage(messageId) {
+    emitDeprecationWarning(
+      "Channel.fetchMessage()",
+      "Use channel.messages.fetch(messageId) instead."
+    );
+    return this.client.channels.fetchMessage(this.id, messageId);
+  }
+};
+var CategoryChannel = class extends GuildChannel {
+};
+var VoiceChannel = class extends GuildChannel {
+  bitrate;
+  userLimit;
+  rtcRegion;
+  constructor(client, data) {
+    super(client, data);
+    this.bitrate = data.bitrate ?? null;
+    this.userLimit = data.user_limit ?? null;
+    this.rtcRegion = data.rtc_region ?? null;
+  }
+};
+var LinkChannel = class extends GuildChannel {
+  url;
+  constructor(client, data) {
+    super(client, data);
+    this.url = data.url ?? null;
+  }
+};
+var DMChannel = class extends Channel {
+  lastMessageId;
+  /** Group DM creator ID. Null for 1:1 DMs. */
+  ownerId;
+  /** Group DM recipients as User objects. Empty for 1:1 DMs. */
+  recipients;
+  /** Group DM member display names (userId -> nickname). */
+  nicks;
+  constructor(client, data) {
+    super(client, data);
+    this.lastMessageId = data.last_message_id ?? null;
+    this.ownerId = data.owner_id ?? null;
+    this.recipients = (data.recipients ?? []).map(
+      (u) => client.getOrCreateUser(u)
+    );
+    this.nicks = data.nicks ?? {};
+  }
+  /**
+   * Send a message to this DM channel.
+   * @param options - Text content or object with content, embeds, and/or files
+   */
+  async send(options) {
+    const opts = typeof options === "string" ? { content: options } : options;
+    const body = buildSendBody(options);
+    const { Message } = await import("./Message-OFIVTTAZ.mjs");
+    const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+    const data = await this.client.rest.post(Routes2.channelMessages(this.id), postOptions);
+    return new Message(this.client, data);
+  }
+  /** Message manager for this channel. Use channel.messages.fetch(messageId). */
+  get messages() {
+    return new MessageManager(this.client, this.id);
+  }
+  /**
+   * Create a message collector for this DM channel.
+   * @param options - Filter, time (ms), and max count
+   */
+  createMessageCollector(options) {
+    return new MessageCollector(this.client, this.id, options);
+  }
+  /**
+   * Fetch pinned messages in this DM channel.
+   * @returns Pinned messages
+   */
+  async fetchPinnedMessages() {
+    const { Message } = await import("./Message-OFIVTTAZ.mjs");
+    const data = await this.client.rest.get(Routes2.channelPins(this.id));
+    const list = Array.isArray(data) ? data : data?.items ?? [];
+    return list.map((item) => {
+      const msg = typeof item === "object" && item && "message" in item ? item.message : item;
+      return new Message(this.client, msg);
+    });
+  }
+  /**
+   * Fetch a message by ID from this DM channel.
+   * @param messageId - Snowflake of the message
+   * @returns The message, or null if not found
+   * @deprecated Use channel.messages.fetch(messageId) instead.
+   */
+  async fetchMessage(messageId) {
+    emitDeprecationWarning(
+      "Channel.fetchMessage()",
+      "Use channel.messages.fetch(messageId) instead."
+    );
+    return this.client.channels.fetchMessage(this.id, messageId);
+  }
+};
+
+export {
+  MessageManager,
+  MessageCollector,
+  Channel,
+  GuildChannel,
+  TextChannel,
+  CategoryChannel,
+  VoiceChannel,
+  LinkChannel,
+  DMChannel
+};

package/dist/{chunk-RCP27MRC.mjs → chunk-UXIF75BV.mjs}

@@ -9,6 +9,8 @@ var GuildBan = class extends Base {
   guildId;
   user;
   reason;
+  /** ISO timestamp when a temporary ban expires. Null for permanent bans. */
+  expiresAt;
   /** @param data - API ban from GET /guilds/{id}/bans or gateway GUILD_BAN_ADD */
   constructor(client, data, guildId) {
     super();
@@ -16,6 +18,7 @@ var GuildBan = class extends Base {
     this.guildId = data.guild_id ?? guildId;
     this.user = client.getOrCreateUser(data.user);
     this.reason = data.reason ?? null;
+    this.expiresAt = data.expires_at ?? null;
   }
   /**
    * Remove this ban (unban the user).

package/dist/chunk-V6T5VMWD.mjs

@@ -0,0 +1,26 @@
+// src/errors/FluxerError.ts
+var FluxerError = class _FluxerError extends Error {
+  code;
+  constructor(message, options) {
+    super(message, options?.cause ? { cause: options.cause } : void 0);
+    this.name = "FluxerError";
+    this.code = options?.code;
+    Object.setPrototypeOf(this, _FluxerError.prototype);
+  }
+};
+
+// src/errors/ErrorCodes.ts
+var ErrorCodes = {
+  ClientNotReady: "CLIENT_NOT_READY",
+  InvalidToken: "INVALID_TOKEN",
+  AlreadyLoggedIn: "ALREADY_LOGGED_IN",
+  ChannelNotFound: "CHANNEL_NOT_FOUND",
+  MessageNotFound: "MESSAGE_NOT_FOUND",
+  GuildNotFound: "GUILD_NOT_FOUND",
+  MemberNotFound: "MEMBER_NOT_FOUND"
+};
+
+export {
+  FluxerError,
+  ErrorCodes
+};

package/dist/{chunk-DSPSRPHF.mjs → chunk-V7LPVPGH.mjs}

@@ -1,11 +1,74 @@
+import {
+  Events
+} from "./chunk-AH7KYH2Z.mjs";
+import {
+  buildSendBody
+} from "./chunk-PM2IUGNR.mjs";
 import {
   Base
 } from "./chunk-XNS4O6QJ.mjs";
 
 // src/structures/Message.ts
-import { Collection } from "@fluxerjs/collection";
+import { Collection as Collection2 } from "@fluxerjs/collection";
 import { MessageType, Routes } from "@fluxerjs/types";
 import { EmbedBuilder } from "@fluxerjs/builders";
+
+// src/util/ReactionCollector.ts
+import { EventEmitter } from "events";
+import { Collection } from "@fluxerjs/collection";
+var ReactionCollector = class extends EventEmitter {
+  client;
+  messageId;
+  channelId;
+  options;
+  collected = new Collection();
+  _timeout = null;
+  _ended = false;
+  _listener;
+  constructor(client, messageId, channelId, options = {}) {
+    super();
+    this.client = client;
+    this.messageId = messageId;
+    this.channelId = channelId;
+    this.options = {
+      filter: options.filter ?? (() => true),
+      time: options.time ?? 0,
+      max: options.max ?? 0
+    };
+    this._listener = (reaction, user, _msgId, chId, _emoji, userId) => {
+      if (this._ended || reaction.messageId !== this.messageId || chId !== this.channelId) return;
+      if (!this.options.filter(reaction, user)) return;
+      const key = `${userId}:${reaction.emoji.id ?? reaction.emoji.name}`;
+      this.collected.set(key, { reaction, user });
+      this.emit("collect", reaction, user);
+      if (this.options.max > 0 && this.collected.size >= this.options.max) {
+        this.stop("limit");
+      }
+    };
+    this.client.on(Events.MessageReactionAdd, this._listener);
+    if (this.options.time > 0) {
+      this._timeout = setTimeout(() => this.stop("time"), this.options.time);
+    }
+  }
+  stop(reason = "user") {
+    if (this._ended) return;
+    this._ended = true;
+    this.client.off(Events.MessageReactionAdd, this._listener);
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+      this._timeout = null;
+    }
+    this.emit("end", this.collected, reason);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+
+// src/structures/Message.ts
 var Message = class _Message extends Base {
   client;
   id;
@@ -28,6 +91,14 @@ var Message = class _Message extends Base {
   messageSnapshots;
   call;
   referencedMessage;
+  /** Webhook ID if this message was sent via webhook. Null otherwise. */
+  webhookId;
+  /** Users mentioned in this message. */
+  mentions;
+  /** Role IDs mentioned in this message. */
+  mentionRoles;
+  /** Client-side nonce for acknowledgment. Null if not provided. */
+  nonce;
   /** Channel where this message was sent. Resolved from cache; null if not cached (e.g. DM channel not in cache). */
   get channel() {
     return this.client.channels.get(this.channelId) ?? null;
@@ -48,7 +119,7 @@ var Message = class _Message extends Base {
     this.createdAt = new Date(data.timestamp);
     this.editedAt = data.edited_timestamp ? new Date(data.edited_timestamp) : null;
     this.pinned = data.pinned;
-    this.attachments = new Collection();
+    this.attachments = new Collection2();
     for (const a of data.attachments ?? []) this.attachments.set(a.id, a);
     this.type = data.type ?? MessageType.Default;
     this.flags = data.flags ?? 0;
@@ -61,17 +132,24 @@ var Message = class _Message extends Base {
     this.messageSnapshots = data.message_snapshots ?? [];
     this.call = data.call ?? null;
     this.referencedMessage = data.referenced_message ? new _Message(client, data.referenced_message) : null;
+    this.webhookId = data.webhook_id ?? null;
+    this.mentions = (data.mentions ?? []).map((u) => client.getOrCreateUser(u));
+    this.mentionRoles = data.mention_roles ?? [];
+    this.nonce = data.nonce ?? null;
   }
   /**
    * Send a message to this channel without replying. Use when you want a standalone message.
-   * @param options - Text content or object with content and/or embeds
+   * @param options - Text content or object with content, embeds, and/or files
    * @example
    * await message.send('Pong!');
    * await message.send({ embeds: [embed.toJSON()] });
+   * await message.send({ content: 'File', files: [{ name: 'data.txt', data }] });
    */
   async send(options) {
-    const body = typeof options === "string" ? { content: options } : options;
-    const data = await this.client.rest.post(Routes.channelMessages(this.channelId), { body });
+    const opts = typeof options === "string" ? { content: options } : options;
+    const body = buildSendBody(options);
+    const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+    const data = await this.client.rest.post(Routes.channelMessages(this.channelId), postOptions);
     return new _Message(this.client, data);
   }
   /**
@@ -87,25 +165,21 @@ var Message = class _Message extends Base {
   }
   /**
    * Reply to this message.
-   * @param options - Text content or object with content and/or embeds
+   * @param options - Text content or object with content, embeds, and/or files
    */
   async reply(options) {
-    const body = typeof options === "string" ? {
-      content: options,
-      message_reference: {
-        channel_id: this.channelId,
-        message_id: this.id,
-        guild_id: this.guildId ?? void 0
-      }
-    } : {
-      ...options,
+    const opts = typeof options === "string" ? { content: options } : options;
+    const base = buildSendBody(options);
+    const body = {
+      ...base,
       message_reference: {
         channel_id: this.channelId,
         message_id: this.id,
         guild_id: this.guildId ?? void 0
       }
     };
-    const data = await this.client.rest.post(Routes.channelMessages(this.channelId), { body });
+    const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+    const data = await this.client.rest.post(Routes.channelMessages(this.channelId), postOptions);
     return new _Message(this.client, data);
   }
   /**
@@ -123,13 +197,26 @@ var Message = class _Message extends Base {
     });
     return new _Message(this.client, data);
   }
+  /**
+   * Create a reaction collector for this message.
+   * Collects reactions matching the filter until time expires or max is reached.
+   * @param options - Filter, time (ms), and max count
+   * @example
+   * const collector = message.createReactionCollector({ filter: (r, u) => u.id === userId, time: 10000 });
+   * collector.on('collect', (reaction, user) => console.log(user.username, 'reacted with', reaction.emoji.name));
+   * collector.on('end', (collected, reason) => { ... });
+   */
+  createReactionCollector(options) {
+    return new ReactionCollector(this.client, this.id, this.channelId, options);
+  }
   /**
    * Re-fetch this message from the API to get the latest content, embeds, reactions, etc.
    * Use when you have a stale Message (e.g. from an old event or cache) and need fresh data.
-   * @returns The updated message, or null if deleted or not found
+   * @returns The updated message
+   * @throws FluxerError with MESSAGE_NOT_FOUND if the message was deleted or does not exist
    * @example
    * const updated = await message.fetch();
-   * if (updated) console.log('Latest content:', updated.content);
+   * console.log('Latest content:', updated.content);
    */
   async fetch() {
     return this.client.channels.fetchMessage(this.channelId, this.id);
@@ -193,8 +280,26 @@ var Message = class _Message extends Base {
     const emojiStr = await this.resolveEmojiForReaction(emoji);
     await this.client.rest.delete(Routes.channelMessageReaction(this.channelId, this.id, emojiStr));
   }
+  /**
+   * Fetch users who reacted with the given emoji.
+   * @param emoji - Unicode emoji or custom `{ name, id }`
+   * @param options - limit (1–100), after (user ID for pagination)
+   * @returns Array of User objects
+   */
+  async fetchReactionUsers(emoji, options) {
+    const emojiStr = await this.resolveEmojiForReaction(emoji);
+    const params = new URLSearchParams();
+    if (options?.limit != null) params.set("limit", String(options.limit));
+    if (options?.after) params.set("after", options.after);
+    const qs = params.toString();
+    const route = Routes.channelMessageReaction(this.channelId, this.id, emojiStr) + (qs ? `?${qs}` : "");
+    const data = await this.client.rest.get(route);
+    const list = Array.isArray(data) ? data : data?.users ?? [];
+    return list.map((u) => this.client.getOrCreateUser(u));
+  }
 };
 
 export {
+  ReactionCollector,
   Message
 };