revbot.js 0.2.5 → 0.2.6

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { User as User$1, FieldsUser, SystemMessage, File, Masquerade, Message, Server as Server$1, FieldsServer, Role as Role$1, FieldsRole, Channel as Channel$1, Invite as Invite$1, Embed as Embed$1, SendableEmbed, Special, FieldsChannel, Member, FieldsMember, Category as Category$1, MessageSort } from 'revolt-api';
-import { File as File$1 } from 'node:buffer';
+import { Role as Role$1, User as User$1, FieldsUser, SystemMessage, File as File$1, Masquerade, Message, Server as Server$1, FieldsServer, FieldsRole, Channel as Channel$1, MessageSort, Invite as Invite$1, Embed as Embed$1, SendableEmbed, Special, FieldsChannel, Member, FieldsMember, Category as Category$1 } from 'revolt-api';
 import { Readable } from 'stream';
+import { File as File$2 } from 'node:buffer';
 import { EventEmitter } from 'node:events';
 import FormData from 'form-data';
 
@@ -203,6 +203,243 @@ declare class CDNClient {
     post<T>(url: string, data: FormData): Promise<T>;
 }
 
+type ChannelPermissionsString = keyof typeof ChannelPermissions.FLAGS;
+type UserPermissionsString = keyof typeof UserPermissions.FLAGS;
+type ServerPermissionsString = keyof typeof ServerPermissions.FLAGS;
+type ChannelPermissionsResolvable = number | ChannelPermissionsString | ChannelPermissions | ChannelPermissionsResolvable[];
+type UserPermissionsResolvable = number | UserPermissionsString | UserPermissions | UserPermissionsResolvable[];
+type ServerPermissionsResolvable = number | ServerPermissionsString | ServerPermissions | ServerPermissionsResolvable[];
+declare interface ChannelPermissions {
+    serialize(): Record<ChannelPermissionsString, boolean>;
+    any(bit: ChannelPermissionsResolvable): boolean;
+    add(...bits: ChannelPermissionsResolvable[]): this;
+    remove(...bits: ChannelPermissionsResolvable[]): this;
+    has(bit: ChannelPermissionsResolvable): boolean;
+}
+declare class ChannelPermissions extends BitField {
+    static readonly FLAGS: {
+        readonly VIEW_CHANNEL: number;
+        readonly SEND_MESSAGE: number;
+        readonly MANAGE_MESSAGE: number;
+        readonly MANAGE_CHANNEL: number;
+        readonly VOICE_CALL: number;
+        readonly INVITE_OTHERS: number;
+        readonly EMBED_LINKS: number;
+        readonly UPLOAD_FILES: number;
+    };
+    constructor(bits?: ChannelPermissionsResolvable);
+    static resolve(bit: ChannelPermissionsResolvable): number;
+}
+declare interface UserPermissions {
+    serialize(): Record<UserPermissionsString, boolean>;
+    any(bit: UserPermissionsResolvable): boolean;
+    add(...bits: UserPermissionsResolvable[]): this;
+    remove(...bits: UserPermissionsResolvable[]): this;
+    has(bit: UserPermissionsResolvable): boolean;
+}
+declare class UserPermissions extends BitField {
+    static readonly FLAGS: {
+        readonly ACCESS: number;
+        readonly VIEW_PROFILE: number;
+        readonly SEND_MESSAGES: number;
+        readonly INVITE: number;
+    };
+    constructor(bits?: UserPermissionsResolvable);
+    static resolve(bit: UserPermissionsResolvable): number;
+}
+declare interface ServerPermissions {
+    serialize(): Record<ServerPermissionsString, boolean>;
+    any(bit: ServerPermissionsResolvable): boolean;
+    add(...bits: ServerPermissionsResolvable[]): this;
+    remove(...bits: ServerPermissionsResolvable[]): this;
+    has(bit: ServerPermissionsResolvable): boolean;
+}
+declare class ServerPermissions extends BitField {
+    static readonly FLAGS: {
+        readonly VIEW_SERVER: number;
+        readonly MANAGE_ROLES: number;
+        readonly MANAGE_CHANNELS: number;
+        readonly MANAGE_SERVER: number;
+        readonly KICK_MEMBERS: number;
+        readonly BAN_MEMBERS: number;
+        readonly CHANGE_NICKNAME: number;
+        readonly MANAGE_NICKNAMES: number;
+        readonly CHANGE_AVATAR: number;
+        readonly REMOVE_AVATARS: number;
+    };
+    constructor(bits?: ServerPermissionsResolvable);
+    static resolve(bit: ServerPermissionsResolvable): number;
+}
+declare class FullPermissions extends BitField {
+    static readonly FLAGS: {
+        readonly ManageChannel: number;
+        readonly ManageServer: number;
+        readonly ManagePermissions: number;
+        readonly ManageRole: number;
+        readonly ManageCustomisation: number;
+        readonly KickMembers: number;
+        readonly BanMembers: number;
+        readonly TimeoutMembers: number;
+        readonly AssignRoles: number;
+        readonly ChangeNickname: number;
+        readonly ManageNicknames: number;
+        readonly ChangeAvatar: number;
+        readonly RemoveAvatars: number;
+        readonly ViewChannel: number;
+        readonly ReadMessageHistory: number;
+        readonly SendMessage: number;
+        readonly ManageMessages: number;
+        readonly ManageWebhooks: number;
+        readonly InviteOthers: number;
+        readonly SendEmbeds: number;
+        readonly UploadFiles: number;
+        readonly Masquerade: number;
+        readonly React: number;
+        readonly Connect: number;
+        readonly Speak: number;
+        readonly Video: number;
+        readonly MuteMembers: number;
+        readonly DeafenMembers: number;
+        readonly MoveMembers: number;
+        readonly MentionEveryone: number;
+        readonly MentionRoles: number;
+        readonly GrantAll: 4503599627370495;
+    };
+    constructor(bits?: number | string | FullPermissions | Array<number | string | FullPermissions>);
+    static resolve(bit: number | string | FullPermissions): number;
+}
+declare const DEFAULT_PERMISSION_DM: Readonly<ChannelPermissions>;
+
+/**
+ * Represents a webhook avatar attachment.
+ */
+interface WebhookAvatar {
+    /** The unique identifier of the attachment. */
+    _id: string;
+    /** The tag associated with the attachment. */
+    tag: string;
+    /** The filename of the attachment. */
+    filename: string;
+    /** Additional metadata for the attachment. */
+    metadata: any;
+    /** The MIME type of the attachment. */
+    content_type: string;
+    /** The size of the attachment in bytes. */
+    size: number;
+}
+/**
+ * Represents data for a webhook creation event.
+ */
+interface WebhookCreateData {
+    /** The unique identifier of the webhook. */
+    webhookId: string;
+    /** The ID of the channel the webhook belongs to. */
+    channelId: string;
+    /** The name of the webhook. */
+    name: string;
+    /** The ID of the user who created the webhook. */
+    creatorId: string;
+    /** The webhook's token. */
+    token: string;
+}
+/**
+ * Represents data for a webhook deletion event.
+ */
+interface WebhookDeleteData {
+    /** The unique identifier of the webhook. */
+    webhookId: string;
+}
+/**
+ * Represents data for a webhook update event.
+ */
+interface WebhookUpdateData {
+    /** The unique identifier of the webhook. */
+    webhookId: string;
+    /** The updated name of the webhook. */
+    name: string;
+    /** The updated avatar of the webhook, if any. */
+    avatar: WebhookAvatar | undefined;
+    /** Fields to remove from the webhook. */
+    remove: string[];
+}
+/**
+ * Represents the permissions that can be set for a role.
+ */
+type editablePermissions = {
+    /**
+     * Permissions to allow for the role.
+     * Each key corresponds to a permission flag in FullPermissions.
+     */
+    a?: Array<keyof (typeof FullPermissions)["FLAGS"]>;
+    /**
+     * Permissions to deny for the role.
+     * Each key corresponds to a permission flag in FullPermissions.
+     */
+    d?: Array<keyof (typeof FullPermissions)["FLAGS"]>;
+};
+/**
+ * Represents a role that can be edited in a server.
+ */
+type editableRole = {
+    /**
+     * Name of the role.
+     */
+    name?: string;
+    /**
+     * Colour of the role, or `null` if no colour is set.
+     */
+    colour?: string | null;
+    /**
+     * Whether the role is displayed separately in the member list.
+     */
+    hoist?: boolean;
+    /**
+     * Rank of the role, used for ordering.
+     */
+    rank?: number;
+    /**
+     * Permissions to set for the role.
+     * Format: { a: allow, d: deny }
+     */
+    permissions?: editablePermissions;
+    /**
+     * Fields to remove from the role.
+     * Each key corresponds to a field in the Role type.
+     */
+    remove?: Array<keyof Role$1 & {
+        [key: string]: unknown;
+    }>;
+};
+interface createWebhookResponse {
+    id: "string";
+    name: "string";
+    avatar: {
+        _id: "string";
+        tag: "string";
+        filename: "string";
+        metadata: {
+            type: "File";
+        };
+        content_type: "string";
+        size: 1;
+        deleted: null;
+        reported: null;
+        message_id: null;
+        user_id: null;
+        server_id: null;
+        object_id: null;
+    };
+    creator_id: "string";
+    channel_id: "string";
+    permissions: 0;
+    token: null;
+}
+interface editWebhookOptions {
+    name: string;
+    avatar?: Readable | string | File;
+    remove?: [];
+}
+
 /**
  * Represents the events that the client can emit.
  */
