@stoatx/client 0.2.2 → 0.4.0

package/dist/index.d.ts

@@ -18,6 +18,28 @@ declare class GatewayManager {
     disconnect(): void;
 }
 
+type CDNTag = "attachments" | "avatars" | "backgrounds" | "icons" | "banners" | "emojis";
+declare class AttachmentBuilder {
+    readonly filename: string | undefined;
+    readonly file: Buffer | Blob;
+    /**
+     * Creates a new AttachmentBuilder with the given file and optional filename.
+     * @param file The file data as a Buffer or Blob.
+     * @param filename An optional filename to use for the uploaded file. If not provided, the CDN will assign a default name.
+     *                 Providing a filename can help with organization and debugging, but is not strictly required.
+     * @example
+     * // Create an attachment from a Buffer with a custom filename
+     * const buffer = Buffer.from("Hello, world!");
+     * const attachment = new AttachmentBuilder(buffer, "greeting.txt");
+     */
+    constructor(file: Buffer | Blob, filename?: string);
+    /**
+     * Uploads this attachment to the Stoat CDN and returns the resulting file ID.
+     * @internal — use `resolveAttachment()` instead of calling this directly.
+     */
+    upload(rest: RESTManager, tag: CDNTag): Promise<string>;
+}
+
 /**
  * Custom Error class for Stoat API failures
  */
@@ -46,12 +68,12 @@ declare class RESTManager {
     /**
      * Uploads a file to Stoat's CDN and returns the File ID
      */
-    uploadFile(filename: string, fileBuffer: Buffer | Blob): Promise<string>;
+    uploadFile(tag: CDNTag, fileBuffer: Buffer | Blob, filename?: string): 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>;
 }
 
 /**
@@ -343,16 +365,142 @@ declare class MemberManager extends BaseManager<string, Member> {
      * await server.members.unban("1234567890");
      */
     unban(member: MemberResolvable): Promise<void>;
