seyfert 1.2.2 → 1.3.0

package/lib/common/shorters/interaction.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionShorter = void 0;
+const __1 = require("../..");
+const base_1 = require("./base");
+class InteractionShorter extends base_1.BaseShorter {
+    async reply(id, token, body) {
+        //@ts-expect-error
+        const { files, ...data } = body.data ?? {};
+        return this.client.proxy
+            .interactions(id)(token)
+            .callback.post({
+            body: __1.BaseInteraction.transformBodyRequest({
+                type: body.type,
+                data,
+            }),
+            files: files ? await (0, __1.resolveFiles)(files) : undefined,
+        });
+    }
+    fetchResponse(token, messageId) {
+        return this.client.webhooks.fetchMessage(this.client.applicationId, token, messageId);
+    }
+    fetchOriginal(token) {
+        return this.fetchResponse(token, '@original');
+    }
+    async editMessage(token, messageId, body) {
+        const { files, ...data } = body;
+        const apiMessage = await this.client.proxy
+            .webhooks(this.client.applicationId)(token)
+            .messages(messageId)
+            .patch({
+            body: __1.BaseInteraction.transformBody(data),
+            files: files ? await (0, __1.resolveFiles)(files) : undefined,
+        });
+        return new __1.WebhookMessage(this.client, apiMessage, this.client.applicationId, token);
+    }
+    editOriginal(token, body) {
+        return this.editMessage(token, '@original', body);
+    }
+    deleteResponse(interactionId, token, messageId) {
+        return this.client.proxy
+            .webhooks(this.client.applicationId)(token)
+            .messages(messageId)
+            .delete()
+            .then(() => this.client.components?.onMessageDelete(messageId === '@original' ? interactionId : messageId));
+    }
+    deleteOriginal(interactionId, token) {
+        return this.deleteResponse(interactionId, token, '@original');
+    }
+    async followup(token, { files, ...body }) {
+        files = files ? await (0, __1.resolveFiles)(files) : undefined;
+        const apiMessage = await this.client.proxy
+            .webhooks(this.client.applicationId)(token)
+            .post({
+            body: __1.BaseInteraction.transformBody(body),
+            files: files,
+        });
+        return new __1.WebhookMessage(this.client, apiMessage, this.client.applicationId, token);
+    }
+}
+exports.InteractionShorter = InteractionShorter;

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

@@ -1,15 +1,18 @@
 import type { RESTPostAPIChannelMessagesThreadsJSONBody } from 'discord-api-types/v10';
-import { Message, type ThreadChannel } from '../../structures';
+import { Message, User } from '../../structures';
 import type { MessageCreateBodyRequest, MessageUpdateBodyRequest } from '../types/write';
 import { BaseShorter } from './base';
+import type { ValidAnswerId } from '../../api/Routes/channels';
 export declare class MessageShorter extends BaseShorter {
     write(channelId: string, { files, ...body }: MessageCreateBodyRequest): Promise<Message>;
     edit(messageId: string, channelId: string, { files, ...body }: MessageUpdateBodyRequest): Promise<Message>;
     crosspost(messageId: string, channelId: string, reason?: string): Promise<Message>;
     delete(messageId: string, channelId: string, reason?: string): Promise<void>;
     fetch(messageId: string, channelId: string): Promise<Message>;
-    purge(messages: string[], channelId: string, reason?: string): Promise<never>;
+    purge(messages: string[], channelId: string, reason?: string): Promise<void | undefined>;
     thread(channelId: string, messageId: string, options: RESTPostAPIChannelMessagesThreadsJSONBody & {
         reason?: string;
-    }): Promise<ThreadChannel>;
+    }): Promise<import("../../structures").ThreadChannel>;
+    endPoll(channelId: string, messageId: string): Promise<Message>;
+    getAnswerVoters(channelId: string, messageId: string, answerId: ValidAnswerId): Promise<User[]>;
 }

package/lib/common/shorters/messages.js