@@ -261,6 +498,12 @@ interface ClientEvents {
     [Events.ROLE_DELETE]: [Role];
     /** emitted when a role is updated */
     [Events.ROLE_UPDATE]: [Role, Role];
+    /** emitted when a webhook is created */
+    [Events.WEBHOOKS_CREATE]: [WebhookCreateData];
+    /** emitted when a webhook is deleted */
+    [Events.WEBHOOKS_DELETE]: [WebhookDeleteData];
+    /** emitted when a webhook is updated */
+    [Events.WEBHOOKS_UPDATE]: [WebhookUpdateData];
 }
 /**
  * Represents the options for configuring the client.
@@ -388,7 +631,10 @@ declare enum Events {
     SERVER_UPDATE = "serverUpdate",
     TYPING_START = "typingStart",
     TYPING_STOP = "typingStop",
-    USER_UPDATE = "userUpdate"
+    USER_UPDATE = "userUpdate",
+    WEBHOOKS_CREATE = "webhookCreate",
+    WEBHOOKS_DELETE = "webhookDelete",
+    WEBHOOKS_UPDATE = "webhookUpdate"
 }
 /**
  * Enum representing the WebSocket events used for communication.
@@ -424,7 +670,10 @@ declare enum WSEvents {
     SERVER_ROLE_UPDATE = "ServerRoleUpdate",
     SERVER_UPDATE = "ServerUpdate",
     USER_RELATIONSHIP = "UserRelationship",
-    USER_UPDATE = "UserUpdate"
+    USER_UPDATE = "UserUpdate",
+    WEBHOOKS_CREATE = "WebhooksCreate",
+    WEBHOOKS_DELETE = "WebhooksDelete",
+    WEBHOOKS_UPDATE = "WebhooksUpdate"
 }
 /**
  * Enum representing the types of channels supported by the client.
@@ -445,133 +694,26 @@ declare const apiUrl = "https://api.stoat.chat";
 /** The system user ID used for identifying system messages. */
 declare const SYSTEM_USER_ID: string;
 
