@stoatx/client 0.2.1 → 0.3.0

package/dist/index.d.cts

@@ -48,10 +48,10 @@ declare class RESTManager {
      */
     uploadFile(filename: string, fileBuffer: Buffer | Blob): Promise<string>;
     get(endpoint: string): Promise<any>;
-    post(endpoint: string, body: any): Promise<any>;
-    patch(endpoint: string, body: any): Promise<any>;
-    delete(endpoint: string): Promise<any>;
-    put(endpoint: string, body: any): Promise<any>;
+    post(endpoint: string, body?: any): Promise<any>;
+    patch(endpoint: string, body?: any): Promise<any>;
+    delete(endpoint: string, body?: any): Promise<any>;
+    put(endpoint: string, body?: any): Promise<any>;
 }
 
 /**
@@ -218,7 +218,7 @@ declare class Collection<K, V> extends Map<K, V> {
  */
 declare abstract class BaseManager<K, Holds> {
     cache: Collection<K, Holds>;
-    protected readonly client: Client;
+    client: Client;
     protected constructor(client: Client, limit?: number);
     /**
      * Defines how to extract the unique ID from a raw API payload.
@@ -343,15 +343,6 @@ declare class MemberManager extends BaseManager<string, Member> {
      * await server.members.unban("1234567890");
      */
     unban(member: MemberResolvable): Promise<void>;
-    /**
-     * Timeouts a member in the server for a specified duration.
-     * @param member The MemberResolvable to timeout
-     * @param duration The duration of the timeout in milliseconds
-     * @example
-     * // Timeout a member for 10 minutes
-     * await server.members.setTimeout("1234567890", 10 * 60 * 1000);
-     */
-    setTimeout(member: MemberResolvable, duration: number): Promise<void>;
     [util.inspect.custom](): Collection<string, Member>;
 }
 
@@ -440,6 +431,209 @@ declare class GroupChannel extends BaseChannel {
     [util.inspect.custom](_depth: number, options: util.InspectOptions, inspect: typeof util.inspect): string;
 }
 
