seyfert 1.0.0 → 1.1.0

package/lib/common/shorters/messages.js

@@ -3,113 +3,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageShorter = void 0;
 const builders_1 = require("../../builders");
 const structures_1 = require("../../structures");
-const functions_1 = require("../../structures/extra/functions");
 const base_1 = require("./base");
 class MessageShorter extends base_1.BaseShorter {
-    get messages() {
-        return {
-            write: async (channelId, { files, ...body }) => {
-                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
-                const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
-                return this.client.proxy
-                    .channels(channelId)
-                    .messages.post({
-                    body: transformedBody,
-                    files: parsedFiles,
-                })
-                    .then(message => {
-                    return new structures_1.Message(this.client, message);
-                });
-            },
-            edit: async (messageId, channelId, { files, ...body }) => {
-                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
-                return this.client.proxy
-                    .channels(channelId)
-                    .messages(messageId)
-                    .patch({
-                    body: structures_1.MessagesMethods.transformMessageBody(body),
-                    files: parsedFiles,
-                })
-                    .then(message => {
-                    return new structures_1.Message(this.client, message);
-                });
-            },
-            crosspost: (messageId, channelId, reason) => {
-                return this.client.proxy
-                    .channels(channelId)
-                    .messages(messageId)
-                    .crosspost.post({ reason })
-                    .then(m => new structures_1.Message(this.client, m));
-            },
-            delete: (messageId, channelId, reason) => {
-                return this.client.proxy
-                    .channels(channelId)
-                    .messages(messageId)
-                    .delete({ reason })
-                    .then(() => {
-                    return this.client.components.onMessageDelete(messageId);
-                });
-            },
-            fetch: async (messageId, channelId) => {
-                return this.client.proxy
-                    .channels(channelId)
-                    .messages(messageId)
-                    .get()
-                    .then(x => new structures_1.Message(this.client, x));
-            },
-            purge: (messages, channelId, reason) => {
-                return this.client.proxy.channels(channelId).messages['bulk-delete'].post({ body: { messages }, reason });
-            },
-            reactions: this.reactions,
-        };
+    async write(channelId, { files, ...body }) {
+        const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
+        return this.client.proxy
+            .channels(channelId)
+            .messages.post({
+            body: transformedBody,
+            files: parsedFiles,
+        })
+            .then(message => {
+            return new structures_1.Message(this.client, message);
+        });
     }
-    get reactions() {
-        return {
-            add: async (messageId, channelId, emoji) => {
-                const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
-                if (!rawEmoji) {
-                    throw new Error('Emoji no resolvable');
-                }
-                return this.client.proxy
-                    .channels(channelId)
-                    .messages(messageId)
-                    .reactions((0, functions_1.encodeEmoji)(rawEmoji))('@me')
-                    .put({});
-            },
-            delete: async (messageId, channelId, emoji, userId = '@me') => {
-                const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
-                if (!rawEmoji) {
-                    throw new Error('Emoji no resolvable');
-                }
-                return this.client.proxy
-                    .channels(channelId)
-                    .messages(messageId)
-                    .reactions((0, functions_1.encodeEmoji)(rawEmoji))(userId)
-                    .delete();
-            },
-            fetch: async (messageId, channelId, emoji, query) => {
-                const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
-                if (!rawEmoji) {
-                    throw new Error('Emoji no resolvable');
-                }
-                return this.client.proxy
-                    .channels(channelId)
-                    .messages(messageId)
-                    .reactions((0, functions_1.encodeEmoji)(rawEmoji))
-                    .get({ query })
-                    .then(u => u.map(user => new structures_1.User(this.client, user)));
-            },
-            purge: async (messageId, channelId, emoji) => {
-                if (!emoji) {
-                    return this.client.proxy.channels(channelId).messages(messageId).reactions.delete();
-                }
-                const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
-                if (!rawEmoji) {
-                    throw new Error('Emoji no resolvable');
-                }
-                return this.client.proxy.channels(channelId).messages(messageId).reactions((0, functions_1.encodeEmoji)(rawEmoji)).delete();
-            },
-        };
+    async edit(messageId, channelId, { files, ...body }) {
+        const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        return this.client.proxy
+            .channels(channelId)
+            .messages(messageId)
+            .patch({
+            body: structures_1.MessagesMethods.transformMessageBody(body),
+            files: parsedFiles,
+        })
+            .then(message => {
+            return new structures_1.Message(this.client, message);
+        });
+    }
+    crosspost(messageId, channelId, reason) {
+        return this.client.proxy
+            .channels(channelId)
+            .messages(messageId)
+            .crosspost.post({ reason })
+            .then(m => new structures_1.Message(this.client, m));
+    }
+    delete(messageId, channelId, reason) {
+        return this.client.proxy
+            .channels(channelId)
+            .messages(messageId)
+            .delete({ reason })
+            .then(() => {
+            return this.client.components.onMessageDelete(messageId);
+        });
+    }
+    fetch(messageId, channelId) {
+        return this.client.proxy
+            .channels(channelId)
+            .messages(messageId)
+            .get()
+            .then(x => new structures_1.Message(this.client, x));
+    }
+    purge(messages, channelId, reason) {
+        return this.client.proxy.channels(channelId).messages['bulk-delete'].post({ body: { messages }, reason });
+    }
+    thread(channelId, messageId, options) {
+        const { reason, ...body } = options;
+        return this.client.proxy
+            .channels(channelId)
+            .messages(messageId)
+            .threads.post({ body, reason })
+            .then(x => new structures_1.ThreadChannel(this.client, x));
     }
 }
 exports.MessageShorter = MessageShorter;

package/lib/common/shorters/reactions.d.ts

@@ -0,0 +1,10 @@
+import type { RESTGetAPIChannelMessageReactionUsersQuery } from 'discord-api-types/v10';
+import { User } from '../../structures';
+import type { EmojiResolvable } from '../types/resolvables';
+import { BaseShorter } from './base';
+export declare class ReactionShorter extends BaseShorter {
+    add(messageId: string, channelId: string, emoji: EmojiResolvable): Promise<void>;
+    delete(messageId: string, channelId: string, emoji: EmojiResolvable, userId?: string): Promise<void>;
+    fetch(messageId: string, channelId: string, emoji: EmojiResolvable, query?: RESTGetAPIChannelMessageReactionUsersQuery): Promise<User[]>;
+    purge(messageId: string, channelId: string, emoji?: EmojiResolvable): Promise<void>;
+}

package/lib/common/shorters/reactions.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactionShorter = void 0;
+const structures_1 = require("../../structures");
+const functions_1 = require("../../structures/extra/functions");
+const base_1 = require("./base");
+class ReactionShorter extends base_1.BaseShorter {
+    async add(messageId, channelId, emoji) {
+        const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
+        if (!rawEmoji) {
+            throw new Error('Emoji no resolvable');
+        }
+        return this.client.proxy.channels(channelId).messages(messageId).reactions((0, functions_1.encodeEmoji)(rawEmoji))('@me').put({});
+    }
+    async delete(messageId, channelId, emoji, userId = '@me') {
+        const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
+        if (!rawEmoji) {
+            throw new Error('Emoji no resolvable');
+        }
+        return this.client.proxy.channels(channelId).messages(messageId).reactions((0, functions_1.encodeEmoji)(rawEmoji))(userId).delete();
+    }
+    async fetch(messageId, channelId, emoji, query) {
+        const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
+        if (!rawEmoji) {
+            throw new Error('Emoji no resolvable');
+        }
+        return this.client.proxy
+            .channels(channelId)
+            .messages(messageId)
+            .reactions((0, functions_1.encodeEmoji)(rawEmoji))
+            .get({ query })
+            .then(u => u.map(user => new structures_1.User(this.client, user)));
+    }
+    async purge(messageId, channelId, emoji) {
+        if (!emoji) {
+            return this.client.proxy.channels(channelId).messages(messageId).reactions.delete();
+        }
+        const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
+        if (!rawEmoji) {
+            throw new Error('Emoji no resolvable');
+        }
+        return this.client.proxy.channels(channelId).messages(messageId).reactions((0, functions_1.encodeEmoji)(rawEmoji)).delete();
+    }
+}
+exports.ReactionShorter = ReactionShorter;

package/lib/common/shorters/roles.d.ts

@@ -2,11 +2,43 @@ import type { RESTPatchAPIGuildRoleJSONBody, RESTPatchAPIGuildRolePositionsJSONB
 import { GuildRole } from '../../structures';
 import { BaseShorter } from './base';
 export declare class RoleShorter extends BaseShorter {
-    get roles(): {
-        create: (guildId: string, body: RESTPostAPIGuildRoleJSONBody, reason?: string) => Promise<any>;
-        list: (guildId: string, force?: boolean) => Promise<GuildRole[]>;
-        edit: (guildId: string, roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string) => Promise<any>;
-        delete: (guildId: string, roleId: string, reason?: string) => Promise<void | undefined>;
-        editPositions: (guildId: string, body: RESTPatchAPIGuildRolePositionsJSONBody) => Promise<GuildRole[]>;
-    };
+    /**
+     * Creates a new role in the guild.
+     * @param guildId The ID of the guild.
+     * @param body The data for creating the role.
+     * @param reason The reason for creating the role.
+     * @returns A Promise that resolves when the role is created.
+     */
+    create(guildId: string, body: RESTPostAPIGuildRoleJSONBody, reason?: string): Promise<any>;
+    /**
+     * Retrieves a list of roles in the guild.
+     * @param guildId The ID of the guild.
+     * @param force Whether to force fetching roles from the API even if they exist in the cache.
+     * @returns A Promise that resolves to an array of roles.
+     */
+    list(guildId: string, force?: boolean): Promise<GuildRole[]>;
+    /**
+     * Edits a role in the guild.
+     * @param guildId The ID of the guild.
+     * @param roleId The ID of the role to edit.
+     * @param body The data to update the role with.
+     * @param reason The reason for editing the role.
+     * @returns A Promise that resolves when the role is edited.
+     */
+    edit(guildId: string, roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string): Promise<any>;
+    /**
+     * Deletes a role from the guild.
+     * @param guildId The ID of the guild.
+     * @param roleId The ID of the role to delete.
+     * @param reason The reason for deleting the role.
+     * @returns A Promise that resolves when the role is deleted.
+     */
+    delete(guildId: string, roleId: string, reason?: string): Promise<void | undefined>;
+    /**
+     * Edits the positions of roles in the guild.
+     * @param guildId The ID of the guild.
+     * @param body The data to update the positions of roles with.
+     * @returns A Promise that resolves to an array of edited roles.
+     */
+    editPositions(guildId: string, body: RESTPatchAPIGuildRolePositionsJSONBody): Promise<GuildRole[]>;
 }

package/lib/common/shorters/roles.js

@@ -4,48 +4,80 @@ exports.RoleShorter = void 0;
 const structures_1 = require("../../structures");
 const base_1 = require("./base");
 class RoleShorter extends base_1.BaseShorter {
-    get roles() {
-        return {
-            create: (guildId, body, reason) => this.client.proxy
-                .guilds(guildId)
-                .roles.post({ body, reason })
-                .then(res => this.client.cache.roles?.setIfNI('Guilds', res.id, guildId, res)),
-            list: async (guildId, force = false) => {
-                let roles = [];
-                if (!force) {
-                    const cachedRoles = (await this.client.cache.roles?.values(guildId)) ?? [];
-                    if (cachedRoles.length) {
-                        return cachedRoles;
-                    }
-                }
-                roles = await this.client.proxy.guilds(guildId).roles.get();
-                await this.client.cache.roles?.set(roles.map(r => [r.id, r]), guildId);
-                return roles.map(r => new structures_1.GuildRole(this.client, r, guildId));
-            },
-            edit: (guildId, roleId, body, reason) => {
-                return this.client.proxy
-                    .guilds(guildId)
-                    .roles(roleId)
-                    .patch({ body, reason })
-                    .then(res => this.client.cache.roles?.setIfNI('Guilds', roleId, guildId, res));
-            },
-            delete: (guildId, roleId, reason) => {
-                return this.client.proxy
-                    .guilds(guildId)
-                    .roles(roleId)
-                    .delete({ reason })
-                    .then(() => this.client.cache.roles?.removeIfNI('Guilds', roleId, guildId));
-            },
-            editPositions: async (guildId, body) => {
-                const roles = await this.client.proxy.guilds(guildId).roles.patch({
-                    body,
-                });
-                if (!this.client.cache.hasRolesIntent) {
-                    await this.client.cache.roles?.set(roles.map(x => [x.id, x]), guildId);
-                }
-                return roles.map(x => new structures_1.GuildRole(this.client, x, guildId));
-            },
-        };
+    /**
+     * Creates a new role in the guild.
+     * @param guildId The ID of the guild.
+     * @param body The data for creating the role.
+     * @param reason The reason for creating the role.
+     * @returns A Promise that resolves when the role is created.
+     */
+    create(guildId, body, reason) {
+        return this.client.proxy
+            .guilds(guildId)
+            .roles.post({ body, reason })
+            .then(res => this.client.cache.roles?.setIfNI('Guilds', res.id, guildId, res));
+    }
+    /**
+     * Retrieves a list of roles in the guild.
+     * @param guildId The ID of the guild.
+     * @param force Whether to force fetching roles from the API even if they exist in the cache.
+     * @returns A Promise that resolves to an array of roles.
+     */
+    async list(guildId, force = false) {
+        let roles = [];
+        if (!force) {
+            const cachedRoles = (await this.client.cache.roles?.values(guildId)) ?? [];
+            if (cachedRoles.length) {
+                return cachedRoles;
+            }
+        }
+        roles = await this.client.proxy.guilds(guildId).roles.get();
+        await this.client.cache.roles?.set(roles.map(r => [r.id, r]), guildId);
+        return roles.map(r => new structures_1.GuildRole(this.client, r, guildId));
+    }
+    /**
+     * Edits a role in the guild.
+     * @param guildId The ID of the guild.
+     * @param roleId The ID of the role to edit.
+     * @param body The data to update the role with.
+     * @param reason The reason for editing the role.
+     * @returns A Promise that resolves when the role is edited.
+     */
+    edit(guildId, roleId, body, reason) {
+        return this.client.proxy
+            .guilds(guildId)
+            .roles(roleId)
+            .patch({ body, reason })
+            .then(res => this.client.cache.roles?.setIfNI('Guilds', roleId, guildId, res));
+    }
+    /**
+     * Deletes a role from the guild.
+     * @param guildId The ID of the guild.
+     * @param roleId The ID of the role to delete.
+     * @param reason The reason for deleting the role.
+     * @returns A Promise that resolves when the role is deleted.
+     */
+    delete(guildId, roleId, reason) {
+        return this.client.proxy
+            .guilds(guildId)
+            .roles(roleId)
+            .delete({ reason })
+            .then(() => this.client.cache.roles?.removeIfNI('Guilds', roleId, guildId));
+    }
+    /**
+     * Edits the positions of roles in the guild.
+     * @param guildId The ID of the guild.
+     * @param body The data to update the positions of roles with.
+     * @returns A Promise that resolves to an array of edited roles.
+     */
+    async editPositions(guildId, body) {
+        const roles = await this.client.proxy.guilds(guildId).roles.patch({
+            body,
+        });
+        if (!this.client.cache.hasRolesIntent) {
+            await this.client.cache.roles?.set(roles.map(x => [x.id, x]), guildId);
+        }
+        return roles.map(x => new structures_1.GuildRole(this.client, x, guildId));
     }
 }
 exports.RoleShorter = RoleShorter;

package/lib/common/shorters/templates.d.ts

@@ -1,12 +1,10 @@
 import type { RESTPatchAPIGuildTemplateJSONBody, RESTPostAPIGuildTemplatesJSONBody } from 'discord-api-types/v10';
 import { BaseShorter } from './base';
 export declare class TemplateShorter extends BaseShorter {
-    get templates(): {
-        fetch: (code: string) => Promise<import("discord-api-types/v10").APITemplate>;
-        list: (guildId: string) => Promise<import("discord-api-types/v10").RESTGetAPIGuildTemplatesResult>;
-        create: (guildId: string, body: RESTPostAPIGuildTemplatesJSONBody) => Promise<import("discord-api-types/v10").APITemplate>;
-        sync: (guildId: string, code: string) => Promise<import("discord-api-types/v10").APITemplate>;
-        edit: (guildId: string, code: string, body: RESTPatchAPIGuildTemplateJSONBody) => Promise<import("discord-api-types/v10").APITemplate>;
-        delete: (guildId: string, code: string) => Promise<import("discord-api-types/v10").APITemplate>;
-    };
+    fetch(code: string): Promise<import("discord-api-types/v10").APITemplate>;
+    list(guildId: string): Promise<import("discord-api-types/v10").RESTGetAPIGuildTemplatesResult>;
+    create(guildId: string, body: RESTPostAPIGuildTemplatesJSONBody): Promise<import("discord-api-types/v10").APITemplate>;
+    sync(guildId: string, code: string): Promise<import("discord-api-types/v10").APITemplate>;
+    edit(guildId: string, code: string, body: RESTPatchAPIGuildTemplateJSONBody): Promise<import("discord-api-types/v10").APITemplate>;
+    delete(guildId: string, code: string): Promise<import("discord-api-types/v10").APITemplate>;
 }

package/lib/common/shorters/templates.js

@@ -3,27 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateShorter = void 0;
 const base_1 = require("./base");
 class TemplateShorter extends base_1.BaseShorter {
-    get templates() {
-        return {
-            fetch: (code) => {
-                return this.client.proxy.guilds.templates(code).get();
-            },
-            list: (guildId) => {
-                return this.client.proxy.guilds(guildId).templates.get();
-            },
-            create: (guildId, body) => {
-                return this.client.proxy.guilds(guildId).templates.post({ body });
-            },
-            sync: (guildId, code) => {
-                return this.client.proxy.guilds(guildId).templates(code).put({});
-            },
-            edit: (guildId, code, body) => {
-                return this.client.proxy.guilds(guildId).templates(code).patch({ body });
-            },
-            delete: (guildId, code) => {
-                return this.client.proxy.guilds(guildId).templates(code).delete();
-            },
-        };
+    fetch(code) {
+        return this.client.proxy.guilds.templates(code).get();
+    }
+    list(guildId) {
+        return this.client.proxy.guilds(guildId).templates.get();
+    }
+    create(guildId, body) {
+        return this.client.proxy.guilds(guildId).templates.post({ body });
+    }
+    sync(guildId, code) {
+        return this.client.proxy.guilds(guildId).templates(code).put({});
+    }
+    edit(guildId, code, body) {
+        return this.client.proxy.guilds(guildId).templates(code).patch({ body });
+    }
+    delete(guildId, code) {
+        return this.client.proxy.guilds(guildId).templates(code).delete();
     }
 }
 exports.TemplateShorter = TemplateShorter;

package/lib/common/shorters/users.d.ts

@@ -2,6 +2,10 @@ import { DMChannel, User } from '../../structures';
 import type { MessageCreateBodyRequest } from '../types/write';
 import { BaseShorter } from './base';
 export declare class UsersShorter extends BaseShorter {
+    createDM(userId: string, force?: boolean): Promise<DMChannel>;
+    deleteDM(userId: string, reason?: string): Promise<DMChannel>;
+    fetch(userId: string, force?: boolean): Promise<User>;
+    write(userId: string, body: MessageCreateBodyRequest): Promise<import("../../structures").Message>;
     get users(): {
         createDM: (userId: string, force?: boolean) => Promise<DMChannel>;
         deleteDM: (userId: string, reason?: string) => Promise<DMChannel>;

package/lib/common/shorters/users.js

@@ -4,6 +4,36 @@ exports.UsersShorter = void 0;
 const structures_1 = require("../../structures");
 const base_1 = require("./base");
 class UsersShorter extends base_1.BaseShorter {
+    async createDM(userId, force = false) {
+        if (!force) {
+            const dm = await this.client.cache.channels?.get(userId);
+            if (dm)
+                return dm;
+        }
+        const data = await this.client.proxy.users('@me').channels.post({
+            body: { recipient_id: userId },
+        });
+        await this.client.cache.channels?.set(userId, '@me', data);
+        return new structures_1.DMChannel(this.client, data);
+    }
+    async deleteDM(userId, reason) {
+        const res = await this.client.proxy.channels(userId).delete({ reason });
+        await this.client.cache.channels?.removeIfNI(structures_1.BaseChannel.__intent__('@me'), res.id, '@me');
+        return new structures_1.DMChannel(this.client, res);
+    }
+    async fetch(userId, force = false) {
+        if (!force) {
+            const user = await this.client.cache.users?.get(userId);
+            if (user)
+                return user;
+        }
+        const data = await this.client.proxy.users(userId).get();
+        await this.client.cache.users?.patch(userId, data);
+        return new structures_1.User(this.client, data);
+    }
+    async write(userId, body) {
+        return (await this.client.users.createDM(userId)).messages.write(body);
+    }
     get users() {
         return {
             createDM: async (userId, force = false) => {

package/lib/common/shorters/webhook.d.ts

@@ -1,31 +1,67 @@
-import type { RESTPatchAPIWebhookJSONBody, RESTPatchAPIWebhookWithTokenJSONBody, RESTPostAPIWebhookWithTokenJSONBody } from '..';
-import { type MessageWebhookMethodEditParams, type MessageWebhookMethodWriteParams, Webhook, WebhookMessage } from '../../structures';
+import type { RESTPatchAPIWebhookJSONBody, RESTPatchAPIWebhookWithTokenJSONBody, RESTPostAPIChannelWebhookJSONBody } from '..';
+import { Webhook, WebhookMessage, type MessageWebhookMethodEditParams, type MessageWebhookMethodWriteParams } from '../../structures';
 import { BaseShorter } from './base';
 export declare class WebhookShorter extends BaseShorter {
-    get webhooks(): {
-        delete: (webhookId: string, { token, reason }: WebhookShorterOptionalParams) => Promise<never>;
-        edit: (webhookId: string, body: RESTPatchAPIWebhookWithTokenJSONBody | RESTPatchAPIWebhookJSONBody, { token, reason }: WebhookShorterOptionalParams) => Promise<import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenResult>;
-        fetch: (webhookId: string, token?: string) => Promise<Webhook>;
-        messages: {
-            write: (webhookId: string, token: string, { body: data, ...payload }: {
-                body: Omit<RESTPostAPIWebhookWithTokenJSONBody, "components" | "embeds"> & import("..").ResolverProps;
-                query?: import("discord-api-types/rest/v10/webhook").RESTPostAPIWebhookWithTokenQuery | undefined;
-            }) => Promise<WebhookMessage | null>;
-            edit: (webhookId: string, token: string, { messageId, body: data, ...json }: {
-                body: Omit<import("discord-api-types/rest/v10/webhook").RESTPatchAPIWebhookWithTokenMessageJSONBody, "components" | "embeds"> & import("..").ResolverProps;
-                messageId: string;
-                query?: import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenMessageQuery | undefined;
-            }) => Promise<WebhookMessage>;
-            delete: (webhookId: string, token: string, messageId: string, reason?: string | undefined) => Promise<never>;
-            fetch: (webhookId: string, token: string, messageId: string, threadId?: string | undefined) => Promise<WebhookMessage | undefined>;
-        };
-    };
-    get messages(): {
-        write: (webhookId: string, token: string, { body: data, ...payload }: MessageWebhookMethodWriteParams) => Promise<WebhookMessage | null>;
-        edit: (webhookId: string, token: string, { messageId, body: data, ...json }: MessageWebhookMethodEditParams) => Promise<WebhookMessage>;
-        delete: (webhookId: string, token: string, messageId: string, reason?: string) => Promise<never>;
-        fetch: (webhookId: string, token: string, messageId: string, threadId?: string) => Promise<WebhookMessage | undefined>;
-    };
+    create(channelId: string, body: RESTPostAPIChannelWebhookJSONBody): Promise<Webhook>;
+    /**
+     * Deletes a webhook.
+     * @param webhookId The ID of the webhook.
+     * @param options The optional parameters including token and reason.
+     * @returns A Promise that resolves when the webhook is deleted.
+     */
+    delete(webhookId: string, options: WebhookShorterOptionalParams): Promise<never>;
+    /**
+     * Edits a webhook.
+     * @param webhookId The ID of the webhook.
+     * @param body The data to update the webhook with.
+     * @param options The optional parameters including token and reason.
+     * @returns A Promise that resolves when the webhook is edited.
+     */
+    edit(webhookId: string, body: RESTPatchAPIWebhookWithTokenJSONBody | RESTPatchAPIWebhookJSONBody, options: WebhookShorterOptionalParams): Promise<import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenResult>;
+    /**
+     * Fetches a webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook (optional).
+     * @returns A Promise that resolves to the fetched webhook.
+     */
+    fetch(webhookId: string, token?: string): Promise<Webhook>;
+    /**
+     * Writes a message using the webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param data The data for writing the message.
+     * @returns A Promise that resolves to the written message.
+     */
+    writeMessage(webhookId: string, token: string, { body: data, ...payload }: MessageWebhookMethodWriteParams): Promise<WebhookMessage | null>;
+    /**
+     * Edits a message sent by the webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param messageId The ID of the message to edit.
+     * @param data The data for editing the message.
+     * @returns A Promise that resolves to the edited message.
+     */
+    editMessage(webhookId: string, token: string, { messageId, body: data, ...json }: MessageWebhookMethodEditParams): Promise<WebhookMessage>;
+    /**
+     * Deletes a message sent by the webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param messageId The ID of the message to delete.
+     * @param reason The reason for deleting the message.
+     * @returns A Promise that resolves when the message is deleted.
+     */
+    deleteMessage(webhookId: string, token: string, messageId: string, reason?: string): Promise<never>;
+    /**
+     * Fetches a message sent by the webhook.
+     * @param webhookId The ID of the webhook.
+     * @param token The token of the webhook.
+     * @param messageId The ID of the message to fetch.
+     * @param threadId The ID of the thread the message belongs to.
+     * @returns A Promise that resolves to the fetched message, or undefined if not found.
+     */
+    fetchMessage(webhookId: string, token: string, messageId: string, threadId?: string): Promise<WebhookMessage | undefined>;
+    listFromGuild(guildId: string): Promise<Webhook[]>;
+    listFromChannel(channelId: string): Promise<Webhook[]>;
 }
 export type WebhookShorterOptionalParams = Partial<{
     token: string;