-type ChannelPermissionsString = keyof typeof ChannelPermissions.FLAGS;
-type UserPermissionsString = keyof typeof UserPermissions.FLAGS;
-type ServerPermissionsString = keyof typeof ServerPermissions.FLAGS;
-type ChannelPermissionsResolvable = number | ChannelPermissionsString | ChannelPermissions | ChannelPermissionsResolvable[];
-type UserPermissionsResolvable = number | UserPermissionsString | UserPermissions | UserPermissionsResolvable[];
-type ServerPermissionsResolvable = number | ServerPermissionsString | ServerPermissions | ServerPermissionsResolvable[];
-declare interface ChannelPermissions {
-    serialize(): Record<ChannelPermissionsString, boolean>;
-    any(bit: ChannelPermissionsResolvable): boolean;
-    add(...bits: ChannelPermissionsResolvable[]): this;
-    remove(...bits: ChannelPermissionsResolvable[]): this;
-    has(bit: ChannelPermissionsResolvable): boolean;
-}
-declare class ChannelPermissions extends BitField {
-    static readonly FLAGS: {
-        readonly VIEW_CHANNEL: number;
-        readonly SEND_MESSAGE: number;
-        readonly MANAGE_MESSAGE: number;
-        readonly MANAGE_CHANNEL: number;
-        readonly VOICE_CALL: number;
-        readonly INVITE_OTHERS: number;
-        readonly EMBED_LINKS: number;
-        readonly UPLOAD_FILES: number;
-    };
-    constructor(bits?: ChannelPermissionsResolvable);
-    static resolve(bit: ChannelPermissionsResolvable): number;
-}
-declare interface UserPermissions {
-    serialize(): Record<UserPermissionsString, boolean>;
-    any(bit: UserPermissionsResolvable): boolean;
-    add(...bits: UserPermissionsResolvable[]): this;
-    remove(...bits: UserPermissionsResolvable[]): this;
-    has(bit: UserPermissionsResolvable): boolean;
+type BadgeString = keyof typeof Badges.FLAGS;
+type BadgesResolvable = number | BadgeString | Badges | BadgesResolvable[];
+declare interface Badges {
+    serialize(): Record<BadgeString, boolean>;
+    any(bit: BadgesResolvable): boolean;
+    add(...bits: BadgesResolvable[]): this;
+    remove(...bits: BadgesResolvable[]): this;
+    has(bit: BadgesResolvable): boolean;
 }
-declare class UserPermissions extends BitField {
+declare class Badges extends BitField {
     static readonly FLAGS: {
-        readonly ACCESS: number;
-        readonly VIEW_PROFILE: number;
-        readonly SEND_MESSAGES: number;
-        readonly INVITE: number;
+        readonly DEVELOPER: number;
+        readonly TRANSLATOR: number;
+        readonly SUPPORTER: number;
+        readonly RESPONSIBLE_DISCLOSURE: number;
+        readonly REVOLT_TEAM: number;
+        readonly EARLY_ADOPTER: number;
     };
-    constructor(bits?: UserPermissionsResolvable);
-    static resolve(bit: UserPermissionsResolvable): number;
-}
-declare interface ServerPermissions {
-    serialize(): Record<ServerPermissionsString, boolean>;
-    any(bit: ServerPermissionsResolvable): boolean;
-    add(...bits: ServerPermissionsResolvable[]): this;
-    remove(...bits: ServerPermissionsResolvable[]): this;
-    has(bit: ServerPermissionsResolvable): boolean;
-}
-declare class ServerPermissions extends BitField {
-    static readonly FLAGS: {
-        readonly VIEW_SERVER: number;
-        readonly MANAGE_ROLES: number;
-        readonly MANAGE_CHANNELS: number;
-        readonly MANAGE_SERVER: number;
-        readonly KICK_MEMBERS: number;
-        readonly BAN_MEMBERS: number;
-        readonly CHANGE_NICKNAME: number;
-        readonly MANAGE_NICKNAMES: number;
-        readonly CHANGE_AVATAR: number;
-        readonly REMOVE_AVATARS: number;
-    };
-    constructor(bits?: ServerPermissionsResolvable);
-    static resolve(bit: ServerPermissionsResolvable): number;
-}
-declare class FullPermissions extends BitField {
-    static readonly FLAGS: {
-        readonly ManageChannel: number;
-        readonly ManageServer: number;
-        readonly ManagePermissions: number;
-        readonly ManageRole: number;
-        readonly ManageCustomisation: number;
-        readonly KickMembers: number;
-        readonly BanMembers: number;
-        readonly TimeoutMembers: number;
-        readonly AssignRoles: number;
-        readonly ChangeNickname: number;
-        readonly ManageNicknames: number;
-        readonly ChangeAvatar: number;
-        readonly RemoveAvatars: number;
-        readonly ViewChannel: number;
-        readonly ReadMessageHistory: number;
-        readonly SendMessage: number;
-        readonly ManageMessages: number;
-        readonly ManageWebhooks: number;
-        readonly InviteOthers: number;
-        readonly SendEmbeds: number;
-        readonly UploadFiles: number;
-        readonly Masquerade: number;
-        readonly React: number;
-        readonly Connect: number;
-        readonly Speak: number;
-        readonly Video: number;
-        readonly MuteMembers: number;
-        readonly DeafenMembers: number;
-        readonly MoveMembers: number;
-        readonly MentionEveryone: number;
-        readonly MentionRoles: number;
-        readonly GrantAll: 4503599627370495;
-    };
-    constructor(bits?: number | string | FullPermissions | Array<number | string | FullPermissions>);
-    static resolve(bit: number | string | FullPermissions): number;
-}
-declare const DEFAULT_PERMISSION_DM: Readonly<ChannelPermissions>;
-
-type BadgeString = keyof typeof Badges.FLAGS;
-type BadgesResolvable = number | BadgeString | Badges | BadgesResolvable[];
-declare interface Badges {
-    serialize(): Record<BadgeString, boolean>;
-    any(bit: BadgesResolvable): boolean;
-    add(...bits: BadgesResolvable[]): this;
-    remove(...bits: BadgesResolvable[]): this;
-    has(bit: BadgesResolvable): boolean;
-}
-declare class Badges extends BitField {
-    static readonly FLAGS: {
-        readonly DEVELOPER: number;
-        readonly TRANSLATOR: number;
-        readonly SUPPORTER: number;
-        readonly RESPONSIBLE_DISCLOSURE: number;
-        readonly REVOLT_TEAM: number;
-        readonly EARLY_ADOPTER: number;
-    };
-    constructor(bits?: BadgesResolvable);
-    static resolve(bit: BadgesResolvable): number;
+    constructor(bits?: BadgesResolvable);
+    static resolve(bit: BadgesResolvable): number;
 }
 
 /**
@@ -689,7 +831,7 @@ declare class MessageStruct extends Base {
     /** An array of embeds included in the message. */
     embeds: Embed[];
     /** An array of file attachments included in the message. */
-    attachments: File[];
+    attachments: File$1[];
     /** Mentions included in the message. */
     mentions: Mentions;
     /** The timestamp of when the message was last edited, or `null` if not edited. */
@@ -863,14 +1005,14 @@ declare class Attachment extends Base {
     /** The size of the attachment in bytes. */
     size: number;
     /** Metadata associated with the attachment (e.g., dimensions for images). */
-    metadata: File["metadata"];
+    metadata: File$1["metadata"];
     /**
      * Creates a new Attachment instance.
      *
      * @param {client} client - The client instance.
      * @param {File} data - The raw data for the attachment from the API.
      */
-    constructor(client: client, data: File);
+    constructor(client: client, data: File$1);
     /**
      * Updates the attachment instance with new data from the API.
      *
@@ -878,7 +1020,7 @@ declare class Attachment extends Base {
      * @returns {this} The updated attachment instance.
      * @protected
      */
-    protected _patch(data: File): this;
+    protected _patch(data: File$1): this;
 }
 
 /**
@@ -985,55 +1127,6 @@ declare class Server extends Base {
     toString(): string;
 }
 
-/**
- * Represents the permissions that can be set for a role.
- */
-type editablePermissions = {
-    /**
-     * Permissions to allow for the role.
-     * Each key corresponds to a permission flag in FullPermissions.
-     */
-    a?: Array<keyof (typeof FullPermissions)["FLAGS"]>;
-    /**
-     * Permissions to deny for the role.
-     * Each key corresponds to a permission flag in FullPermissions.
-     */
-    d?: Array<keyof (typeof FullPermissions)["FLAGS"]>;
-};
-/**
- * Represents a role that can be edited in a server.
- */
-type editableRole = {
-    /**
-     * Name of the role.
-     */
-    name?: string;
-    /**
-     * Colour of the role, or `null` if no colour is set.
-     */
-    colour?: string | null;
-    /**
-     * Whether the role is displayed separately in the member list.
-     */
-    hoist?: boolean;
-    /**
-     * Rank of the role, used for ordering.
-     */
-    rank?: number;
-    /**
-     * Permissions to set for the role.
-     * Format: { a: allow, d: deny }
-     */
-    permissions?: editablePermissions;
-    /**
-     * Fields to remove from the role.
-     * Each key corresponds to a field in the Role type.
-     */
-    remove?: Array<keyof Role$1 & {
-        [key: string]: unknown;
-    }>;
-};
-
 /**
  * Represents a role in a server.
  *
@@ -1110,6 +1203,172 @@ declare class Role extends Base {
     toString(): string;
 }
 
+/**
+ * Represents a channel in the API.
+ * @private
+ */
+type APIServerChannel = Extract<Channel$1, {
+    channel_type: "TextChannel" | "VoiceChannel";
+}>;
+
+type ServerChannelResolvable = ServerChannel | APIServerChannel | string;
+interface CreateChannelOptions {
+    name: string;
+    type?: "Text" | "Voice";
+    description?: string;
+    nsfw?: boolean;
+    voice: {
+        max_users?: number;
+    };
+}
+declare class ServerChannelManager extends BaseManager<ServerChannel> {
+    protected readonly server: Server;
+    /** @private */
+    holds: typeof ServerChannel;
+    constructor(server: Server);
+    /** @private */
+    _add(data: APIServerChannel): ServerChannel;
+    /**
+     * Creates a new channel in the server.
+     * @param options - Options for creating the channel.
+     * @param options.name - The name of the channel to create.
+     * @param [options.type="Text"] - The type of the channel to create. Can be "Text" or "Voice". Defaults to "Text".
+     * @param [options.description] - The description of the channel to create. Only used for voice channels.
+     * @returns A promise that resolves to the created channel.
+     */
+    create({ name, type, description, }: CreateChannelOptions): Promise<ServerChannel>;
+    /**
+     * fetch a channel from the server
+     * @param channel The channel to fetch. Can be a string, a channel object, or an API channel object.
+     * @param force Whether to force fetch the channel from the API. Defaults to true.
+     * If set to false, the method will return the channel from the cache if it exists.
+     * @returns A promise that resolves to the fetched channel
+     */
+    fetch(channel: ServerChannelResolvable, { force }?: {
+        force?: boolean | undefined;
+    }): Promise<ServerChannel>;
+}
+
+type MessageResolvable = MessageStruct | Message | string;
+interface MessageReply {
+    id: string;
+    mention: boolean;
+}
+interface MessageOptions {
+    content?: string;
+    replies?: MessageReply[];
+    attachments?: Readable[] | string[] | File$2[];
+    embeds?: MessageEmbed[];
+    masquerade?: Masquerade;
+}
+interface MessageEditOptions {
+    content?: string;
+    attachments?: string[];
+    embeds?: MessageEmbed[];
+}
+interface MessageSearchOptions {
+    query: string;
+    limit?: number;
+    before?: string;
+    after?: string;
+    sort?: MessageSort;
+}
+interface MessageQueryOptions {
+    limit?: number;
+    before?: string;
+    after?: string;
+    sort?: MessageSort;
+    nearby?: string;
+}
+declare class MessageManager extends BaseManager<MessageStruct, Message> {
+    protected readonly channel: Channel;
+    /** @private */
+    holds: typeof MessageStruct;
+    constructor(channel: Channel, maxSize?: number);
+    /**
+     *
+     * @param content The content to send. Can be a string or an object with the following properties:
+     * - content: The content of the message
+     * - replies: An array of message IDs to reply to
+     * - attachments: An array of attachment URLs, Files, or ReadStreams
+     * - embeds: An array of MessageEmbed objects
+     * @returns Promise that resolves to the sent message
+     */
+    send(content: MessageOptions | string): Promise<MessageStruct>;
+    /**
+     * acknowledge a message to mark it as read (not important for bots)
+     * @param message The message to acknowledge
+     * @returns Promise that resolves when the message is acknowledged
+     */
+    ack(message: MessageResolvable): Promise<void>;
+    /**
+     * bulk delete messages from the channel
+     * @param messages The messages to delete. Can be an array of message IDs or a Map of message IDs to Message objects.
+     * @returns Promise that resolves when the messages are deleted
+     */
+    bulkDelete(messages: MessageResolvable[] | number | Map<string, MessageStruct>): Promise<void>;
+    /**
+     * delete a message from the channel
+     * @param message The message to delete. Can be a Message object or a message ID.
+     * @returns Promise that resolves when the message is deleted
+     */
+    delete(message: MessageResolvable): Promise<void>;
+    /**
+     * edit a message in the channel
+     * @param message The message to edit. Can be a Message object or a message ID.
+     * @param options The options to edit the message with. Can be a string or an object with the following properties:
+     * - content: The new content of the message
+     * - attachments: An array of attachment URLs
+     * - embeds: An array of MessageEmbed objects
+     * @returns Promise that resolves when the message is edited
+     */
+    edit(message: MessageResolvable, options: MessageEditOptions | string): Promise<void>;
+    /**
+     * search for messages in the channel
+     * @param query The query to search for. Can be a string or an object with the following properties:
+     * - query: The query to search for
+     * - limit: The maximum number of messages to return
+     * - before: The message ID to start searching from (exclusive)
+     * - after: The message ID to stop searching at (exclusive)
+     * - sort: The sort order of the results (asc or desc)
+     * @returns Promise that resolves to a Map of message IDs to Message objects
+     */
+    search(query: MessageSearchOptions | string): Promise<Map<string, MessageStruct>>;
+    /**
+     * fetch a message from the channel
+     * @param message The message to fetch. Can be a Message object, a message ID, or an object with the following properties:
+     * - limit: The maximum number of messages to return
+     * - before: The message ID to start fetching from (exclusive)
+     * - after: The message ID to stop fetching at (exclusive)
+     * @returns Promise that resolves to a Message object or a Map of message IDs to Message objects
+     */
+    fetch(message: MessageResolvable): Promise<MessageStruct>;
+    fetch(query?: MessageQueryOptions): Promise<Map<string, MessageStruct>>;
+    fetch(limit: number): Promise<Map<string, MessageStruct>>;
+    /**
+     * add a reaction to a message
+     * @param message The message to react to. Can be a Message object or a message ID.
+     * @param emoji emoji to react with. Can be a string or an Emoji object.
+     * @returns Promise that resolves when the reaction is added
+     */
+    addReaction(message: MessageResolvable | string, emoji: string | Emoji): Promise<void>;
+    /**
+     *
+     * @param message The message to unreact. Can be a Message object or a message ID.
+     * @param emoji the emoji to unreact with. Can be a string or an Emoji object.
+     * @param user_id The user ID to remove the reaction for. If not provided, removes the reaction for the current user.
+     * @param remove_all Whether to remove all of the specified reaction for the message. Defaults to false.
+     * @returns Promise that resolves when the reaction is removed
+     */
+    removeReaction(message: MessageResolvable | string, emoji: string | Emoji, user_id?: string, remove_all?: boolean): Promise<void>;
+    /**
+     * remove all reactions from a message
+     * @param message The message to remove reactions from. Can be a Message object or a message ID.
+     * @returns Promise that resolves when the reactions are removed
+     */
+    removeAllReactions(message: MessageResolvable | string): Promise<void>;
+}
+
 /**
  * Represents a generic communication channel in the client.
  * This abstract class provides a base structure and common functionality
@@ -1160,38 +1419,270 @@ declare abstract class Channel extends Base {
      *
      * @returns {boolean} True if the channel is a text-based channel, otherwise false.
      */
-    isText(): this is TextChannel | GroupChannel | DMChannel;
+    isText(): this is TextChannel | GroupChannel | DMChannel;
+    /**
+     * Checks if the channel is a voice channel.
+     *
+     * @returns {boolean} True if the channel is a voice channel, otherwise false.
+     */
+    isVoice(): this is VoiceChannel;
+    /**
+     * Checks if the channel is a group channel.
+     *
+     * @returns {boolean} True if the channel is a group channel, otherwise false.
+     */
+    isGroup(): this is GroupChannel;
+    /**
+     * Checks if the channel is part of a server.
+     *
+     * @returns {boolean} True if the channel is a server channel, otherwise false.
+     */
+    inServer(): this is ServerChannel;
+    /**
+     * Converts the channel to a string representation.
+     *
+     * @returns {string} A string representation of the channel in the format `<#channelId>`.
+     */
+    toString(): string;
+    /**
+     * Fetches the latest data for the channel from the client's channel collection.
+     *
+     * @param {boolean} [force=true] - Whether to force a fetch even if the channel is cached.
+     * @returns {Promise<Channel>} A promise that resolves with the updated channel instance.
+     */
+    fetch(force?: boolean): Promise<Channel>;
+    edit(data: Partial<CreateChannelOptions>): Promise<{
+        channel_type: string;
+        _id: string;
+        user: string;
+    }>;
+    /**
+     * Sets role permissions for this channel.
+     *
+     * @param roleId - The ID of the role to set permissions for.
+     * @param allow - Array of permissions to allow for the role.
+     * @returns A promise that resolves when the permissions have been updated.
+     *
+     * @throws {TypeError} If the channel ID is invalid.
+     *
+     * @example
+     * ```typescript
+     * // Allow specific permissions
+     * await channel.setRolePermissions(roleId, ["ViewChannel", "SendMessage"]);
+     * ```
+     */
+    setRolePermissions(roleId: string, allow: editablePermissions["a"]): Promise<void>;
+    /**
+     * Sets role permissions for this channel.
+     *
+     * @param roleId - The ID of the role to set permissions for.
+     * @param allow - Array of permissions to allow for the role.
+     * @param deny - Array of permissions to deny for the role.
+     * @returns A promise that resolves when the permissions have been updated.
+     *
+     * @throws {TypeError} If the channel ID is invalid.
+     *
+     * @example
+     * ```typescript
+     * // Set both allow and deny permissions
+     * await channel.setRolePermissions(roleId, ["ViewChannel"], ["ManageMessages"]);
+     * ```
+     */
+    setRolePermissions(roleId: string, allow: editablePermissions["a"], deny: editablePermissions["d"]): Promise<void>;
+    /**
+     * Sets role permissions for this channel.
+     *
+     * @param roleId - The ID of the role to set permissions for.
+     * @param options - Object containing allow and/or deny permissions.
+     * @returns A promise that resolves when the permissions have been updated.
+     *
+     * @throws {TypeError} If the channel ID is invalid or if both allow and deny are undefined.
+     *
+     * @example
+     * ```typescript
+     * // Allow specific permissions only
+     * await channel.setRolePermissions(roleId, { allow: ["ViewChannel", "SendMessage"] });
+     *
+     * // Deny specific permissions only
+     * await channel.setRolePermissions(roleId, { deny: ["ManageMessages"] });
+     *
+     * // Set both allow and deny permissions
+     * await channel.setRolePermissions(roleId, {
+     *   allow: ["ViewChannel"],
+     *   deny: ["ManageMessages"]
+     * });
+     * ```
+     */
+    setRolePermissions(roleId: string, options: {
+        allow?: editablePermissions["a"];
+        deny?: editablePermissions["d"];
+    }): Promise<void>;
+    /**
+     * Sets default permissions for this channel.
+     *
+     * @param allow - Array of permissions to allow by default.
+     * @returns A promise that resolves when the permissions have been updated.
+     *
+     * @throws {TypeError} If the channel ID is invalid.
+     *
+     * @example
+     * ```typescript
+     * // Allow specific permissions
+     * await channel.setDefaultPermissions(["ViewChannel", "SendMessage"]);
+     * ```
+     */
+    setDefaultPermissions(allow: editablePermissions["a"]): Promise<void>;
+    /**
+     * Sets default permissions for this channel.
+     *
+     * @param options - Object containing allow and/or deny permissions.
+     * @returns A promise that resolves when the permissions have been updated.
+     *
+     * @throws {TypeError} If the channel ID is invalid or if both allow and deny are undefined.
+     *
+     * @example
+     * ```typescript
+     * // Allow specific permissions only
+     * await channel.setDefaultPermissions({ allow: ["ViewChannel", "SendMessage"] });
+     *
+     * // Deny specific permissions only
+     * await channel.setDefaultPermissions({ deny: ["ManageMessages"] });
+     *
+     * // Set both allow and deny permissions
+     * await channel.setDefaultPermissions({
+     *   allow: ["ViewChannel"],
+     *   deny: ["ManageMessages"]
+     * });
+     * ```
+     */
+    setDefaultPermissions(options: {
+        allow?: editablePermissions["a"];
+        deny?: editablePermissions["d"];
+    }): Promise<void>;
+    /**
+     * Sets default permissions for this channel (legacy format).
+     *
+     * @param permissions - Object containing allow and deny permissions.
+     * @returns A promise that resolves when the permissions have been updated.
+     *
+     * @throws {TypeError} If the channel ID is invalid.
+     *
+     * @example
+     * ```typescript
+     * // Legacy format
+     * await channel.setDefaultPermissions({
+     *   a: ["ViewChannel"],
+     *   d: ["ManageMessages"]
+     * });
+     * ```
+     */
+    setDefaultPermissions(permissions: editablePermissions): Promise<void>;
+    /**
+     * Creates a new webhook in this channel.
+     *
+     * @param name - The name of the webhook
+     * @param avatar - Optional avatar for the webhook. Can be a URL string, Readable stream, or File object
+     * @returns Promise resolving to the created webhook response
+     *
+     * @example
+     * ```typescript
+     * const webhook = await channel.createWebhook("My Webhook", "https://example.com/avatar.png");
+     * ```
+     */
+    createWebhook(name: string, avatar?: Readable | string | File): Promise<createWebhookResponse>;
+    /**
+     * Retrieves all webhooks for this channel.
+     *
+     * @returns Promise resolving to an array of webhook responses
+     *
+     * @example
+     * ```typescript
+     * const webhooks = await channel.getWebhooks();
+     * console.log(`Found ${webhooks.length} webhooks`);
+     * ```
+     */
+    getWebhooks(): Promise<createWebhookResponse[]>;
     /**
-     * Checks if the channel is a voice channel.
+     * Retrieves a specific webhook by ID and token.
      *
-     * @returns {boolean} True if the channel is a voice channel, otherwise false.
+     * @param webhookId - The ID of the webhook to retrieve
+     * @param token - The token of the webhook
+     * @returns Promise resolving to the webhook response
+     *
+     * @example
+     * ```typescript
+     * const webhook = await channel.getWebhook("webhookId", "webhookToken");
+     * console.log(`Webhook name: ${webhook.name}`);
+     * ```
      */
-    isVoice(): this is VoiceChannel;
+    getWebhook(webhookId: string, token: string): Promise<createWebhookResponse>;
     /**
-     * Checks if the channel is a group channel.
+     * Sends a message through a webhook in this channel.
      *
-     * @returns {boolean} True if the channel is a group channel, otherwise false.
+     * @param webhookId - The ID of the webhook to send the message through
+     * @param token - The token of the webhook
+     * @param content - The message content. Can be a string or MessageOptions object with attachments and embeds
+     * @returns Promise resolving to the sent message
+     *
+     * @example
+     * ```typescript
+     * // Send a simple text message
+     * await channel.sendWebhookMessage("webhookId", "token", "Hello, world!");
+     *
+     * // Send a message with embeds and attachments
+     * await channel.sendWebhookMessage("webhookId", "token", {
+     *   content: "Check out this image!",
+     *   attachments: ["https://example.com/image.png"],
+     *   embeds: [myEmbed]
+     * });
+     * ```
      */
-    isGroup(): this is GroupChannel;
+    sendWebhookMessage(webhookId: string, token: string, content: MessageOptions | string): Promise<Message>;
     /**
-     * Checks if the channel is part of a server.
+     * Deletes a webhook.
      *
-     * @returns {boolean} True if the channel is a server channel, otherwise false.
+     * @param webhookId - The ID of the webhook to delete
+     * @param token - The token of the webhook
+     * @returns Promise that resolves when the webhook is deleted
+     *
+     * @example
+     * ```typescript
+     * await channel.deleteWebhook("webhookId", "webhookToken");
+     * console.log("Webhook deleted successfully");
+     * ```
      */
-    inServer(): this is ServerChannel;
+    deleteWebhook(webhookId: string, token: string): Promise<void>;
     /**
-     * Converts the channel to a string representation.
+     * Edits a webhook's properties.
      *
-     * @returns {string} A string representation of the channel in the format `<#channelId>`.
+     * @param webhookId - The ID of the webhook to edit
+     * @param token - The token of the webhook
+     * @param options - The options to edit on the webhook
+     * @returns Promise resolving to the updated webhook response
+     *
+     * @example
+     * ```typescript
+     * const updatedWebhook = await channel.editWebhook("webhookId", "token", {
+     *   name: "New Webhook Name",
+     *   avatar: "https://example.com/new-avatar.png"
+     * });
+     * ```
      */
-    toString(): string;
+    editWebhook(webhookId: string, token: string, options: editWebhookOptions): Promise<createWebhookResponse>;
     /**
-     * Fetches the latest data for the channel from the client's channel collection.
+     * Retrieves partial information about a webhook using only its ID.
+     * This method provides limited webhook information without requiring a token.
      *
-     * @param {boolean} [force=true] - Whether to force a fetch even if the channel is cached.
-     * @returns {Promise<Channel>} A promise that resolves with the updated channel instance.
+     * @param webhookId - The ID of the webhook to retrieve partial information for
+     * @returns Promise resolving to the webhook response with partial information
+     *
+     * @example
+     * ```typescript
+     * const partialWebhook = await channel.getPartialWebhook("webhookId");
+     * console.log(`Webhook name: ${partialWebhook.name}`);
+     * ```
      */
-    fetch(force?: boolean): Promise<Channel>;
+    getPartialWebhook(webhookId: string): Promise<createWebhookResponse>;
 }
 
 /**
@@ -1584,7 +2075,7 @@ declare class MessageEmbed {
      * @param {Readable | string | File} media - The media URL, File or Stream to set.
      * @returns {this} The updated `MessageEmbed` instance.
      */
-    setMedia(media: Readable | string | File$1): this;
+    setMedia(media: Readable | string | File$2): this;
     /**
      *
      * @param client The client instance used to send the embed.
@@ -1670,14 +2161,6 @@ declare class NotesChannel extends Channel implements TextBasedChannel {
     get user(): User;
 }
 
-/**
- * Represents a channel in the API.
- * @private
- */
-type APIServerChannel = Extract<Channel$1, {
-    channel_type: "TextChannel" | "VoiceChannel";
-}>;
-
 interface Overwrite {
     allow: FullPermissions;
     deny: FullPermissions;
@@ -2123,6 +2606,128 @@ declare class UserManager extends BaseManager<User, User$1> {
     resolveId(resolvable: UserResolvable): string | null;
 }
 
+/**
+ * Manages webhooks for the client.
+ * Provides methods for creating, managing, and sending messages through webhooks.
+ */
+declare class WebhookManager {
+    protected readonly client: client;
+    /**
+     * Creates a new WebhookManager instance.
+     *
+     * @param client - The client instance this manager belongs to
+     */
+    constructor(client: client);
+    /**
+     * Creates a new webhook in the specified channel.
+     *
+     * @param channelId - The ID of the channel where the webhook will be created
+     * @param name - The name of the webhook
+     * @param avatar - Optional avatar for the webhook. Can be a URL string, Readable stream, or File object
+     * @returns Promise resolving to the created webhook response
+     *
+     * @example
+     * ```typescript
+     * const webhook = await client.webhooks.create("channelId", "My Webhook", "https://example.com/avatar.png");
+     * ```
+     */
+    create(channelId: string, name: string, avatar?: Readable | string | File): Promise<createWebhookResponse>;
+    /**
+     * Retrieves all webhooks for the specified channel.
+     *
+     * @param channelId - The ID of the channel to get webhooks from
+     * @returns Promise resolving to an array of webhook responses
+     *
+     * @example
+     * ```typescript
+     * const webhooks = await client.webhooks.getAll("channelId");
+     * console.log(`Found ${webhooks.length} webhooks`);
+     * ```
+     */
+    getAll(channelId: string): Promise<createWebhookResponse[]>;
+    /**
+     * Retrieves a specific webhook by ID and token.
+     *
+     * @param webhookId - The ID of the webhook to retrieve
+     * @param token - The token of the webhook
+     * @returns Promise resolving to the webhook response
+     *
+     * @example
+     * ```typescript
+     * const webhook = await client.webhooks.get("webhookId", "webhookToken");
+     * console.log(`Webhook name: ${webhook.name}`);
+     * ```
+     */
+    get(webhookId: string, token: string): Promise<createWebhookResponse>;
+    /**
+     * Sends a message through a webhook.
+     *
+     * @param webhookId - The ID of the webhook to send the message through
+     * @param token - The token of the webhook
+     * @param content - The message content. Can be a string or MessageOptions object with attachments and embeds
+     * @returns Promise resolving to the sent message
+     *
+     * @example
+     * ```typescript
+     * // Send a simple text message
+     * await client.webhooks.send("webhookId", "token", "Hello, world!");
+     *
+     * // Send a message with embeds and attachments
+     * await client.webhooks.send("webhookId", "token", {
+     *   content: "Check out this image!",
+     *   attachments: ["https://example.com/image.png"],
+     *   embeds: [myEmbed]
+     * });
+     * ```
+     */
+    send(webhookId: string, token: string, content: MessageOptions | string): Promise<Message>;
+    /**
+     * Deletes a webhook.
+     *
+     * @param webhookId - The ID of the webhook to delete
+     * @param token - The token of the webhook
+     * @returns Promise that resolves when the webhook is deleted
+     *
+     * @example
+     * ```typescript
+     * await client.webhooks.delete("webhookId", "webhookToken");
+     * console.log("Webhook deleted successfully");
+     * ```
+     */
+    delete(webhookId: string, token: string): Promise<void>;
+    /**
+     * Edits a webhook's properties.
+     *
+     * @param webhookId - The ID of the webhook to edit
+     * @param token - The token of the webhook
+     * @param options - The options to edit on the webhook
+     * @returns Promise resolving to the updated webhook response
+     *
+     * @example
+     * ```typescript
+     * const updatedWebhook = await client.webhooks.edit("webhookId", "token", {
+     *   name: "New Webhook Name",
+     *   avatar: "https://example.com/new-avatar.png"
+     * });
+     * ```
+     */
+    edit(webhookId: string, token: string, options: editWebhookOptions): Promise<createWebhookResponse>;
+    /**
+     * Retrieves partial information about a webhook using only its ID.
+     * This method provides limited webhook information without requiring a token.
+     *
+     * @param webhookId - The ID of the webhook to retrieve partial information for
+     * @returns Promise resolving to the webhook response with partial information
+     *
+     * @example
+     * ```typescript
+     * const partialWebhook = await client.webhooks.getPartial("webhookId");
+     * console.log(`Webhook name: ${partialWebhook.name}`);
+     * ```
+     */
+    getPartial(webhookId: string): Promise<createWebhookResponse>;
+}
+
 /**
  * Represents the client user, which is the authenticated user or bot.
  *
@@ -2338,6 +2943,8 @@ declare class client extends BaseClient {
     readonly users: UserManager;
     /** Manages the events in the client. */
     readonly events: EventManager;
+    /** Manages the webhooks in the client. */
+    readonly webhooks: WebhookManager;
     /** The authenticated user, or `null` if not logged in. */
     user: ClientUser | null;
     /** The timestamp when the client became ready, or `null` if not ready. */
@@ -2500,126 +3107,6 @@ declare class ServerManager extends BaseManager<Server, Server$1> {
     }): Promise<Server>;
 }
 