+type UserResolvable = User | string;
+interface UserEditOptions {
+    avatar?: string | null;
+    displayName?: string | null;
+    profile?: UserProfile;
+    status?: UserStatus;
+}
+declare class UserManager extends BaseManager<string, User> {
+    constructor(client: Client, limit?: number);
+    /**
+     * Tell BaseManager how to find the ID for Users
+     */
+    protected extractId(data: any): string;
+    /**
+     * Tell BaseManager how to build a User
+     */
+    protected construct(data: any): User;
+    /**
+     * Resolves a UserResolvable to a User object from the cache.
+     */
+    resolve(user: UserResolvable): User | undefined;
+    /**
+     * Extracts ID from a UserResolvable.
+     * @param user The UserResolvable to extract the ID from.
+     * @returns The extracted user ID.
+     * @throws TypeError if an invalid type is provided.
+     */
+    resolveId(user: UserResolvable): string;
+    /**
+     * Fetches a User.
+     * @param user The ID or mention to fetch
+     * @param force Skip the cache check and force an API request
+     * @returns The fetched User object
+     * @throws Error if the user cannot be found or fetched
+     * @throws TypeError if invalid UserResolvable is provided
+     * @example
+     * // Fetch a user by ID
+     * const user = await client.users.fetch("01JE2MM759J5D7CHJF084R7MJ2");
+     * console.log(user.username);
+     *
+     * // Fetch a user by mention
+     * const user = await client.users.fetch("<@01JE2MM759J5D7CHJF084R7MJ2>");
+     * console.log(user.username);
+     *
+     * // Force fetch a user, bypassing the cache
+     * const user = await client.users.fetch("01JE2MM759J5D7CHJF084R7MJ2", true);
+     * console.log(user.username);
+     */
+    fetch(user: UserResolvable, force?: boolean): Promise<User>;
+    /**
+     * Fetch the current user (the bot itself).
+     * @returns The fetched User object representing the current user.
+     * @throws Error if the user cannot be fetched.
+     * @example
+     * // Fetch the current user (the bot itself)
+     * const me = await client.users.fetchMe();
+     * console.log(`Logged in as ${me.tag}`);
+     */
+    fetchMe(): Promise<User>;
+    /**
+     * Edits the currently authenticated user (the bot itself).
+     * @param options The fields to update (avatar, status, profile, etc.).
+     * @returns A promise that resolves to the updated User object.
+     * @throws {TypeError} If invalid options are provided.
+     * @throws {Error} If the API request fails.
+     * @example
+     * // Update the bot's status and presence
+     * await client.users.editMe({
+     *   status: { text: "Watching the server", presence: "Online" }
+     * });
+     *
+     * // Clear the bot's avatar and display name
+     * await client.users.editMe({ avatar: null, displayName: null });
+     */
+    editMe(options: UserEditOptions): Promise<User>;
+    /**
+     * The DM between the client's user and a user
+     *
+     * @param {string} userId The user id
+     * @returns {?DMChannel}
+     * @private
+     */
+    dmChannel(userId: string): DMChannel | null;
+    /**
+     * Creates a DM channel between the client's user and another user.
+     * @param user The UserResolvable to create a DM with.
+     * @param options Additional options for DM creation.
+     * @param options.force If true, forces the creation of a new DM channel even if one already exists.
+     * @returns A promise that resolves to the created DMChannel object.
+     * @throws {TypeError} If an invalid UserResolvable is provided.
+     * @throws {Error} If the API request fails.
+     * @example
+     * // Create a DM with a user by ID
+     * const dm = await client.users.createDM("1234567890");
+     * console.log(`DM channel ID: ${dm.id}`);
+     */
+    createDM(user: UserResolvable, { force }?: {
+        force?: boolean | undefined;
+    }): Promise<DMChannel>;
+}
+
+type MessageResolvable = Message | string;
+interface MessageFetchOptions {
+    limit?: number;
+    before?: string;
+    after?: string;
+    sort?: "Relevance" | "Latest" | "Oldest";
+    nearby?: string;
+    includeUsers?: boolean;
+}
+declare class MessageManager extends BaseManager<string, Message> {
+    channel: BaseChannel;
+    constructor(client: Client, channel: BaseChannel, limit?: number);
+    /**
+     * Tell BaseManager how to find the ID for Messages
+     */
+    protected extractId(data: any): string;
+    /**
+     * Tell BaseManager how to build a Message
+     */
+    protected construct(data: any): Message;
+    fetch(id: string): Promise<Message>;
+    /**
+     * Fetches multiple messages from the channel using specific filter parameters.
+     * @param options The query parameters to filter the fetched messages.
+     * @returns A promise that resolves to a Collection of fetched Messages.
+     * @throws {Error} If the API request fails.
+     * @example
+     * // Fetch the last 50 messages in the channel
+     * const messages = await channel.messages.fetchMany({ limit: 50, sort: "Latest" });
+     *
+     * // Fetch 20 messages before a specific message ID
+     * const history = await channel.messages.fetchMany({ limit: 20, before: "01H..." });
+     */
+    fetchMany(options?: MessageFetchOptions): Promise<Collection<string, Message>>;
+    resolveId(message: MessageResolvable): string;
+    /**
+     * Sends a new message to this channel.
+     * @param contentOrOptions The string content or message options payload.
+     * @returns A promise that resolves to the sent Message.
+     */
+    send(contentOrOptions: MessageOptions | string): Promise<Message>;
+    /**
+     * Edits an existing message.
+     * @param message The MessageResolvable (object or ID) to edit.
+     * @param contentOrOptions The new content or options.
+     * @returns A promise that resolves to the updated Message.
+     */
+    edit(message: MessageResolvable, contentOrOptions: string | MessageOptions): Promise<Message>;
+    /**
+     * Deletes a message from the channel.
+     * @param message The MessageResolvable to delete.
+     */
+    delete(message: MessageResolvable): Promise<void>;
+    /**
+     * Pins a message in the channel.
+     * @param message The MessageResolvable to pin.
+     */
+    pin(message: MessageResolvable): Promise<void>;
+    /**
+     * Unpins a message in the channel.
+     * @param message The MessageResolvable to unpin.
+     */
+    unpin(message: MessageResolvable): Promise<void>;
+    /**
+     * React to a message
+     * @param message The MessageResolvable to react to.
+     * @param reaction The emoji to react with. Can be a Unicode emoji or a custom emoji ID.
+     * @throws {Error} If the API request fails.
+     * @example
+     * await channel.messages.react(messageId, "👍");
+     * await channel.messages.react(messageId, "customEmojiId");
+     */
+    react(message: MessageResolvable, reaction: string): Promise<void>;
+    /**
+     * Remove a reaction(s) from a message
+     * Requires ManageMessages if changing others' reactions.
+     * @param reaction The emoji to remove. Can be a unicode emoji or a custom emoji ID.
+     * @param message The MessageResolvable to remove the reaction from.
+     * @param userId The ID of the user whose reaction to remove. If not provided, removes the current user's reaction.
+     * @param removeAll Remove all reactions of this type.
+     * @throws {Error} If both userId and removeAll are provided, or if the API request fails.
+     * @example
+     * // Remove the current user's reaction
+     * await channel.messages.removeReaction(messageId, "👍");
+     * // Remove a specific user's reaction
+     * await channel.messages.removeReaction(messageId, "👍", userId);
+     * // Remove all reactions of this type
+     * await channel.messages.removeReaction(messageId, "👍", undefined, true);
+     */
+    removeReaction(message: MessageResolvable, reaction: string, userId?: UserResolvable, removeAll?: boolean): Promise<void>;
+    /**
+     * Remove all reactions from a message
+     * Requires ManageMessages permission.
+     * @param message The MessageResolvable to clear reactions from.
+     * @throws {Error} If the API request fails.
+     * @example
+     * await channel.messages.clearReactions(messageId);
+     */
+    clearReactions(message: MessageResolvable): Promise<void>;
+    [util.inspect.custom](): Collection<string, Message>;
+}
+
 type ChannelResolvable = BaseChannel | string;
 interface ChannelEditOptions {
     name?: string;
@@ -458,7 +652,6 @@ interface ChannelRolePermissionOptions {
     deny?: PermissionResolvable;
 }
 declare class ChannelManager extends BaseManager<string, BaseChannel> {
-    client: Client;
     /**
      * Manages API methods and caching for all channels globally.
      * @param client The active Client instance.
@@ -486,7 +679,7 @@ declare class ChannelManager extends BaseManager<string, BaseChannel> {
     /**
      * Fetches a Channel from the API or resolves it from the local cache.
      * @param channel The ID, mention, or Channel object to fetch.
-     * @param force Whether to skip the cache check and force a direct API request. Defaults to true.
+     * @param force Whether to skip the cache check and force a direct API request. Defaults to false.
      * @returns A promise that resolves to the fetched BaseChannel object.
      * @throws {TypeError} If an invalid ChannelResolvable is provided.
      * @throws {Error} If the API request fails.
@@ -541,6 +734,33 @@ declare class ChannelManager extends BaseManager<string, BaseChannel> {
      * await client.channels.delete("01H...");
      */
     delete(channel: ChannelResolvable): Promise<void>;
+    /**
+     * Pin a message
+     * @param id Channel ID
+     * @param messageId Message ID
+     * @throws {Error} If the API request fails.
+     * @example
+     * await client.channels.pin("CHANNEL_ID", "MESSAGE_ID");
+     */
+    pin(id: string, messageId: string): Promise<void>;
+    /**
+     * Unpin a message
+     * @param id Channel ID
+     * @param messageId Message ID
+     * @throws {Error} If the API request fails
+     * @example
+     * await client.channels.unpin("CHANNEL_ID", "MESSAGE_ID");
+     */
+    unpin(id: string, messageId: string): Promise<void>;
+    /**
+     * Bulk delete up to 100 messages
+     * @param id Channel ID
+     * @param messages An array of MessageResolvable
+     * @throws {Error} If the API request fails
+     * @example
+     * await client.channels.bulkDelete("CHANNEL_ID", ["MESSAGE_ID_1", "MESSAGE_ID_2", "MESSAGE_ID_3"]);
+     */
+    bulkDelete(id: string, messages: MessageResolvable[]): Promise<void>;
 }
 
 declare class TextChannel extends BaseChannel {
@@ -581,72 +801,174 @@ declare class TextChannel extends BaseChannel {
      * await channel.setDefaultPermissions(["ViewChannel", "ReadMessageHistory"]);
      */
     setDefaultPermissions(permissions: PermissionResolvable): Promise<this>;
+    /**
+     * Edits the category of this channel. Only applicable to server channels.
+     * @param category The ID of the category to move this channel into, or "default" to remove from any category.
+     * @returns The updated TextChannel with the new category.
+     * @throws {Error} If the channel is not a server channel, if the category is not found in the server, or if the API request fails.
+     * @example
+     * // Move this channel into a category
+     * await channel.setCategory("CATEGORY_ID");
+     * // Remove this channel from its category
+     * await channel.setCategory("default");
+     */
+    setCategory(category: string): Promise<TextChannel>;
+    /**
+     * Sets the position of this channel within its current category.
+     * @param position The new index position for the channel within its category.
+     * @returns The updated TextChannel.
+     * @throws {Error} If the channel is not in a category, or if the API request fails.
+     * @example
+     * // Move channel to the top of its category
+     * await channel.setPosition(0);
+     */
+    setPosition(position: number): Promise<TextChannel>;
+    /**
+     * Edit the description of this channel
+     * @param description
+     * @throws {Error} If the API request fails
+     * @returns The updated TextChannel
+     * @example
+     * // Set the channel description
+     * await channel.setDescription("This is a channel about cats!");
+     * // Remove the channel description
+     * await channel.setDescription(null);
+     */
+    setDescription(description: string | null): Promise<TextChannel>;
+    /**
+     * Edit the name of this channel
+     * @param name
+     * @throws {Error} If the API request fails
+     * @returns The updated TextChannel
+     * @example
+     * await channel.setName("New Name");
+     */
+    setName(name: string): Promise<TextChannel>;
+    /**
+     * Set whether this channel is NSFW
+     * @param nsfw
+     * @throws {Error} If the API request fails
+     * @returns The updated TextChannel
+     * @example
+     * // Mark the channel as NSFW
+     * await channel.setNSFW(true);
+     * // Mark the channel as SFW
+     * await channel.setNSFW(false);
+     */
+    setNSFW(nsfw: boolean): Promise<TextChannel>;
+    /**
+     * Set the channel slowmode in seconds
+     * @param slowmode
+     * @throws {Error} If the API request fails
+     * @returns The updated TextChannel
+     * @example
+     * // Set the slowmode to 5 seconds
+     * await channel.setSlowmode(5);
+     * // Remove slowmode
+     * await channel.setSlowmode(0);
+     */
+    setSlowmode(slowmode: number): Promise<TextChannel>;
+    /**
+     * Set the channel Icon
+     * @param id Autumn ID to use
+     * @throws {Error} If the API request fails
+     * @returns The updated TextChannel
+     * @example
+     * await channel.setIcon("123");
+     * // Remove the channel icon
+     * await channel.setIcon(null);
+     */
+    setIcon(id: string | null): Promise<TextChannel>;
 }
 
-type MessageResolvable = Message | string;
-interface MessageFetchOptions {
-    limit?: number;
-    before?: string;
-    after?: string;
-    sort?: "Relevance" | "Latest" | "Oldest";
-    nearby?: string;
-    includeUsers?: boolean;
+/**
+ * Options to be passed to a Collector
+ */
+interface CollectorOptions<V> {
+    /** The filter applied to this collector */
+    filter?: (item: V, ...args: any[]) => boolean;
+    /** How long to run the collector for in milliseconds */
+    time?: number;
+    /** How long to stop the collector after inactivity in milliseconds */
+    idle?: number;
+    /** Whether to dispose data when it's deleted */
+    dispose?: boolean;
 }
-declare class MessageManager extends BaseManager<string, Message> {
-    private channel;
-    constructor(client: Client, channel: BaseChannel, limit?: number);
+/**
+ * Abstract class for defining a new Collector
+ */
+declare abstract class Collector<K, V> extends EventEmitter {
+    readonly client: Client;
+    filter: (item: V, ...args: any[]) => boolean;
+    options: CollectorOptions<V>;
+    collected: Collection<K, V>;
+    ended: boolean;
+    private _timeout;
+    private _idletimeout;
+    protected constructor(client: Client, options?: CollectorOptions<V>);
     /**
-     * Tell BaseManager how to find the ID for Messages
+     * Evaluates an item and possibly passes it to the collector
      */
-    protected extractId(data: any): string;
+    handleCollect(item: V, ...args: any[]): void;
     /**
-     * Tell BaseManager how to build a Message
+     * Evaluates an item and possibly removes it from the collector
      */
-    protected construct(data: any): Message;
-    fetch(id: string): Promise<Message>;
+    handleDispose(item: V, ...args: any[]): void;
     /**
-     * Fetches multiple messages from the channel using specific filter parameters.
-     * @param options The query parameters to filter the fetched messages.
-     * @returns A promise that resolves to a Collection of fetched Messages.
-     * @throws {Error} If the API request fails.
-     * @example
-     * // Fetch the last 50 messages in the channel
-     * const messages = await channel.messages.fetchMany({ limit: 50, sort: "Latest" });
-     *
-     * // Fetch 20 messages before a specific message ID
-     * const history = await channel.messages.fetchMany({ limit: 20, before: "01H..." });
+     * Stops the collector.
      */
-    fetchMany(options?: MessageFetchOptions): Promise<Collection<string, Message>>;
-    resolveId(message: MessageResolvable): string;
+    stop(reason?: string): void;
     /**
-     * Sends a new message to this channel.
-     * @param contentOrOptions The string content or message options payload.
-     * @returns A promise that resolves to the sent Message.
+     * Check if we should end upon collecting/disposing
      */
-    send(contentOrOptions: MessageOptions | string): Promise<Message>;
+    checkEnd(): void;
     /**
-     * Edits an existing message.
-     * @param message The MessageResolvable (object or ID) to edit.
-     * @param contentOrOptions The new content or options.
-     * @returns A promise that resolves to the updated Message.
+     * Check if there's a reason to end
      */
-    edit(message: MessageResolvable, contentOrOptions: string | MessageOptions): Promise<Message>;
+    endReason(): string | null;
     /**
-     * Deletes a message from the channel.
-     * @param message The MessageResolvable to delete.
+     * Returns a key if the item should be collected, or null to skip
      */
-    delete(message: MessageResolvable): Promise<void>;
+    abstract collect(item: V, ...args: any[]): K | null;
     /**
-     * Pins a message in the channel.
-     * @param message The MessageResolvable to pin.
+     * Returns a key if the item should be disposed, or null to skip
      */
-    pin(message: MessageResolvable): Promise<void>;
+    abstract dispose(item: V, ...args: any[]): K | null;
     /**
-     * Unpins a message in the channel.
-     * @param message The MessageResolvable to unpin.
+     * Allows iterating over collected items asynchronously.
+     * @example
+     * for await (const [id, message] of collector) {
+     *   console.log(`Received message: ${message.content}`);
+     * }
      */
-    unpin(message: MessageResolvable): Promise<void>;
-    [util.inspect.custom](): Collection<string, Message>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<[K, V]>;
+}
+
+/**
+ * Options to be passed to a MessageCollector
+ */
+interface MessageCollectorOptions extends CollectorOptions<Message> {
+    /** The maximum number of messages to collect */
+    max?: number;
+    /** The maximum number of messages to process (both matching and non-matching the filter) */
+    maxProcessed?: number;
+}
+/**
+ * Collects messages on a channel.
+ */
+declare class MessageCollector extends Collector<string, Message> {
+    channel: BaseChannel;
+    channelId: string;
+    total: number;
+    processed: number;
+    constructor(channel: BaseChannel, options?: MessageCollectorOptions);
+    collect(message: Message): string | null;
+    dispose(message: Message | {
+        id: string;
+        channelId: string;
+    }): string | null;
+    handleCollect(message: Message): void;
+    endReason(): string | null;
 }
 
 declare enum ChannelType {
@@ -676,29 +998,95 @@ declare abstract class BaseChannel extends Base {
      * await channel.send({ content: "Here is an embed", embeds: [myEmbed] });
      */
     send(contentOrOptions: string | MessageOptions): Promise<Message>;
-    fetch(force?: boolean): Promise<this>;
+    /**
+     * Fetch this channel
+     * @param force Whether to skip the cache check and force a direct API request. Defaults to false
+     * @throws {Error} If the API request fails
+     * @returns {BaseChannel}
+     * @example
+     * // Force fetch channel to update its data
+     * await channel.fetch(true);
+     */
+    fetch(force?: boolean): Promise<BaseChannel>;
     /**
      * Fetches multiple messages from this channel.
      * @param options The query parameters to filter the messages.
+     * @throws {Error} If the API request fails
+     * @returns A Collection of Messages, keyed by their ID.
+     * @example
+     * // Fetch the last 50 messages in the channel
+     * const messages = await channel.fetchMessages({ limit: 50 });
+     * console.log(`Fetched ${messages.size} messages`);
+     * // Fetch messages before a specific message ID
+     * const messages = await channel.fetchMessages({ before: "MESSAGE_ID" });
+     * console.log(`Fetched ${messages.size} messages sent before the specified message`);
+     * // Fetch messages after a specific message ID
+     * const messages = await channel.fetchMessages({ after: "MESSAGE_ID" });
+     * console.log(`Fetched ${messages.size} messages sent after the specified message`);
+     * // Fetch messages around a specific message ID
+     * const messages = await channel.fetchMessages({ around: "MESSAGE_ID", limit: 10 });
+     * console.log(`Fetched ${messages.size} messages sent around the specified message`);
      */
     fetchMessages(options?: MessageFetchOptions): Promise<Collection<string, Message>>;
     /**
      * Edits this channel.
      * @param options The fields to update
+     * @throws {Error} If the API request fails
+     * @returns BaseChannel
+     * @example
+     * // Edit the channel's name
+     * await channel.edit({name: "New Cool Name"});
      */
-    edit(options: ChannelEditOptions): Promise<this>;
+    edit(options: ChannelEditOptions): Promise<BaseChannel>;
     /**
      * Deletes this channel.
+     * @throws {Error} If the API request fails
+     * @example
+     * // Delete the channel
+     * await channel.delete();
      */
     delete(): Promise<void>;
+    /**
+     * Bulk delete messages from this channel
+     * @param messages MessageResolvable to delete
+     * @throws {Error} If the API request fails
+     * @example
+     * // Delete messages by their ID's
+     * await channel.bulkDelete(["MESSAGE_ID_1", "MESSAGE_ID_2", "MESSAGE_ID_3"]);
+     * // Delete messages by their Message objects
+     * await channel.bulkDelete([message1, message2, message3]);
+     */
+    bulkDelete(messages: MessageResolvable[]): Promise<void>;
+    /**
+     * Creates a MessageCollector to collect messages in this channel.
+     * @param options The options for the collector.
+     * @returns The instantiated MessageCollector
+     * @example
+     * const collector = channel.createMessageCollector({ filter: m => m.authorId === '123', time: 15000 });
+     * collector.on('collect', m => console.log(`Collected ${m.content}`));
+     * collector.on('end', collected => console.log(`Collected ${collected.size} items`));
+     */
+    createMessageCollector(options?: MessageCollectorOptions): MessageCollector;
+    /**
+     * Awaits messages in this channel that meet certain criteria.
+     * @param options The options for the collector.
+     * @returns A promise that resolves to a collection of messages.
+     * @example
+     * // Await !vote messages
+     * const filter = m => m.content.startsWith('!vote');
+     * channel.awaitMessages({ filter, max: 4, time: 60000 })
+     *   .then(collected => console.log(collected.size))
+     *   .catch(console.error);
+     */
+    awaitMessages(options?: MessageCollectorOptions): Promise<Collection<string, Message>>;
     isText(): this is TextChannel;
     isDM(): this is DMChannel;
     isGroup(): this is GroupChannel;
 }
 
 declare class ServerChannelManager {
-    private client;
-    private server;
+    client: Client;
+    server: Server;
     constructor(client: Client, server: Server);
     get cache(): Collection<string, BaseChannel>;
     /**
@@ -815,7 +1203,7 @@ interface RolePermissionOptions {
 }
 type RoleResolvable = Role | string;
 declare class RoleManager extends BaseManager<string, Role> {
-    private server;
+    server: Server;
     /**
      * Manages API methods and caching for server roles.
      */
@@ -1029,6 +1417,35 @@ declare class ServerManager extends BaseManager<string, Server> {
     [util.inspect.custom](): Collection<string, Server>;
 }
 
+interface EmojiParent {
+    id: string;
+    type: "Server";
+}
+declare class Emoji extends Base {
+    creatorId: string;
+    name: string;
+    parent: EmojiParent;
+    animated: boolean;
+    nsfw: boolean;
+    constructor(client: Client, data: any);
+    _patch(data: any): void;
+}
+
+declare class EmojiManager extends BaseManager<string, Emoji> {
+    server?: Server | undefined;
+    constructor(client: Client, server?: Server | undefined, limit?: number);
+    /**
+     * Tell BaseManager how to find the ID for Emojis
+     */
+    protected extractId(data: any): string;
+    /**
+     * Tell BaseManager how to build an Emoji
+     */
+    protected construct(data: any): Emoji;
+    fetch(id: string): Promise<Emoji>;
+    [util.inspect.custom](): Collection<string, Emoji>;
+}
+
 interface Categories {
     channels: string[];
     id: string;
@@ -1052,6 +1469,7 @@ declare class Server extends Base {
     roles: RoleManager;
     bans: ServerBanManager;
     invites: ServerInviteManager;
+    emojis: EmojiManager;
     constructor(client: Client, data: any);
     /**
      * Updates the server instance with new data without losing the object reference.
@@ -1075,7 +1493,7 @@ declare class Server extends Base {
 }
 
 declare class MemberRoleManager {
-    private member;
+    member: Member;
     constructor(member: Member);
     /**
      * Gets a Collection of the actual Role objects this member has.
@@ -1169,6 +1587,18 @@ declare class Member extends Base {
      * await member.setTimeout(600000);
      */
     setTimeout(duration: number): Promise<void>;
+    /**
+     * Send a message to this member.
+     * @param options The content or options for the message to send.
+     * @returns A promise that resolves to the sent Message object.
+     * @throws {Error} If the API request fails.
+     * @example
+     * // Send a message to this member
+     * const message = await member.send("Hello!");
+     * console.log(`Sent message ID: ${message.id}`);
+     */
+    send(options: string | MessageOptions): Promise<Message>;
+    setNickname(nickname: string): Promise<Member>;
     /** Checks if the member has a specific permission */
     hasPermission(permission: PermissionResolvable): boolean;
     /**
@@ -1176,7 +1606,15 @@ declare class Member extends Base {
      * @param options The options to edit the member with (nickname, roles, timeout, etc.)
      * @returns A promise that resolves to the updated Member.
      */
-    edit(options: MemberEditOptions): Promise<this>;
+    edit(options: MemberEditOptions): Promise<Member>;
+    /**
+     * When concatenated with a string, this automatically returns the user's mention instead of the GuildMember object.
+     * @returns {string}
+     * @example
+     * // Logs: Hello from <@01JE2MM759J5D7CHJF084R7MJ2>!
+     * console.log(`Hello from ${member}!`);
+     */
+    toString(): string;
     /**
      * Kick this member from the server.
      */
@@ -1209,6 +1647,48 @@ declare class EmbedBuilder {
     toJSON(): TextEmbedData;
 }
 
+declare class MessageReaction {
+    client: Client;
+    message: Message | {
+        id: string;
+        channelId: string;
+    };
+    emoji: Emoji | string;
+    users: Collection<string, User | {
+        id: string;
+    }>;
+    constructor(client: Client, data: {
+        message: Message | {
+            id: string;
+            channelId: string;
+        };
+        emojiId: string;
+        users?: string[];
+    });
+    get count(): number;
+    remove(): Promise<void>;
+    [util.inspect.custom](): string;
+}
+
+interface ReactionCollectorOptions extends CollectorOptions<MessageReaction> {
+    /** The maximum number of reactions to collect */
+    max?: number;
+    /** The maximum number of users to collect reactions from */
+    maxUsers?: number;
+}
+declare class ReactionCollector extends Collector<string, MessageReaction> {
+    message: Message;
+    messageId: string;
+    total: number;
+    users: Set<string>;
+    constructor(message: Message, options?: ReactionCollectorOptions);
+    collect(reaction: MessageReaction): string | null;
+    dispose(reaction: MessageReaction): string | null;
+    private handleMessageReact;
+    private handleMessageUnreact;
+    endReason(): string | null;
+}
+
 interface MessageOptions {
     content?: string;
     embeds?: (TextEmbedData | EmbedBuilder)[];
@@ -1245,7 +1725,7 @@ declare class Message extends Base {
     masquerade: Masquerade | null;
     mentions: string[];
     pinned: boolean;
-    reactions: any[];
+    reactions: Record<string, string[]>;
     replies: string[];
     role_mentions: string[];
     constructor(client: Client, data: any);
@@ -1267,119 +1747,71 @@ declare class Message extends Base {
      * Unpins this message.
      */
     unpin(): Promise<void>;
-    /** Gets the Channel object from cache */
-    get channel(): BaseChannel | undefined;
-    /** Gets the Global User object from cache */
-    get author(): User | undefined;
-    /** Gets the Server Member object (if sent in a server) */
-    get member(): Member | undefined;
-    /** Gets the Server ID if this message was sent in a server channel */
-    get serverId(): string | undefined;
-    /** Gets the Server object from cache */
-    get server(): Server | undefined;
-    _patch(data: any): void;
-    [util.inspect.custom](depth: number, options: util.InspectOptions, inspect: typeof util.inspect): string;
-}
-
-type UserResolvable = User | string;
-interface UserEditOptions {
-    avatar?: string | null;
-    displayName?: string | null;
-    profile?: UserProfile;
-    status?: UserStatus;
-}
-declare class UserManager extends BaseManager<string, User> {
-    constructor(client: Client, limit?: number);
-    /**
-     * Tell BaseManager how to find the ID for Users
-     */
-    protected extractId(data: any): string;
-    /**
-     * Tell BaseManager how to build a User
-     */
-    protected construct(data: any): User;
-    /**
-     * Resolves a UserResolvable to a User object from the cache.
-     */
-    resolve(user: UserResolvable): User | undefined;
-    /**
-     * Extracts ID from a UserResolvable.
-     * @param user The UserResolvable to extract the ID from.
-     * @returns The extracted user ID.
-     * @throws TypeError if an invalid type is provided.
-     */
-    resolveId(user: UserResolvable): string;
     /**
-     * Fetches a User.
-     * @param user The ID or mention to fetch
-     * @param force Skip the cache check and force an API request
-     * @returns The fetched User object
-     * @throws Error if the user cannot be found or fetched
-     * @throws TypeError if invalid UserResolvable is provided
+     * React to this message
+     * @param reaction The emoji to react with. Can be a Unicode emoji or a custom emoji ID.
+     * @throws {Error} If the API request fails.
      * @example
-     * // Fetch a user by ID
-     * const user = await client.users.fetch("01JE2MM759J5D7CHJF084R7MJ2");
-     * console.log(user.username);
-     *
-     * // Fetch a user by mention
-     * const user = await client.users.fetch("<@01JE2MM759J5D7CHJF084R7MJ2>");
-     * console.log(user.username);
-     *
-     * // Force fetch a user, bypassing the cache
-     * const user = await client.users.fetch("01JE2MM759J5D7CHJF084R7MJ2", true);
-     * console.log(user.username);
+     * await message.react("👍");
+     * await message.react("customEmojiId");
      */
-    fetch(user: UserResolvable, force?: boolean): Promise<User>;
+    react(reaction: string): Promise<void>;
     /**
-     * Fetch the current user (the bot itself).
-     * @returns The fetched User object representing the current user.
-     * @throws Error if the user cannot be fetched.
+     * Remove a reaction from this message
+     * @param reaction The emoji to remove. Can be a Unicode emoji or a custom emoji ID.
+     * @param userId The ID of the user whose reaction to remove. If not provided, removes the current user's reaction.
+     * @param removeAll Remove all reactions of this type.
+     * @throws {Error} If both userId and removeAll are provided, or if the API request fails.
      * @example
-     * // Fetch the current user (the bot itself)
-     * const me = await client.users.fetchMe();
-     * console.log(`Logged in as ${me.tag}`);
+     * // Remove the current user's reaction
+     * await message.removeReaction("👍");
+     * // Remove a specific user's reaction
+     * await message.removeReaction("👍", userId);
+     * // Remove all reactions of this type
+     * await message.removeReaction("👍", undefined, true);
      */
-    fetchMe(): Promise<User>;
+    removeReaction(reaction: string, userId?: UserResolvable, removeAll?: boolean): Promise<void>;
     /**
-     * Edits the currently authenticated user (the bot itself).
-     * @param options The fields to update (avatar, status, profile, etc.).
-     * @returns A promise that resolves to the updated User object.
-     * @throws {TypeError} If invalid options are provided.
+     * Remove all reactions from this message
      * @throws {Error} If the API request fails.
      * @example
-     * // Update the bot's status and presence
-     * await client.users.editMe({
-     *   status: { text: "Watching the server", presence: "Online" }
-     * });
-     *
-     * // Clear the bot's avatar and display name
-     * await client.users.editMe({ avatar: null, displayName: null });
+     * await message.clearReactions();
      */
-    editMe(options: UserEditOptions): Promise<User>;
+    clearReactions(): Promise<void>;
     /**
-     * The DM between the client's user and a user
-     *
-     * @param {string} userId The user id
-     * @returns {?DMChannel}
-     * @private
+     * Creates a ReactionCollector to collect reactions on this message.
+     * @param options The options for the collector.
+     * @returns A new ReactionCollector instance.
+     * @example
+     * const collector = message.createReactionCollector({ time: 15000 });
+     * collector.on('collect', (reaction) => console.log(`Collected ${reaction.emojiId} from ${reaction.userId}`));
+     * collector.on('end', (collected) => console.log(`Collected ${collected.size} items`));
      */
-    dmChannel(userId: string): DMChannel | null;
+    createReactionCollector(options?: ReactionCollectorOptions): ReactionCollector;
     /**
-     * Creates a DM channel between the client's user and another user.
-     * @param user The UserResolvable to create a DM with.
-     * @param options Additional options for DM creation.
-     * @param options.force If true, forces the creation of a new DM channel even if one already exists.
-     * @returns A promise that resolves to the created DMChannel object.
-     * @throws {TypeError} If an invalid UserResolvable is provided.
-     * @throws {Error} If the API request fails.
+     * Awaits reactions on this message.
+     * @param options The options for the collector.
+     * @returns A promise that resolves to a collection of reactions collected.
      * @example
-     * // Create a DM with a user by ID
-     * const dm = await client.users.createDM("1234567890");
-     * console.log(`DM channel ID: ${dm.id}`);
+     * // Await reactions
+     * const filter = (reaction) => reaction.emoji.id === '123' && reaction.users.has(author.id);
+     * message.awaitReactions({ filter, max: 1, time: 60000 })
+     *   .then(collected => console.log(collected.size))
+     *   .catch(console.error);
      */
-    createDM(user: UserResolvable, { force }?: {
-        force?: boolean | undefined;
-    }): Promise<DMChannel>;
+    awaitReactions(options?: ReactionCollectorOptions): Promise<Collection<string, MessageReaction>>;
+    /** Gets the Channel object from cache */
+    get channel(): BaseChannel | undefined;
+    /** Gets the Global User object from cache */
+    get author(): User | undefined;
+    /** Gets the Server Member object (if sent in a server) */
+    get member(): Member | undefined;
+    /** Gets the Server ID if this message was sent in a server channel */
+    get serverId(): string | undefined;
+    /** Gets the Server object from cache */
+    get server(): Server | undefined;
+    _patch(data: any): void;
+    [util.inspect.custom](depth: number, options: util.InspectOptions, inspect: typeof util.inspect): string;
 }
 
 /**
@@ -1396,9 +1828,9 @@ interface SweeperOptions {
     };
 }
 declare class SweeperManager {
-    private client;
-    private options;
     private messageInterval;
+    client: Client;
+    options: SweeperOptions;
     constructor(client: Client, options: SweeperOptions);
     start(): void;
     private sweepMessages;
@@ -1413,6 +1845,18 @@ interface ClientEvents {
         id: string;
         channelId: string;
     }];
+    messageReact: [message: Message | {
+        id: string;
+        channelId: string;
+    }, emojiId: string, userId: string];
+    messageUnreact: [message: Message | {
+        id: string;
+        channelId: string;
+    }, emojiId: string, userId: string];
+    messageRemoveReaction: [message: Message | {
+        id: string;
+        channelId: string;
+    }, emojiId: string];
     error: [error: Error];
     debug: [message: string];
     raw: [data: any];
@@ -1432,6 +1876,7 @@ interface ClientOptions {
         users?: number;
         servers?: number;
         channels?: number;
+        emojis?: number;
     };
 }
 declare class Client extends EventEmitter {
@@ -1442,6 +1887,7 @@ declare class Client extends EventEmitter {
     servers: ServerManager;
     users: UserManager;
     sweepers: SweeperManager;
+    emojis: EmojiManager;
     user: ClientUser | null;
     constructor(options?: ClientOptions);
     /**
@@ -1460,4 +1906,4 @@ declare class UnknownChannel extends BaseChannel {
     constructor(client: Client, data: any);
 }
 
-export { Attachment, type AttachmentMetadata, Base, BaseChannel, type BotInformation, type Categories, type ChannelCreateOptions, type ChannelEditOptions, ChannelManager, type ChannelResolvable, type ChannelRolePermissionOptions, ChannelType, Client, type ClientEvents, type ClientOptions, ClientUser, Collection, DMChannel, EmbedBuilder, type FetchMembersOptions, GatewayManager, type Interaction, type Masquerade, Member, type MemberBanOptions, type MemberEditOptions, MemberManager, type MemberResolvable, Message, type MessageFetchOptions, MessageManager, type MessageOptions, type MessageResolvable, PermissionFlags, type PermissionResolvable, type PermissionString, Permissions, RESTManager, type ReplyIntent, Role, type RoleCreateOptions, type RoleEditOptions, RoleManager, type RolePermissionOptions, type RoleResolvable, Server, ServerChannelManager, type ServerEditOptions, ServerManager, StoatAPIError, SweeperManager, type SweeperOptions, TextChannel, type TextEmbedData, UnknownChannel, User, type UserEditOptions, UserManager, UserPresence, type UserProfile, UserRelationship, type UserResolvable, type UserStatus };
+export { Attachment, type AttachmentMetadata, Base, BaseChannel, type BotInformation, type Categories, type ChannelCreateOptions, type ChannelEditOptions, ChannelManager, type ChannelResolvable, type ChannelRolePermissionOptions, ChannelType, Client, type ClientEvents, type ClientOptions, ClientUser, Collection, Collector, type CollectorOptions, DMChannel, EmbedBuilder, Emoji, EmojiManager, type EmojiParent, type FetchMembersOptions, GatewayManager, type Interaction, type Masquerade, Member, type MemberBanOptions, type MemberEditOptions, MemberManager, type MemberResolvable, Message, MessageCollector, type MessageCollectorOptions, type MessageFetchOptions, MessageManager, type MessageOptions, MessageReaction, type MessageResolvable, PermissionFlags, type PermissionResolvable, type PermissionString, Permissions, RESTManager, ReactionCollector, type ReactionCollectorOptions, type ReplyIntent, Role, type RoleCreateOptions, type RoleEditOptions, RoleManager, type RolePermissionOptions, type RoleResolvable, Server, ServerChannelManager, type ServerEditOptions, ServerManager, StoatAPIError, SweeperManager, type SweeperOptions, TextChannel, type TextEmbedData, UnknownChannel, User, type UserEditOptions, UserManager, UserPresence, type UserProfile, UserRelationship, type UserResolvable, type UserStatus };