+    [util.inspect.custom](): Collection<string, Member>;
+}
+
+type BitFieldResolvable = number | string | bigint | BitField | BitFieldResolvable[];
+declare class BitField {
+    static Flags: Record<string, number | bigint>;
+    static DefaultBit: number | bigint;
+    bitfield: number | bigint;
+    constructor(bits?: BitFieldResolvable);
+    /**
+     * Checks whether this bitfield has any of the given bits set.
+     *
+     * @param bit The bit(s) to test against.
+     * @returns `true` if at least one of the provided bits is set.
+     *
+     * @example
+     * perms.any(['SendMessage', 'ManageChannel']); // true if either is set
+     */
+    any(bit: BitFieldResolvable): boolean;
     /**
-     * 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
+     * Checks whether this bitfield is exactly equal to the given bit value.
+     *
+     * @param bit The bit(s) to compare against.
+     * @returns `true` if the resolved bit value is identical to this bitfield.
+     *
      * @example
-     * // Timeout a member for 10 minutes
-     * await server.members.setTimeout("1234567890", 10 * 60 * 1000);
+     * new Permissions(0n).equals(0n); // true
      */
-    setTimeout(member: MemberResolvable, duration: number): Promise<void>;
-    [util.inspect.custom](): Collection<string, Member>;
+    equals(bit: BitFieldResolvable): boolean;
+    /**
+     * Checks whether this bitfield has *all* of the given bits set.
+     *
+     * @param bit The bit(s) to check for.
+     * @returns `true` if every provided bit is set in this bitfield.
+     *
+     * @example
+     * perms.has('SendMessage');
+     * perms.has(['SendMessage', 'ViewChannel']); // true only if both are set
+     */
+    has(bit: BitFieldResolvable, ..._hasParams: any[]): boolean;
+    /**
+     * Returns the flag names present in `bits` that are *missing* from this bitfield.
+     *
+     * @param bits The bits to check against.
+     * @returns An array of flag name strings that are in `bits` but not in this bitfield.
+     *
+     * @example
+     * // If perms only has SendMessage:
+     * perms.missing(['SendMessage', 'ManageChannel']); // ['ManageChannel']
+     */
+    missing(bits: BitFieldResolvable, ...hasParams: any[]): string[];
+    /**
+     * Freezes this BitField instance, making it immutable.
+     * Subsequent calls to `add()` or `remove()` will return a new instance instead of mutating this one.
+     *
+     * @returns This instance, frozen.
+     */
+    freeze(): Readonly<this>;
+    /**
+     * Adds one or more bits to this bitfield.
+     * If the instance is frozen, returns a new BitField with the bits added.
+     *
+     * @param bits The bit(s) to add.
+     * @returns This instance (or a new one if frozen), with the bits added.
+     *
+     * @example
+     * perms.add('SendMessage', 'ViewChannel');
+     */
+    add(...bits: BitFieldResolvable[]): this;
+    /**
+     * Removes one or more bits from this bitfield.
+     * If the instance is frozen, returns a new BitField with the bits removed.
+     *
+     * @param bits The bit(s) to remove.
+     * @returns This instance (or a new one if frozen), with the bits cleared.
+     *
+     * @example
+     * perms.remove('ManageChannel');
+     */
+    remove(...bits: BitFieldResolvable[]): this;
+    /**
+     * Serializes this bitfield to a plain object mapping each flag name to a boolean
+     * indicating whether that flag is set.
+     *
+     * @returns A record of `{ [flagName]: boolean }` for all defined flags.
+     *
+     * @example
+     * perms.serialize();
+     * // { SendMessage: true, ManageChannel: false, ... }
+     */
+    serialize(...hasParams: any[]): Record<string, boolean>;
+    /**
+     * Returns an array of flag names that are set in this bitfield.
+     *
+     * @returns An array of string flag names.
+     *
+     * @example
+     * perms.toArray(); // ['SendMessage', 'ViewChannel']
+     */
+    toArray(...hasParams: any[]): string[];
+    /**
+     * Returns the bitfield value as a JSON-safe primitive.
+     * Numbers are returned as-is; bigints are converted to their string representation
+     * to avoid JSON serialization errors.
+     */
+    toJSON(): number | string;
+    /**
+     * Returns the underlying numeric value of this bitfield.
+     * Allows BitField instances to be used directly in arithmetic expressions.
+     */
+    valueOf(): number | bigint;
+    /**
+     * Iterates over the names of all flags that are set in this bitfield.
+     *
+     * @example
+     * for (const flag of perms) {
+     *   console.log(flag); // 'SendMessage', 'ViewChannel', etc.
+     * }
+     */
+    [Symbol.iterator](...hasParams: any[]): IterableIterator<string>;
+    /**
+     * Resolves a {@link BitFieldResolvable} into a raw `number | bigint`.
+     *
+     * Resolution rules (in order):
+     * - `undefined` → `DefaultBit`
+     * - A number or bigint matching `DefaultBit`'s type and >= 0 → returned as-is
+     * - A `BitField` instance → its `.bitfield` value
+     * - An array → each element resolved and OR'd together
+     * - A numeric string → parsed as `BigInt` or `Number` depending on `DefaultBit`'s type
+     * - A named string flag → looked up in `Flags`
+     * - Anything else → throws `RangeError`
+     *
+     * @param bit The value to resolve.
+     * @throws {RangeError} If the value cannot be resolved to a valid bit.
+     */
+    static resolve(bit?: BitFieldResolvable): number | bigint;
 }
 
 declare const PermissionFlags: {
@@ -392,16 +540,16 @@ declare const PermissionFlags: {
     readonly GrantAllSafe: 4503599627370495n;
 };
 type PermissionString = keyof typeof PermissionFlags;
-type PermissionResolvable = bigint | PermissionString | PermissionResolvable[];
-declare class Permissions {
-    /**
-     * Converts a string, BigInt, or array of strings into a single BigInt
-     */
-    static resolve(permission: PermissionResolvable): bigint;
-    /**
-     * Checks if a specific permission bit exists
-     */
-    static has(totalPermissions: bigint, permissionToCheck: PermissionResolvable): boolean;
+type PermissionResolvable = PermissionString | bigint | number | Permissions | PermissionResolvable[];
+declare class Permissions extends BitField {
+    static Flags: Record<string, number | bigint>;
+    static DefaultBit: bigint;
+    static resolve(bit?: PermissionResolvable): bigint;
+    has(bit: PermissionResolvable): boolean;
+    any(bit: PermissionResolvable): boolean;
+    missing(bits: PermissionResolvable): PermissionString[];
+    add(...bits: PermissionResolvable[]): this;
+    remove(...bits: PermissionResolvable[]): this;
 }
 
 declare class DMChannel extends BaseChannel {
@@ -440,12 +588,215 @@ 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;
     description?: string | null;
     owner?: string;
-    icon?: string | null;
+    icon?: string | AttachmentBuilder | null;
     nsfw?: boolean;
     archived?: boolean;
     voice?: {
@@ -485,7 +836,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.
@@ -540,6 +891,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 {
@@ -580,72 +958,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;
-}
-declare class MessageManager extends BaseManager<string, Message> {
-    channel: BaseChannel;
-    constructor(client: Client, channel: BaseChannel, limit?: number);
+
+/**
+ * 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;
+}
+/**
+ * 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 {
@@ -675,21 +1155,87 @@ 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;
@@ -715,7 +1261,8 @@ declare class Role extends Base {
     color: string | null;
     hoist: boolean;
     rank: number;
-    permissions: bigint;
+    icon: Attachment | null;
+    private _permissions;
     constructor(client: Client, data: any, serverId: string);
     /**
      * Updates the role instance with new data without losing the object reference.
@@ -728,11 +1275,9 @@ declare class Role extends Base {
      */
     get server(): Server | undefined;
     /**
-     * Checks whether this role has a specific permission.
-     * @param permission The permission to check for.
-     * @returns True if the role has the permission.
+     * Permissions for this role
      */
-    hasPermission(permission: PermissionResolvable): boolean;
+    get permissions(): Permissions;
     /**
      * Fetches this role directly from the API to ensure data is up to date.
      * @param force Whether to skip the cache check and force a direct API request. Defaults to false.
@@ -744,7 +1289,7 @@ declare class Role extends Base {
      * await role.fetch();
      * console.log(`Role updated, current name: ${role.name}`);
      */
-    fetch(force?: boolean): Promise<this>;
+    fetch(force?: boolean): Promise<Role>;
     /**
      * Edits the role with the given options. Only the fields provided in the options will be updated; all other fields will remain unchanged.
      * @param options The fields to update.
@@ -753,12 +1298,12 @@ declare class Role extends Base {
      * @throws {Error} If the API request fails (e.g., lack of permissions).
      * @example
      * // Change the role's name and color
-     * await role.edit({ name: "Senior Admin", colour: "#FFD700" });
+     * await role.edit({ name: "Senior Admin", color: "#FFD700" });
      *
      * // Remove the custom color from the role
-     * await role.edit({ colour: null });
+     * await role.edit({ color: null });
      */
-    edit(options: RoleEditOptions): Promise<this>;
+    edit(options: RoleEditOptions): Promise<Role>;
     /**
      * Deletes this Role from the server.
      * @throws {Error} If the role cannot be deleted (e.g., lack of permissions).
@@ -779,7 +1324,7 @@ declare class Role extends Base {
      *   allow: ["ManageChannel", "SendMessage"]
      * });
      */
-    setPermissions(options: RolePermissionOptions): Promise<this>;
+    setPermissions(options: RolePermissionOptions): Promise<Role>;
     /**
      * Updates the hierarchical position of this role.
      * Automatically reconstructs the role array and performs a bulk update.
@@ -791,7 +1336,66 @@ declare class Role extends Base {
      * await role.setPosition(2);
      * console.log(`Role moved to rank: ${role.rank}`);
      */
-    setPosition(newPosition: number): Promise<this>;
+    setPosition(newPosition: number): Promise<Role>;
+    /**
+     * Change the name for this role
+     * @param name The new name for the role
+     * @returns A promise that resolves to this updated Role object.
+     * @throws {Error} If API request fails.
+     * @example
+     * // Change the role's name
+     * await role.setName("New Role Name");
+     * console.log(`Role's new name: ${role.name}`);
+     */
+    setName(name: string): Promise<Role>;
+    /**
+     * Change the color for this role, it can be a HEX or CSS colours
+     * @param {[string]} color The new color for the role
+     * @returns A promise that resolves to this updated Role object.
+     * @throws {Error} If API request fails
+     * @example
+     * // Change the role's color
+     * await role.setColour("#FF0000");
+     * console.log(`Role's new color: ${role.color}`);
+     *
+     * // Use CSS color linear-graident
+     * await role.setColour("linear-gradient(90deg, #FF0000, #0000FF)");
+     * console.log(`Role's new color: ${role.color}`);
+     *
+     * // Remove the custom color from the role
+     * await role.setColour(null);
+     * console.log(`Role's color removed, current color: ${role.color}`);
+     */
+    setColor(color: string | null): Promise<Role>;
+    /**
+     * Edit the icon of this role
+     * @param icon Autumn ID for the new icon, or null to remove the custom icon
+     * @returns A promise that resolves to this updated Role object.
+     * @throws {Error} If API request fails
+     * @example
+     * // Set a new icon for the role
+     * await role.setIcon("AUTUMN_ID_FOR_ICON");
+     * console.log(`Role's new icon: ${role.icon}`);
+     *
+     * // Use AttachmentBuilder to upload a new icon file
+     * import { readFile } from "node:fs/promises";
+     * const iconFile = await readFile("./a.jpg");
+     * const attachment = new AttachmentBuilder(iconFile, "a.jpg");
+     * await role.setIcon(attachment);
+     * console.log(`Role's new icon: ${role.icon}`);
+     */
+    setIcon(icon: string | AttachmentBuilder | null): Promise<Role>;
+    /**
+     * Change the hoist status for this role
+     * @param hoist The new hoist status for the role
+     * @returns A promise that resolves to this updated Role object.
+     * @throws {Error} If API request fails
+     * @example
+     * // Enable hoisting for the role
+     * await role.setHoist(true);
+     * console.log(`Role is now hoisted: ${role.hoist}`);
+     */
+    setHoist(hoist: boolean): Promise<Role>;
     /**
      * Customizer for Node.js `console.log` and `util.inspect`.
      * Hides the cyclic client reference and raw serverId for a cleaner output.
@@ -805,8 +1409,9 @@ interface RoleCreateOptions {
 }
 interface RoleEditOptions {
     name?: string;
-    colour?: string | null;
+    color?: string | null;
     hoist?: boolean;
+    icon?: string | AttachmentBuilder | null;
 }
 interface RolePermissionOptions {
     allow?: PermissionResolvable;
@@ -884,7 +1489,7 @@ declare class RoleManager extends BaseManager<string, Role> {
     fetch(role: RoleResolvable, force?: boolean): Promise<Role>;
     /**
      * Edits an existing role in the server.
-     * @param role The RoleResolvable to edit.
+     * @param role The {@link RoleResolvable} to edit.
      * @param options The fields to update.
      * @returns A promise that resolves to the updated Role.
      * @throws {TypeError} If invalid options or RoleResolvable are provided.
@@ -1028,6 +1633,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;
@@ -1051,6 +1685,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.
@@ -1133,7 +1768,7 @@ declare class Member extends Base {
     /** Gets the Server object this member belongs to */
     get server(): Server | undefined;
     /** Calculates the member's total permissions using BigInt */
-    get permissions(): bigint;
+    get permissions(): Permissions;
     /** Get avatar URL for this member, or null if they don't have one.
      * @example
      * // Get a member's avatar URL
@@ -1168,14 +1803,32 @@ declare class Member extends Base {
      * await member.setTimeout(600000);
      */
     setTimeout(duration: number): Promise<void>;
-    /** Checks if the member has a specific permission */
-    hasPermission(permission: PermissionResolvable): boolean;
+    /**
+     * 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>;
     /**
      * Edit this member.
      * @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.
      */
@@ -1208,10 +1861,52 @@ 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)[];
-    attachments?: string[];
+    attachments?: string[] | AttachmentBuilder[];
     interactions?: any[];
     flags?: number;
     masquerade?: Masquerade;
@@ -1244,7 +1939,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);
@@ -1266,119 +1961,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;
 }
 
 /**
@@ -1412,6 +2059,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];
@@ -1431,6 +2090,7 @@ interface ClientOptions {
         users?: number;
         servers?: number;
         channels?: number;
+        emojis?: number;
     };
 }
 declare class Client extends EventEmitter {
@@ -1441,6 +2101,7 @@ declare class Client extends EventEmitter {
     servers: ServerManager;
     users: UserManager;
     sweepers: SweeperManager;
+    emojis: EmojiManager;
     user: ClientUser | null;
     constructor(options?: ClientOptions);
     /**
@@ -1459,4 +2120,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, AttachmentBuilder, type AttachmentMetadata, Base, BaseChannel, BitField, type BitFieldResolvable, type BotInformation, type CDNTag, 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 };