-type MessageResolvable = MessageStruct | Message | string;
-interface MessageReply {
-    id: string;
-    mention: boolean;
-}
-interface MessageOptions {
-    content?: string;
-    replies?: MessageReply[];
-    attachments?: Readable[] | string[] | File$1[];
-    embeds?: MessageEmbed[];
-    masquerade?: Masquerade;
-}
-interface MessageEditOptions {
-    content?: string;
-    attachments?: string[];
-    embeds?: MessageEmbed[];
-}
-interface MessageSearchOptions {
-    query: string;
-    limit?: number;
-    before?: string;
-    after?: string;
-    sort?: MessageSort;
-}
-interface MessageQueryOptions {
-    limit?: number;
-    before?: string;
-    after?: string;
-    sort?: MessageSort;
-    nearby?: string;
-}
-declare class MessageManager extends BaseManager<MessageStruct, Message> {
-    protected readonly channel: Channel;
-    /** @private */
-    holds: typeof MessageStruct;
-    constructor(channel: Channel, maxSize?: number);
-    /**
-     *
-     * @param content The content to send. Can be a string or an object with the following properties:
-     * - content: The content of the message
-     * - replies: An array of message IDs to reply to
-     * - attachments: An array of attachment URLs, Files, or ReadStreams
-     * - embeds: An array of MessageEmbed objects
-     * @returns Promise that resolves to the sent message
-     */
-    send(content: MessageOptions | string): Promise<MessageStruct>;
-    /**
-     * acknowledge a message to mark it as read (not important for bots)
-     * @param message The message to acknowledge
-     * @returns Promise that resolves when the message is acknowledged
-     */
-    ack(message: MessageResolvable): Promise<void>;
-    /**
-     * bulk delete messages from the channel
-     * @param messages The messages to delete. Can be an array of message IDs or a Map of message IDs to Message objects.
-     * @returns Promise that resolves when the messages are deleted
-     */
-    bulkDelete(messages: MessageResolvable[] | number | Map<string, MessageStruct>): Promise<void>;
-    /**
-     * delete a message from the channel
-     * @param message The message to delete. Can be a Message object or a message ID.
-     * @returns Promise that resolves when the message is deleted
-     */
-    delete(message: MessageResolvable): Promise<void>;
-    /**
-     * edit a message in the channel
-     * @param message The message to edit. Can be a Message object or a message ID.
-     * @param options The options to edit the message with. Can be a string or an object with the following properties:
-     * - content: The new content of the message
-     * - attachments: An array of attachment URLs
-     * - embeds: An array of MessageEmbed objects
-     * @returns Promise that resolves when the message is edited
-     */
-    edit(message: MessageResolvable, options: MessageEditOptions | string): Promise<void>;
-    /**
-     * search for messages in the channel
-     * @param query The query to search for. Can be a string or an object with the following properties:
-     * - query: The query to search for
-     * - limit: The maximum number of messages to return
-     * - before: The message ID to start searching from (exclusive)
-     * - after: The message ID to stop searching at (exclusive)
-     * - sort: The sort order of the results (asc or desc)
-     * @returns Promise that resolves to a Map of message IDs to Message objects
-     */
-    search(query: MessageSearchOptions | string): Promise<Map<string, MessageStruct>>;
-    /**
-     * fetch a message from the channel
-     * @param message The message to fetch. Can be a Message object, a message ID, or an object with the following properties:
-     * - limit: The maximum number of messages to return
-     * - before: The message ID to start fetching from (exclusive)
-     * - after: The message ID to stop fetching at (exclusive)
-     * @returns Promise that resolves to a Message object or a Map of message IDs to Message objects
-     */
-    fetch(message: MessageResolvable): Promise<MessageStruct>;
-    fetch(query?: MessageQueryOptions): Promise<Map<string, MessageStruct>>;
-    fetch(limit: number): Promise<Map<string, MessageStruct>>;
-    /**
-     * add a reaction to a message
-     * @param message The message to react to. Can be a Message object or a message ID.
-     * @param emoji emoji to react with. Can be a string or an Emoji object.
-     * @returns Promise that resolves when the reaction is added
-     */
-    addReaction(message: MessageResolvable | string, emoji: string | Emoji): Promise<void>;
-    /**
-     *
-     * @param message The message to unreact. Can be a Message object or a message ID.
-     * @param emoji the emoji to unreact with. Can be a string or an Emoji object.
-     * @param user_id The user ID to remove the reaction for. If not provided, removes the reaction for the current user.
-     * @param remove_all Whether to remove all of the specified reaction for the message. Defaults to false.
-     * @returns Promise that resolves when the reaction is removed
-     */
-    removeReaction(message: MessageResolvable | string, emoji: string | Emoji, user_id?: string, remove_all?: boolean): Promise<void>;
-    /**
-     * remove all reactions from a message
-     * @param message The message to remove reactions from. Can be a Message object or a message ID.
-     * @returns Promise that resolves when the reactions are removed
-     */
-    removeAllReactions(message: MessageResolvable | string): Promise<void>;
-}
-
 type RoleResolvable = Role | string;
 declare class RoleManager extends BaseManager<Role, Role$1 & {
     id: string;
@@ -2660,40 +3147,6 @@ declare class RoleManager extends BaseManager<Role, Role$1 & {
     edit(role: RoleResolvable, data: editableRole): Promise<Role>;
 }
 
-type ServerChannelResolvable = ServerChannel | APIServerChannel | string;
-interface CreateChannelOptions {
-    name: string;
-    type?: "Text" | "Voice";
-    description?: string;
-}
-declare class ServerChannelManager extends BaseManager<ServerChannel> {
-    protected readonly server: Server;
-    /** @private */
-    holds: typeof ServerChannel;
-    constructor(server: Server);
-    /** @private */
-    _add(data: APIServerChannel): ServerChannel;
-    /**
-     * Creates a new channel in the server.
-     * @param options - Options for creating the channel.
-     * @param options.name - The name of the channel to create.
-     * @param [options.type="Text"] - The type of the channel to create. Can be "Text" or "Voice". Defaults to "Text".
-     * @param [options.description] - The description of the channel to create. Only used for voice channels.
-     * @returns A promise that resolves to the created channel.
-     */
-    create({ name, type, description, }: CreateChannelOptions): Promise<ServerChannel>;
-    /**
-     * fetch a channel from the server
-     * @param channel The channel to fetch. Can be a string, a channel object, or an API channel object.
-     * @param force Whether to force fetch the channel from the API. Defaults to true.
-     * If set to false, the method will return the channel from the cache if it exists.
-     * @returns A promise that resolves to the fetched channel
-     */
-    fetch(channel: ServerChannelResolvable, { force }?: {
-        force?: boolean | undefined;
-    }): Promise<ServerChannel>;
-}
-
 type ServerMemberResolvable = ServerMember | User | Member | string;
 interface EditServerMemberOptions {
     nickname?: string;