@@ -1,12 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageShorter = void 0;
 const builders_1 = require("../../builders");
 const structures_1 = require("../../structures");
-const channels_1 = __importDefault(require("../../structures/channels"));
 const base_1 = require("./base");
 class MessageShorter extends base_1.BaseShorter {
     async write(channelId, { files, ...body }) {
@@ -18,7 +14,8 @@ class MessageShorter extends base_1.BaseShorter {
             body: transformedBody,
             files: parsedFiles,
         })
-            .then(message => {
+            .then(async (message) => {
+            await this.client.cache.messages?.setIfNI('GuildMessages', message.id, message.channel_id, message);
             return new structures_1.Message(this.client, message);
         });
     }
@@ -31,7 +28,8 @@ class MessageShorter extends base_1.BaseShorter {
             body: structures_1.MessagesMethods.transformMessageBody(body),
             files: parsedFiles,
         })
-            .then(message => {
+            .then(async (message) => {
+            await this.client.cache.messages?.setIfNI('GuildMessages', message.id, message.channel_id, message);
             return new structures_1.Message(this.client, message);
         });
     }
@@ -40,14 +38,18 @@ class MessageShorter extends base_1.BaseShorter {
             .channels(channelId)
             .messages(messageId)
             .crosspost.post({ reason })
-            .then(m => new structures_1.Message(this.client, m));
+            .then(async (m) => {
+            await this.client.cache.messages?.setIfNI('GuildMessages', m.id, m.channel_id, m);
+            return new structures_1.Message(this.client, m);
+        });
     }
     delete(messageId, channelId, reason) {
         return this.client.proxy
             .channels(channelId)
             .messages(messageId)
             .delete({ reason })
-            .then(() => {
+            .then(async () => {
+            await this.client.cache.messages?.removeIfNI('GuildMessages', messageId, channelId);
             void this.client.components?.onMessageDelete(messageId);
         });
     }
@@ -56,18 +58,34 @@ class MessageShorter extends base_1.BaseShorter {
             .channels(channelId)
             .messages(messageId)
             .get()
-            .then(x => new structures_1.Message(this.client, x));
+            .then(async (x) => {
+            await this.client.cache.messages?.set(x.id, x.channel_id, x);
+            return new structures_1.Message(this.client, x);
+        });
     }
     purge(messages, channelId, reason) {
-        return this.client.proxy.channels(channelId).messages['bulk-delete'].post({ body: { messages }, reason });
+        return this.client.proxy
+            .channels(channelId)
+            .messages['bulk-delete'].post({ body: { messages }, reason })
+            .then(() => this.client.cache.messages?.removeIfNI('GuildMessages', messages, channelId));
+    }
+    thread(channelId, messageId, options) {
+        return this.client.threads.fromMessage(channelId, messageId, options);
     }
-    async thread(channelId, messageId, options) {
-        const { reason, ...body } = options;
+    endPoll(channelId, messageId) {
         return this.client.proxy
             .channels(channelId)
-            .messages(messageId)
-            .threads.post({ body, reason })
-            .then(thread => (0, channels_1.default)(thread, this.client));
+            .polls(messageId)
+            .expire.post()
+            .then(message => new structures_1.Message(this.client, message));
+    }
+    getAnswerVoters(channelId, messageId, answerId) {
+        return this.client.proxy
+            .channels(channelId)
+            .polls(messageId)
+            .answers(answerId)
+            .get()
+            .then(data => data.users.map(user => new structures_1.User(this.client, user)));
     }
 }
 exports.MessageShorter = MessageShorter;

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

@@ -9,7 +9,7 @@ export declare class RoleShorter extends BaseShorter {
      * @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>;
+    create(guildId: string, body: RESTPostAPIGuildRoleJSONBody, reason?: string): Promise<GuildRole>;
     /**
      * Retrieves a list of roles in the guild.
      * @param guildId The ID of the guild.
@@ -25,7 +25,7 @@ export declare class RoleShorter extends BaseShorter {
      * @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>;
+    edit(guildId: string, roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string): Promise<GuildRole>;
     /**
      * Deletes a role from the guild.
      * @param guildId The ID of the guild.
@@ -33,7 +33,7 @@ export declare class RoleShorter extends BaseShorter {
      * @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>;
+    delete(guildId: string, roleId: string, reason?: string): Promise<GuildRole>;
     /**
      * Edits the positions of roles in the guild.
      * @param guildId The ID of the guild.

package/lib/common/shorters/roles.js

@@ -11,11 +11,10 @@ class RoleShorter extends base_1.BaseShorter {
      * @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));
+    async create(guildId, body, reason) {
+        const res = await this.client.proxy.guilds(guildId).roles.post({ body, reason });
+        await this.client.cache.roles?.setIfNI('Guilds', res.id, guildId, res);
+        return new structures_1.GuildRole(this.client, res, guildId);
     }
     /**
      * Retrieves a list of roles in the guild.
@@ -43,12 +42,10 @@ class RoleShorter extends base_1.BaseShorter {
      * @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));
+    async edit(guildId, roleId, body, reason) {
+        const res = await this.client.proxy.guilds(guildId).roles(roleId).patch({ body, reason });
+        await this.client.cache.roles?.setIfNI('Guilds', roleId, guildId, res);
+        return new structures_1.GuildRole(this.client, res, guildId);
     }
     /**
      * Deletes a role from the guild.
@@ -57,12 +54,10 @@ class RoleShorter extends base_1.BaseShorter {
      * @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));
+    async delete(guildId, roleId, reason) {
+        const res = await this.client.proxy.guilds(guildId).roles(roleId).delete({ reason });
+        this.client.cache.roles?.removeIfNI('Guilds', roleId, guildId);
+        return new structures_1.GuildRole(this.client, res, guildId);
     }
     /**
      * Edits the positions of roles in the guild.

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

@@ -1,10 +1,11 @@
 import type { RESTPatchAPIGuildTemplateJSONBody, RESTPostAPIGuildTemplatesJSONBody } from 'discord-api-types/v10';
 import { BaseShorter } from './base';
+import { GuildTemplate } from '../..';
 export declare class TemplateShorter extends BaseShorter {
-    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<GuildTemplate>;
+    list(guildId: string): Promise<GuildTemplate[]>;
+    create(guildId: string, body: RESTPostAPIGuildTemplatesJSONBody): Promise<GuildTemplate>;
+    sync(guildId: string, code: string): Promise<GuildTemplate>;
+    edit(guildId: string, code: string, body: RESTPatchAPIGuildTemplateJSONBody): Promise<GuildTemplate>;
+    delete(guildId: string, code: string): Promise<GuildTemplate>;
 }

package/lib/common/shorters/templates.js

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

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

@@ -0,0 +1,39 @@
+import type { APIThreadMember, RESTGetAPIChannelThreadMembersQuery, RESTGetAPIChannelThreadsArchivedQuery, RESTPatchAPIChannelJSONBody, RESTPostAPIChannelMessagesThreadsJSONBody, RESTPostAPIChannelThreadsJSONBody, RESTPostAPIGuildForumThreadsJSONBody } from 'discord-api-types/v10';
+import type { ThreadChannel } from '../../structures';
+import { BaseShorter } from './base';
+import type { MakeRequired, When } from '../types/util';
+export declare class ThreadShorter extends BaseShorter {
+    /**
+     * Creates a new thread in the channel (only guild based channels).
+     * @param channelId The ID of the parent channel.
+     * @param reason The reason for unpinning the message.
+     * @returns A promise that resolves when the thread is succesfully created.
+     */
+    create(channelId: string, body: RESTPostAPIChannelThreadsJSONBody | RESTPostAPIGuildForumThreadsJSONBody, reason?: string): Promise<ThreadChannel>;
+    fromMessage(channelId: string, messageId: string, options: RESTPostAPIChannelMessagesThreadsJSONBody & {
+        reason?: string;
+    }): Promise<ThreadChannel>;
+    join(threadId: string): Promise<never>;
+    leave(threadId: string): Promise<never>;
+    lock(threadId: string, locked?: boolean, reason?: string): Promise<ThreadChannel>;
+    edit(threadId: string, body: RESTPatchAPIChannelJSONBody, reason?: string): Promise<import("../../structures").AllChannels>;
+    removeMember(threadId: string, memberId: string): Promise<never>;
+    fetchMember<WithMember extends boolean = false>(threadId: string, memberId: string, with_member: WithMember): Promise<When<WithMember, Required<APIThreadMember>, GetAPIChannelThreadMemberResult>>;
+    addMember(threadId: string, memberId: string): Promise<never>;
+    listMembers<T extends RESTGetAPIChannelThreadMembersQuery = RESTGetAPIChannelThreadMembersQuery>(threadId: string, query?: T): Promise<InferWithMemberOnList<T>>;
+    listArchivedThreads(channelId: string, type: 'public' | 'private', query?: RESTGetAPIChannelThreadsArchivedQuery): Promise<{
+        threads: ThreadChannel[];
+        members: GetAPIChannelThreadMemberResult[];
+        hasMore: boolean;
+    }>;
+    listJoinedArchivedPrivate(channelId: string, query?: RESTGetAPIChannelThreadsArchivedQuery): Promise<{
+        threads: ThreadChannel[];
+        members: GetAPIChannelThreadMemberResult[];
+        hasMore: boolean;
+    }>;
+}
+export type GetAPIChannelThreadMemberResult = MakeRequired<APIThreadMember, 'id' | 'user_id'>;
+type InferWithMemberOnList<T extends RESTGetAPIChannelThreadMembersQuery> = T extends {
+    with_member: infer B;
+} ? B extends true ? Required<APIThreadMember>[] : GetAPIChannelThreadMemberResult[] : GetAPIChannelThreadMemberResult[];
+export {};

package/lib/common/shorters/threads.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadShorter = void 0;
+const channels_1 = __importDefault(require("../../structures/channels"));
+const base_1 = require("./base");
+class ThreadShorter extends base_1.BaseShorter {
+    /**
+     * Creates a new thread in the channel (only guild based channels).
+     * @param channelId The ID of the parent channel.
+     * @param reason The reason for unpinning the message.
+     * @returns A promise that resolves when the thread is succesfully created.
+     */
+    async create(channelId, body, reason) {
+        return (this.client.proxy
+            .channels(channelId)
+            .threads.post({ body, reason })
+            // When testing this, discord returns the thread object, but in discord api types it does not.
+            .then(thread => (0, channels_1.default)(thread, this.client)));
+    }
+    async fromMessage(channelId, messageId, options) {
+        const { reason, ...body } = options;
+        return this.client.proxy
+            .channels(channelId)
+            .messages(messageId)
+            .threads.post({ body, reason })
+            .then(thread => (0, channels_1.default)(thread, this.client));
+    }
+    async join(threadId) {
+        return this.client.proxy.channels(threadId)['thread-members']('@me').put();
+    }
+    async leave(threadId) {
+        return this.client.proxy.channels(threadId)['thread-members']('@me').delete();
+    }
+    async lock(threadId, locked = true, reason) {
+        return this.edit(threadId, { locked }, reason).then(x => (0, channels_1.default)(x, this.client));
+    }
+    async edit(threadId, body, reason) {
+        return this.client.channels.edit(threadId, body, { reason });
+    }
+    async removeMember(threadId, memberId) {
+        return this.client.proxy.channels(threadId)['thread-members'](memberId).delete();
+    }
+    async fetchMember(threadId, memberId, with_member) {
+        return this.client.proxy.channels(threadId)['thread-members'](memberId).get({
+            query: {
+                with_member,
+            },
+        });
+    }
+    async addMember(threadId, memberId) {
+        return this.client.proxy.channels(threadId)['thread-members'](memberId).put();
+    }
+    async listMembers(threadId, query) {
+        return this.client.proxy.channels(threadId)['thread-members'].get({ query });
+    }
+    async listArchivedThreads(channelId, type, query) {
+        const data = await this.client.proxy.channels(channelId).threads.archived[type].get({ query });
+        return {
+            threads: data.threads.map(thread => (0, channels_1.default)(thread, this.client)),
+            members: data.members,
+            hasMore: data.has_more,
+        };
+    }
+    async listJoinedArchivedPrivate(channelId, query) {
+        const data = await this.client.proxy.channels(channelId).users('@me').threads.archived.private.get({ query });
+        return {
+            threads: data.threads.map(thread => (0, channels_1.default)(thread, this.client)),
+            members: data.members,
+            hasMore: data.has_more,
+        };
+    }
+}
+exports.ThreadShorter = ThreadShorter;

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

@@ -17,7 +17,7 @@ export declare class WebhookShorter extends BaseShorter {
      * @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/v10").RESTGetAPIWebhookWithTokenResult>;
+    edit(webhookId: string, body: RESTPatchAPIWebhookWithTokenJSONBody | RESTPatchAPIWebhookJSONBody, options: WebhookShorterOptionalParams): Promise<Webhook>;
     /**
      * Fetches a webhook.
      * @param webhookId The ID of the webhook.

package/lib/common/shorters/webhook.js

@@ -32,9 +32,15 @@ class WebhookShorter extends base_1.BaseShorter {
      */
     edit(webhookId, body, options) {
         if (options.token) {
-            return this.client.proxy.webhooks(webhookId)(options.token).patch({ body, reason: options.reason, auth: false });
+            return this.client.proxy
+                .webhooks(webhookId)(options.token)
+                .patch({ body, reason: options.reason, auth: false })
+                .then(webhook => new structures_1.Webhook(this.client, webhook));
         }
-        return this.client.proxy.webhooks(webhookId).patch({ body, reason: options.reason });
+        return this.client.proxy
+            .webhooks(webhookId)
+            .patch({ body, reason: options.reason })
+            .then(webhook => new structures_1.Webhook(this.client, webhook));
     }
     /**
      * Fetches a webhook.

package/lib/common/types/options.d.ts

@@ -1,7 +1,7 @@
 import type { Identify } from '..';
-import type { ImageURLOptions } from '../../api';
+import type { CDNUrlOptions } from '../../api';
 import type { UsingClient } from '../../commands';
-export type ImageOptions = ImageURLOptions;
+export type ImageOptions = CDNUrlOptions;
 export type MethodContext<T = {}> = Identify<{
     client: UsingClient;
 } & T>;

package/lib/common/types/write.d.ts

@@ -1,17 +1,20 @@
-import type { APIActionRowComponent, APIEmbed, APIInteractionResponseCallbackData, APIInteractionResponseChannelMessageWithSource, APIMessageActionRowComponent, APIModalInteractionResponse, RESTPatchAPIChannelMessageJSONBody, RESTPatchAPIWebhookWithTokenMessageJSONBody, RESTPostAPIChannelMessageJSONBody, RESTPostAPIWebhookWithTokenJSONBody } from 'discord-api-types/v10';
+import type { APIActionRowComponent, APIEmbed, APIInteractionResponseCallbackData, APIInteractionResponseChannelMessageWithSource, APIMessageActionRowComponent, APIModalInteractionResponse, RESTAPIPollCreate, RESTPatchAPIChannelMessageJSONBody, RESTPatchAPIWebhookWithTokenMessageJSONBody, RESTPostAPIChannelMessageJSONBody, RESTPostAPIWebhookWithTokenJSONBody } from 'discord-api-types/v10';
 import type { RawFile } from '../../api';
-import type { ActionRow, Attachment, AttachmentBuilder, BuilderComponents, Embed, Modal } from '../../builders';
+import type { ActionRow, Attachment, AttachmentBuilder, BuilderComponents, Embed, Modal, PollBuilder } from '../../builders';
 import type { OmitInsert } from './util';
 export interface ResolverProps {
     embeds?: Embed[] | APIEmbed[] | undefined;
     components?: APIActionRowComponent<APIMessageActionRowComponent>[] | ActionRow<BuilderComponents>[] | undefined;
     files?: AttachmentBuilder[] | Attachment[] | RawFile[] | undefined;
 }
-export type MessageCreateBodyRequest = OmitInsert<RESTPostAPIChannelMessageJSONBody, 'components' | 'embeds', ResolverProps>;
+export interface SendResolverProps extends ResolverProps {
+    poll?: PollBuilder | RESTAPIPollCreate | undefined;
+}
+export type MessageCreateBodyRequest = OmitInsert<RESTPostAPIChannelMessageJSONBody, 'components' | 'embeds' | 'poll', SendResolverProps>;
 export type MessageUpdateBodyRequest = OmitInsert<RESTPatchAPIChannelMessageJSONBody, 'components' | 'embeds', ResolverProps>;
-export type MessageWebhookCreateBodyRequest = OmitInsert<RESTPostAPIWebhookWithTokenJSONBody, 'components' | 'embeds', ResolverProps>;
+export type MessageWebhookCreateBodyRequest = OmitInsert<RESTPostAPIWebhookWithTokenJSONBody, 'components' | 'embeds' | 'poll', SendResolverProps>;
 export type MessageWebhookUpdateBodyRequest = OmitInsert<RESTPatchAPIWebhookWithTokenMessageJSONBody, 'components' | 'embeds', ResolverProps>;
 export type InteractionMessageUpdateBodyRequest = OmitInsert<RESTPatchAPIWebhookWithTokenMessageJSONBody, 'components' | 'embeds', ResolverProps>;
 export type ComponentInteractionMessageUpdate = OmitInsert<APIInteractionResponseCallbackData, 'components' | 'embeds', ResolverProps>;
-export type InteractionCreateBodyRequest = OmitInsert<APIInteractionResponseChannelMessageWithSource['data'], 'components' | 'embeds', ResolverProps>;
+export type InteractionCreateBodyRequest = OmitInsert<APIInteractionResponseChannelMessageWithSource['data'], 'components' | 'embeds' | 'poll', SendResolverProps>;
 export type ModalCreateBodyRequest = APIModalInteractionResponse['data'] | Modal;

package/lib/components/ButtonComponent.js

@@ -8,7 +8,7 @@ class LinkButtonComponent extends BaseComponent_1.BaseComponent {
         return this.data.style;
     }
     get url() {
-        // @ts-ignore
+        // @ts-expect-error
         return this.data.url;
     }
     get label() {

package/lib/components/componentcontext.d.ts

@@ -46,7 +46,7 @@ export declare class ComponentContext<Type extends keyof ComponentCommandInterac
      * Edits the response of the interaction.
      * @param body - The updated body of the response.
      */
-    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessage>;
     /**
      * Updates the interaction with new data.
      * @param body - The updated body of the interaction.

package/lib/components/handler.d.ts

@@ -16,23 +16,6 @@ type COMPONENTS = {
     timeout?: NodeJS.Timeout;
     __run: (customId: string | string[] | RegExp, callback: ComponentCallback) => any;
 };
-export interface ComponentHandlerLike {
-    readonly values: Map<string, COMPONENTS>;
-    readonly commands: (ComponentCommand | ModalCommand)[];
-    readonly modals: Map<string, ModalSubmitCallback> | LimitedCollection<string, ModalSubmitCallback>;
-    onFail: ComponentHandler['onFail'];
-    createComponentCollector: ComponentHandler['createComponentCollector'];
-    hasModal: ComponentHandler['hasModal'];
-    onModalSubmit: ComponentHandler['onModalSubmit'];
-    executeModal: ComponentHandler['executeModal'];
-    hasComponent: ComponentHandler['hasComponent'];
-    executeComponent: ComponentHandler['executeComponent'];
-    onComponent: ComponentHandler['onComponent'];
-    load: ComponentHandler['load'];
-    reload: ComponentHandler['reload'];
-    reloadAll: ComponentHandler['reloadAll'];
-    onMessageDelete: ComponentHandler['onMessageDelete'];
-}
 export declare class ComponentHandler extends BaseHandler {
     protected client: UsingClient;
     onFail: OnFailCallback;
@@ -57,5 +40,11 @@ export declare class ComponentHandler extends BaseHandler {
     reloadAll(): Promise<void>;
     executeComponent(interaction: ComponentInteraction): Promise<void>;
     executeModal(interaction: ModalSubmitInteraction): Promise<void>;
+    setHandlers({ callback }: {
+        callback: ComponentHandler['callback'];
+    }): void;
+    callback: (file: {
+        new (): ModalCommand | ComponentCommand;
+    }) => ModalCommand | ComponentCommand | false;
 }
 export {};

package/lib/components/handler.js

@@ -121,7 +121,9 @@ class ComponentHandler extends common_1.BaseHandler {
         for (let i = 0; i < paths.length; i++) {
             let component;
             try {
-                component = new paths[i].file();
+                component = this.callback(paths[i].file);
+                if (!component)
+                    continue;
             }
             catch (e) {
                 if (e instanceof Error && e.message === 'paths[i].file is not a constructor') {
@@ -138,7 +140,6 @@ class ComponentHandler extends common_1.BaseHandler {
                 continue;
             component.__filePath = paths[i].path;
             this.commands.push(component);
-            await this.__callback?.(component);
         }
     }
     async reload(path) {
@@ -201,5 +202,9 @@ class ComponentHandler extends common_1.BaseHandler {
             }
         }
     }
+    setHandlers({ callback }) {
+        this.callback = callback;
+    }
+    callback = (file) => new file();
 }
 exports.ComponentHandler = ComponentHandler;

package/lib/events/handler.d.ts

@@ -1,23 +1,14 @@
 import type { GatewayDispatchPayload } from 'discord-api-types/v10';
 import type { Client, WorkerClient } from '../client';
-import { BaseHandler, type MakeRequired, type OnFailCallback, type SnakeCase } from '../common';
+import { BaseHandler, type MakeRequired, type SnakeCase } from '../common';
 import type { ClientEvents } from '../events/hooks';
 import type { ClientEvent, ClientNameEvents } from './event';
-type EventValue = MakeRequired<ClientEvent, '__filePath'> & {
+export type EventValue = MakeRequired<ClientEvent, '__filePath'> & {
     fired?: boolean;
 };
-type GatewayEvents = Uppercase<SnakeCase<keyof ClientEvents>>;
-export interface EventHandlerLike {
-    runEvent: EventHandler['runEvent'];
-    execute: EventHandler['execute'];
-    load: EventHandler['load'];
-    reload: EventHandler['reload'];
-    reloadAll: EventHandler['reloadAll'];
-    values: EventHandler['values'];
-    onFail: EventHandler['onFail'];
-}
+export type GatewayEvents = Uppercase<SnakeCase<keyof ClientEvents>>;
 export declare class EventHandler extends BaseHandler {
-    onFail: OnFailCallback;
+    onFail: (event: GatewayEvents, err: unknown) => void;
     protected filter: (path: string) => boolean;
     values: Partial<Record<GatewayEvents, EventValue>>;
     load(eventsDir: string): Promise<void>;
@@ -25,5 +16,8 @@ export declare class EventHandler extends BaseHandler {
     runEvent(name: GatewayEvents, client: Client | WorkerClient, packet: any, shardId: number): Promise<void>;
     reload(name: ClientNameEvents): Promise<any>;
     reloadAll(): Promise<void>;
+    setHandlers({ callback }: {
+        callback: EventHandler['callback'];
+    }): void;
+    callback: (file: ClientEvent) => ClientEvent | false;
 }
-export {};