seyfert 1.2.3 → 1.3.0

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 {};

package/lib/events/handler.js

@@ -27,19 +27,20 @@ exports.EventHandler = void 0;
 const common_1 = require("../common");
 const RawEvents = __importStar(require("../events/hooks"));
 class EventHandler extends common_1.BaseHandler {
-    onFail = err => this.logger.warn('<Client>.events.onFail', err);
+    onFail = (event, err) => this.logger.warn('<Client>.events.onFail', err, event);
     filter = (path) => path.endsWith('.js') || (!path.endsWith('.d.ts') && path.endsWith('.ts'));
     values = {};
     async load(eventsDir) {
         for (const i of await this.loadFilesK(await this.getFiles(eventsDir))) {
-            const instance = i.file;
+            const instance = this.callback(i.file);
+            if (!instance)
+                continue;
             if (typeof instance?.run !== 'function') {
                 this.logger.warn(i.path.split(process.cwd()).slice(1).join(process.cwd()), 'Missing run function, use `export default {...}` syntax');
                 continue;
             }
             instance.__filePath = i.path;
             this.values[common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()] = instance;
-            await this.__callback?.(instance);
         }
     }
     async execute(name, ...args) {
@@ -95,7 +96,7 @@ class EventHandler extends common_1.BaseHandler {
             await Event.run(...[hook, client, shardId]);
         }
         catch (e) {
-            await this.onFail(e);
+            await this.onFail(name, e);
         }
     }
     async reload(name) {
@@ -114,5 +115,9 @@ class EventHandler extends common_1.BaseHandler {
             await this.reload(common_1.ReplaceRegex.camel(i));
         }
     }
+    setHandlers({ callback }) {
+        this.callback = callback;
+    }
+    callback = (file) => file;
 }
 exports.EventHandler = EventHandler;

package/lib/events/hooks/guild.d.ts

@@ -20,7 +20,7 @@ export declare const GUILD_BAN_REMOVE: (self: BaseClient, data: GatewayGuildBanR
     guildId: string;
 };
 export declare const GUILD_CREATE: (self: BaseClient, data: GatewayGuildCreateDispatchData) => Guild<"create">;
-export declare const GUILD_DELETE: (_self: BaseClient, data: GatewayGuildDeleteDispatchData) => Promise<import("discord-api-types/v10").APIUnavailableGuild>;
+export declare const GUILD_DELETE: (self: BaseClient, data: GatewayGuildDeleteDispatchData) => Promise<import("discord-api-types/v10").APIUnavailableGuild | Guild<"cached">>;
 export declare const GUILD_EMOJIS_UPDATE: (self: BaseClient, data: GatewayGuildEmojisUpdateDispatchData) => {
     emojis: GuildEmoji[];
     guildId: string;

package/lib/events/hooks/guild.js

@@ -19,8 +19,8 @@ const GUILD_CREATE = (self, data) => {
     return new structures_1.Guild(self, data);
 };
 exports.GUILD_CREATE = GUILD_CREATE;
-const GUILD_DELETE = async (_self, data) => {
-    return data;
+const GUILD_DELETE = async (self, data) => {
+    return (await self.cache.guilds?.get(data.id)) ?? data;
 };
 exports.GUILD_DELETE = GUILD_DELETE;
 const GUILD_EMOJIS_UPDATE = (self, data) => {

package/lib/events/hooks/message.d.ts

@@ -1,18 +1,19 @@
-import type { GatewayMessageCreateDispatchData, GatewayMessageDeleteBulkDispatchData, GatewayMessageDeleteDispatchData, GatewayMessageReactionAddDispatchData, GatewayMessageReactionRemoveAllDispatchData, GatewayMessageReactionRemoveDispatchData, GatewayMessageReactionRemoveEmojiDispatchData, GatewayMessageUpdateDispatchData } from 'discord-api-types/v10';
+import type { GatewayMessageCreateDispatchData, GatewayMessageDeleteBulkDispatchData, GatewayMessageDeleteDispatchData, GatewayMessagePollVoteDispatchData, GatewayMessageReactionAddDispatchData, GatewayMessageReactionRemoveAllDispatchData, GatewayMessageReactionRemoveDispatchData, GatewayMessageReactionRemoveEmojiDispatchData, GatewayMessageUpdateDispatchData } from 'discord-api-types/v10';
 import type { BaseClient } from '../../client/base';
 import { type MakeRequired, type PartialClass } from '../../common';
 import { Message } from '../../structures';
 export declare const MESSAGE_CREATE: (self: BaseClient, data: GatewayMessageCreateDispatchData) => Message;
-export declare const MESSAGE_DELETE: (_self: BaseClient, data: GatewayMessageDeleteDispatchData) => {
+export declare const MESSAGE_DELETE: (self: BaseClient, data: GatewayMessageDeleteDispatchData) => Promise<{
     id: string;
     channelId: string;
     guildId?: string | undefined;
-};
-export declare const MESSAGE_DELETE_BULK: (_self: BaseClient, data: GatewayMessageDeleteBulkDispatchData) => {
+}>;
+export declare const MESSAGE_DELETE_BULK: (self: BaseClient, data: GatewayMessageDeleteBulkDispatchData) => Promise<{
+    messages: import("../..").ReturnCache<Message | undefined>[];
     ids: string[];
-    channelId: string;
-    guildId?: string | undefined;
-};
+    channel_id: string;
+    guild_id?: string | undefined;
+}>;
 export declare const MESSAGE_REACTION_ADD: (_self: BaseClient, data: GatewayMessageReactionAddDispatchData) => {
     emoji: {
         roles?: string[] | undefined;
@@ -67,4 +68,21 @@ export declare const MESSAGE_REACTION_REMOVE_EMOJI: (_self: BaseClient, data: Ga
     messageId: string;
     guildId?: string | undefined;
 };
-export declare const MESSAGE_UPDATE: (self: BaseClient, data: GatewayMessageUpdateDispatchData) => MakeRequired<PartialClass<Message>, 'id' | 'channelId' | 'createdAt' | 'createdTimestamp' | 'rest' | 'cache' | 'api' | 'client'>;
+export declare const MESSAGE_UPDATE: (self: BaseClient, data: GatewayMessageUpdateDispatchData) => Promise<[
+    undefined | Message,
+    MakeRequired<PartialClass<Message>, 'id' | 'channelId' | 'createdAt' | 'createdTimestamp' | 'rest' | 'cache' | 'api' | 'client'>
+]>;
+export declare const MESSAGE_POLL_VOTE_ADD: (_: BaseClient, data: GatewayMessagePollVoteDispatchData) => {
+    userId: string;
+    channelId: string;
+    messageId: string;
+    guildId?: string | undefined;
+    answerId: number;
+};
+export declare const MESSAGE_POLL_VOTE_REMOVE: (_: BaseClient, data: GatewayMessagePollVoteDispatchData) => {
+    userId: string;
+    channelId: string;
+    messageId: string;
+    guildId?: string | undefined;
+    answerId: number;
+};

package/lib/events/hooks/message.js

@@ -1,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MESSAGE_UPDATE = exports.MESSAGE_REACTION_REMOVE_EMOJI = exports.MESSAGE_REACTION_REMOVE_ALL = exports.MESSAGE_REACTION_REMOVE = exports.MESSAGE_REACTION_ADD = exports.MESSAGE_DELETE_BULK = exports.MESSAGE_DELETE = exports.MESSAGE_CREATE = void 0;
+exports.MESSAGE_POLL_VOTE_REMOVE = exports.MESSAGE_POLL_VOTE_ADD = exports.MESSAGE_UPDATE = exports.MESSAGE_REACTION_REMOVE_EMOJI = exports.MESSAGE_REACTION_REMOVE_ALL = exports.MESSAGE_REACTION_REMOVE = exports.MESSAGE_REACTION_ADD = exports.MESSAGE_DELETE_BULK = exports.MESSAGE_DELETE = exports.MESSAGE_CREATE = void 0;
 const common_1 = require("../../common");
 const structures_1 = require("../../structures");
 const MESSAGE_CREATE = (self, data) => {
     return new structures_1.Message(self, data);
 };
 exports.MESSAGE_CREATE = MESSAGE_CREATE;
-const MESSAGE_DELETE = (_self, data) => {
-    return (0, common_1.toCamelCase)(data);
+const MESSAGE_DELETE = async (self, data) => {
+    return (await self.cache.messages?.get(data.id)) ?? (0, common_1.toCamelCase)(data);
 };
 exports.MESSAGE_DELETE = MESSAGE_DELETE;
-const MESSAGE_DELETE_BULK = (_self, data) => {
-    return (0, common_1.toCamelCase)(data);
+const MESSAGE_DELETE_BULK = async (self, data) => {
+    return {
+        ...data,
+        messages: await Promise.all(data.ids.map(id => self.cache.messages?.get(id))),
+    };
 };
 exports.MESSAGE_DELETE_BULK = MESSAGE_DELETE_BULK;
 const MESSAGE_REACTION_ADD = (_self, data) => {
@@ -31,7 +34,15 @@ const MESSAGE_REACTION_REMOVE_EMOJI = (_self, data) => {
     return (0, common_1.toCamelCase)(data);
 };
 exports.MESSAGE_REACTION_REMOVE_EMOJI = MESSAGE_REACTION_REMOVE_EMOJI;
-const MESSAGE_UPDATE = (self, data) => {
-    return new structures_1.Message(self, data);
+const MESSAGE_UPDATE = async (self, data) => {
+    return [await self.cache.messages?.get(data.id), new structures_1.Message(self, data)];
 };
 exports.MESSAGE_UPDATE = MESSAGE_UPDATE;
+const MESSAGE_POLL_VOTE_ADD = (_, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.MESSAGE_POLL_VOTE_ADD = MESSAGE_POLL_VOTE_ADD;
+const MESSAGE_POLL_VOTE_REMOVE = (_, data) => {
+    return (0, common_1.toCamelCase)(data);
+};
+exports.MESSAGE_POLL_VOTE_REMOVE = MESSAGE_POLL_VOTE_REMOVE;

package/lib/langs/handler.d.ts

@@ -1,13 +1,5 @@
 import type { LocaleString } from 'discord-api-types/v10';
 import { BaseHandler } from '../common';
-export interface LangsHandlerLike {
-    getKey: LangsHandler['getKey'];
-    load: LangsHandler['load'];
-    values: LangsHandler['values'];
-    aliases: LangsHandler['aliases'];
-    get: LangsHandler['get'];
-    defaultLang?: LangsHandler['defaultLang'];
-}
 export declare class LangsHandler extends BaseHandler {
     values: Partial<Record<string, any>>;
     protected filter: (path: string) => boolean;
@@ -19,4 +11,8 @@ export declare class LangsHandler extends BaseHandler {
         get(locale?: string | undefined): import("..").DefaultLocale;
     };
     load(dir: string): Promise<void>;
+    setHandlers({ callback }: {
+        callback: LangsHandler['callback'];
+    }): void;
+    callback: (_locale: string, file: Record<string, any>) => Record<string, any> | false;
 }

package/lib/langs/handler.js

@@ -34,9 +34,14 @@ class LangsHandler extends common_1.BaseHandler {
         const files = await this.loadFilesK(await this.getFiles(dir));
         for (const i of files) {
             const locale = i.name.split('.').slice(0, -1).join('.');
-            this.values[locale] = i.file;
-            await this.__callback?.(locale, i.file);
+            const result = this.callback(locale, i.file);
+            if (result)
+                this.values[locale] = result;
         }
     }
+    setHandlers({ callback }) {
+        this.callback = callback;
+    }
+    callback = (_locale, file) => file;
 }
 exports.LangsHandler = LangsHandler;

package/lib/structures/AutoModerationRule.d.ts

@@ -8,16 +8,16 @@ export declare class AutoModerationRule extends DiscordBase<APIAutoModerationRul
     constructor(client: UsingClient, data: APIAutoModerationRule);
     fetchCreator(force?: boolean): Promise<import("./GuildMember").GuildMember>;
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
-    fetch(): Promise<APIAutoModerationRule>;
-    edit(body: ObjectToLower<RESTPatchAPIAutoModerationRuleJSONBody>, reason?: string): Promise<APIAutoModerationRule>;
+    fetch(): Promise<AutoModerationRule>;
+    edit(body: ObjectToLower<RESTPatchAPIAutoModerationRuleJSONBody>, reason?: string): Promise<AutoModerationRule>;
     delete(reason?: string): Promise<never>;
     static methods({ client, guildId }: MethodContext<{
         guildId: string;
     }>): {
-        list: () => Promise<import("discord-api-types/v10").RESTGetAPIAutoModerationRulesResult>;
-        create: (body: RESTPostAPIAutoModerationRuleJSONBody) => Promise<APIAutoModerationRule>;
+        list: () => Promise<AutoModerationRule[]>;
+        create: (body: RESTPostAPIAutoModerationRuleJSONBody) => Promise<AutoModerationRule>;
         delete: (ruleId: string, reason?: string) => Promise<never>;
-        fetch: (ruleId: string) => Promise<APIAutoModerationRule>;
-        edit: (ruleId: string, body: RESTPatchAPIAutoModerationRuleJSONBody, reason?: string) => Promise<APIAutoModerationRule>;
+        fetch: (ruleId: string) => Promise<AutoModerationRule>;
+        edit: (ruleId: string, body: RESTPatchAPIAutoModerationRuleJSONBody, reason?: string) => Promise<AutoModerationRule>;
     };
 }

package/lib/structures/Guild.d.ts

@@ -1,9 +1,11 @@
 import type { APIGuild, GatewayGuildCreateDispatchData } from 'discord-api-types/v10';
 import type { UsingClient } from '../commands';
 import type { ObjectToLower, StructPropState, StructStates, ToClass } from '../common/types/util';
+import { AutoModerationRule } from './AutoModerationRule';
 import { GuildEmoji } from './GuildEmoji';
 import { GuildMember } from './GuildMember';
 import { GuildRole } from './GuildRole';
+import { GuildTemplate } from './GuildTemplate';
 import { Sticker } from './Sticker';
 import { BaseGuild } from './extra/BaseGuild';
 import type { DiscordBase } from './extra/DiscordBase';
@@ -23,12 +25,12 @@ export declare class Guild<State extends StructStates = 'api'> extends Guild_bas
     get maxEmojis(): MaxEmojis;
     fetchOwner(force?: boolean): Promise<null> | Promise<GuildMember>;
     templates: {
-        fetch: (code: string) => Promise<import("discord-api-types/v10").APITemplate>;
-        list: () => Promise<import("discord-api-types/v10").RESTGetAPIGuildTemplatesResult>;
-        create: (body: import("discord-api-types/v10").RESTPostAPIGuildTemplatesJSONBody) => Promise<import("discord-api-types/v10").APITemplate>;
-        sync: (code: string) => Promise<import("discord-api-types/v10").APITemplate>;
-        edit: (code: string, body: import("discord-api-types/utils/internals").AddUndefinedToPossiblyUndefinedPropertiesOfInterface<Partial<import("discord-api-types/v10").RESTPostAPIGuildTemplatesJSONBody>>) => Promise<import("discord-api-types/v10").APITemplate>;
-        delete: (code: string) => Promise<import("discord-api-types/v10").APITemplate>;
+        fetch: (code: string) => Promise<GuildTemplate>;
+        list: () => Promise<GuildTemplate[]>;
+        create: (body: import("discord-api-types/v10").RESTPostAPIGuildTemplatesJSONBody) => Promise<GuildTemplate>;
+        sync: (code: string) => Promise<GuildTemplate>;
+        edit: (code: string, body: import("discord-api-types/utils/internals").AddUndefinedToPossiblyUndefinedPropertiesOfInterface<Partial<import("discord-api-types/v10").RESTPostAPIGuildTemplatesJSONBody>>) => Promise<GuildTemplate>;
+        delete: (code: string) => Promise<GuildTemplate>;
     };
     stickers: {
         list: () => Promise<Sticker[]>;
@@ -49,17 +51,17 @@ export declare class Guild<State extends StructStates = 'api'> extends Guild_bas
         list: (query?: import("discord-api-types/v10").RESTGetAPIGuildMembersQuery | undefined, force?: boolean) => Promise<GuildMember[]>;
     };
     moderationRules: {
-        list: () => Promise<import("discord-api-types/v10").RESTGetAPIAutoModerationRulesResult>;
-        create: (body: import("discord-api-types/v10").RESTPostAPIAutoModerationRuleJSONBody) => Promise<import("discord-api-types/v10").APIAutoModerationRule>;
+        list: () => Promise<AutoModerationRule[]>;
+        create: (body: import("discord-api-types/v10").RESTPostAPIAutoModerationRuleJSONBody) => Promise<AutoModerationRule>;
         delete: (ruleId: string, reason?: string | undefined) => Promise<never>;
-        fetch: (ruleId: string) => Promise<import("discord-api-types/v10").APIAutoModerationRule>;
-        edit: (ruleId: string, body: import("discord-api-types/v10").RESTPatchAPIAutoModerationRuleJSONBody, reason?: string | undefined) => Promise<import("discord-api-types/v10").APIAutoModerationRule>;
+        fetch: (ruleId: string) => Promise<AutoModerationRule>;
+        edit: (ruleId: string, body: import("discord-api-types/v10").RESTPatchAPIAutoModerationRuleJSONBody, reason?: string | undefined) => Promise<AutoModerationRule>;
     };
     roles: {
-        create: (body: import("discord-api-types/v10").RESTPostAPIGuildRoleJSONBody) => Promise<any>;
+        create: (body: import("discord-api-types/v10").RESTPostAPIGuildRoleJSONBody) => Promise<GuildRole>;
         list: (force?: boolean) => Promise<GuildRole[]>;
-        edit: (roleId: string, body: import("discord-api-types/v10").RESTPatchAPIGuildRoleJSONBody, reason?: string | undefined) => Promise<any>;
-        delete: (roleId: string, reason?: string | undefined) => Promise<void | undefined>;
+        edit: (roleId: string, body: import("discord-api-types/v10").RESTPatchAPIGuildRoleJSONBody, reason?: string | undefined) => Promise<GuildRole>;
+        delete: (roleId: string, reason?: string | undefined) => Promise<GuildRole>;
         editPositions: (body: import("discord-api-types/v10").RESTPatchAPIGuildRolePositionsJSONBody) => Promise<GuildRole[]>;
     };
     channels: {

package/lib/structures/GuildRole.d.ts

@@ -10,15 +10,15 @@ export declare class GuildRole extends DiscordBase {
     permissions: PermissionsBitField;
     constructor(client: UsingClient, data: APIRole, guildId: string);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
-    edit(body: RESTPatchAPIGuildRoleJSONBody, reason?: string): Promise<any>;
-    delete(reason?: string): Promise<void | undefined>;
+    edit(body: RESTPatchAPIGuildRoleJSONBody, reason?: string): Promise<GuildRole>;
+    delete(reason?: string): Promise<GuildRole>;
     static methods(ctx: MethodContext<{
         guildId: string;
     }>): {
-        create: (body: RESTPostAPIGuildRoleJSONBody) => Promise<any>;
+        create: (body: RESTPostAPIGuildRoleJSONBody) => Promise<GuildRole>;
         list: (force?: boolean) => Promise<GuildRole[]>;
-        edit: (roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string) => Promise<any>;
-        delete: (roleId: string, reason?: string) => Promise<void | undefined>;
+        edit: (roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string) => Promise<GuildRole>;
+        delete: (roleId: string, reason?: string) => Promise<GuildRole>;
         editPositions: (body: RESTPatchAPIGuildRolePositionsJSONBody) => Promise<GuildRole[]>;
     };
 }

package/lib/structures/GuildTemplate.d.ts

@@ -7,18 +7,18 @@ export interface GuildTemplate extends Base, ObjectToLower<APITemplate> {
 export declare class GuildTemplate extends Base {
     constructor(client: UsingClient, data: APITemplate);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
-    fetch(): Promise<APITemplate>;
-    sync(): Promise<APITemplate>;
-    edit(body: RESTPatchAPIGuildTemplateJSONBody): Promise<APITemplate>;
-    delete(): Promise<APITemplate>;
+    fetch(): Promise<GuildTemplate>;
+    sync(): Promise<GuildTemplate>;
+    edit(body: RESTPatchAPIGuildTemplateJSONBody): Promise<GuildTemplate>;
+    delete(): Promise<GuildTemplate>;
     static methods(ctx: MethodContext<{
         guildId: string;
     }>): {
-        fetch: (code: string) => Promise<APITemplate>;
-        list: () => Promise<import("discord-api-types/v10").RESTGetAPIGuildTemplatesResult>;
-        create: (body: RESTPostAPIGuildTemplatesJSONBody) => Promise<APITemplate>;
-        sync: (code: string) => Promise<APITemplate>;
-        edit: (code: string, body: RESTPatchAPIGuildTemplateJSONBody) => Promise<APITemplate>;
-        delete: (code: string) => Promise<APITemplate>;
+        fetch: (code: string) => Promise<GuildTemplate>;
+        list: () => Promise<GuildTemplate[]>;
+        create: (body: RESTPostAPIGuildTemplatesJSONBody) => Promise<GuildTemplate>;
+        sync: (code: string) => Promise<GuildTemplate>;
+        edit: (code: string, body: RESTPatchAPIGuildTemplateJSONBody) => Promise<GuildTemplate>;
+        delete: (code: string) => Promise<GuildTemplate>;
     };
 }

package/lib/structures/Interaction.d.ts

@@ -55,11 +55,11 @@ export declare class Interaction<FromGuild extends boolean = boolean, Type exten
     write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void>>;
     modal(body: ModalCreateBodyRequest): Promise<void>;
     editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void>>;
-    editMessage(messageId: string, body: InteractionMessageUpdateBodyRequest): Promise<Message>;
-    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message>;
+    editMessage(messageId: string, body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessage>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessage>;
     deleteResponse(): Promise<void | undefined>;
     deleteMessage(messageId: string): Promise<void | undefined>;
-    createResponse({ files, ...body }: MessageWebhookCreateBodyRequest): Promise<Message>;
+    followup(body: MessageWebhookCreateBodyRequest): Promise<WebhookMessage>;
 }
 export declare class ApplicationCommandInteraction<FromGuild extends boolean = boolean, Type extends APIApplicationCommandInteraction = APIApplicationCommandInteraction> extends Interaction<FromGuild, Type> {
     type: ApplicationCommandType;

package/lib/structures/Interaction.js

@@ -55,19 +55,21 @@ class BaseInteraction extends DiscordBase_1.DiscordBase {
             case v10_1.InteractionResponseType.DeferredChannelMessageWithSource:
                 return body;
             case v10_1.InteractionResponseType.ChannelMessageWithSource:
-            case v10_1.InteractionResponseType.UpdateMessage:
+            case v10_1.InteractionResponseType.UpdateMessage: {
+                const poll = body.poll;
                 return {
                     type: body.type,
-                    // @ts-ignore
+                    //@ts-ignore
                     data: {
-                        // @ts-ignore
                         ...(body.data ?? {}),
-                        // @ts-ignore
+                        //@ts-ignore
                         components: body.data?.components?.map(x => (x instanceof builders_1.ActionRow ? x.toJSON() : x)) ?? undefined,
                         embeds: body.data?.embeds?.map(x => (x instanceof builders_1.Embed ? x.toJSON() : x)) ?? undefined,
                         attachments: body.data?.attachments?.map((x, i) => ({ id: i, ...(0, builders_1.resolveAttachment)(x) })) ?? undefined,
+                        poll: poll ? (poll instanceof builders_1.PollBuilder ? poll.toJSON() : poll) : undefined,
                     },
                 };
+            }
             case v10_1.InteractionResponseType.Modal:
                 return {
                     type: body.type,
@@ -87,38 +89,34 @@ class BaseInteraction extends DiscordBase_1.DiscordBase {
         }
     }
     static transformBody(body) {
+        const poll = body.poll;
         return {
             ...body,
             components: body.components?.map(x => (x instanceof builders_1.ActionRow ? x.toJSON() : x)) ?? undefined,
             embeds: body?.embeds?.map(x => (x instanceof builders_1.Embed ? x.toJSON() : x)) ?? undefined,
-            // attachments: body.attachments?.map((x, i) => ({ id: i, ...resolveAttachment(x) })) ?? undefined,
+            poll: poll ? (poll instanceof builders_1.PollBuilder ? poll.toJSON() : poll) : undefined,
         };
     }
-    matchReplied(data, type, filesParsed) {
-        this.replied = (this.__reply ?? this.api.interactions(this.id)(this.token).callback.post)({
-            // @ts-expect-error
-            body: BaseInteraction.transformBodyRequest({ data, type }),
-            files: filesParsed,
-        }).then(() => (this.replied = true));
+    async matchReplied(body) {
+        if (this.__reply) {
+            //@ts-expect-error
+            const { files, ...data } = body.data ?? {};
+            return (this.replied = this.__reply({
+                body: BaseInteraction.transformBodyRequest({ data, type: body.type }),
+                files: files ? await (0, builders_1.resolveFiles)(files) : undefined,
+            }).then(() => (this.replied = true)));
+        }
+        return (this.replied = this.client.interactions.reply(this.id, this.token, body).then(() => (this.replied = true)));
     }
     async reply(body) {
         if (this.replied) {
             throw new Error('Interaction already replied');
         }
+        await this.matchReplied(body);
         // @ts-expect-error
-        if (body.data?.files) {
-            // @ts-expect-error
-            const { files, ...rest } = body.data;
-            this.matchReplied(rest, body.type, await (0, builders_1.resolveFiles)(files));
-            // @ts-expect-error
-        }
-        else
-            this.matchReplied(body.data, body.type);
-        // @ts-expect-error
-        if (body.data instanceof builders_1.Modal)
+        if (body.data instanceof builders_1.Modal && body.data.__exec)
             // @ts-expect-error
             this.client.components.modals.set(this.user.id, body.data.__exec);
-        await this.replied;
     }
     deferReply(flags) {
         return this.reply({
@@ -191,7 +189,7 @@ class AutocompleteInteraction extends BaseInteraction {
 exports.AutocompleteInteraction = AutocompleteInteraction;
 class Interaction extends BaseInteraction {
     fetchMessage(messageId) {
-        return this.client.webhooks.fetchMessage(this.applicationId, this.token, messageId);
+        return this.client.interactions.fetchResponse(this.token, messageId);
     }
     fetchResponse() {
         return this.fetchMessage('@original');
@@ -218,16 +216,8 @@ class Interaction extends BaseInteraction {
         }
         return this.write(body, fetchReply);
     }
-    async editMessage(messageId, body) {
-        const { files, ...data } = body;
-        const apiMessage = await this.api
-            .webhooks(this.applicationId)(this.token)
-            .messages(messageId)
-            .patch({
-            body: BaseInteraction.transformBody(data),
-            files: files ? await (0, builders_1.resolveFiles)(files) : undefined,
-        });
-        return new Message_1.Message(this.client, apiMessage);
+    editMessage(messageId, body) {
+        return this.client.interactions.editMessage(this.token, messageId, body);
     }
     editResponse(body) {
         return this.editMessage('@original', body);
@@ -236,21 +226,10 @@ class Interaction extends BaseInteraction {
         return this.deleteMessage('@original');
     }
     deleteMessage(messageId) {
-        return this.api
-            .webhooks(this.applicationId)(this.token)
-            .messages(messageId)
-            .delete()
-            .then(() => this.client.components?.onMessageDelete(messageId === '@original' ? this.id : messageId));
-    }
-    async createResponse({ files, ...body }) {
-        files ??= files ? await (0, builders_1.resolveFiles)(files) : undefined;
-        const apiMessage = await this.api
-            .webhooks(this.applicationId)(this.token)
-            .post({
-            body: BaseInteraction.transformBody(body),
-            files: files,
-        });
-        return new Message_1.Message(this.client, apiMessage);
+        return this.client.interactions.deleteResponse(this.id, this.token, messageId);
+    }
+    async followup(body) {
+        return this.client.interactions.followup(this.token, body);
     }
 }
 exports.Interaction = Interaction;

package/lib/structures/Message.d.ts

@@ -10,8 +10,9 @@ import { GuildMember } from './GuildMember';
 import { User } from './User';
 import type { MessageWebhookMethodEditParams, MessageWebhookMethodWriteParams } from './Webhook';
 import { DiscordBase } from './extra/DiscordBase';
+import { Poll } from '..';
 export type MessageData = APIMessage | GatewayMessageCreateDispatchData;
-export interface BaseMessage extends DiscordBase, ObjectToLower<Omit<MessageData, 'timestamp' | 'author' | 'mentions' | 'components'>> {
+export interface BaseMessage extends DiscordBase, ObjectToLower<Omit<MessageData, 'timestamp' | 'author' | 'mentions' | 'components' | 'poll'>> {
 }
 export declare class BaseMessage extends DiscordBase {
     guildId: string | undefined;
@@ -19,6 +20,7 @@ export declare class BaseMessage extends DiscordBase {
     author: User;
     member?: GuildMember;
     components: MessageActionRowComponent<ActionRowMessageComponents>[];
+    poll?: Poll;
     mentions: {
         roles: string[];
         channels: APIChannelMention[];
@@ -27,7 +29,7 @@ export declare class BaseMessage extends DiscordBase {
     constructor(client: UsingClient, data: MessageData);
     get user(): User;
     createComponentCollector(options?: ListenerOptions): {
-        run<T extends import("./Interaction").StringSelectMenuInteraction<string[]> | import("./Interaction").ComponentInteraction<boolean, import("discord-api-types/v10").APIMessageComponentInteraction> = import("./Interaction").StringSelectMenuInteraction<string[]> | import("./Interaction").ComponentInteraction<boolean, import("discord-api-types/v10").APIMessageComponentInteraction>>(customId: string | RegExp | string[], callback: import("../builders").ComponentCallback<T>): any;
+        run<T extends import("./Interaction").StringSelectMenuInteraction<string[]> | import("./Interaction").ComponentInteraction<boolean, import("discord-api-types/v10").APIMessageComponentInteraction> = import("./Interaction").StringSelectMenuInteraction<string[]> | import("./Interaction").ComponentInteraction<boolean, import("discord-api-types/v10").APIMessageComponentInteraction>>(customId: string | RegExp | string[], callback: import("..").ComponentCallback<T>): any;
         stop(reason?: string | undefined): any;
     };
     get url(): string;
@@ -36,7 +38,7 @@ export declare class BaseMessage extends DiscordBase {
     react(emoji: EmojiResolvable): Promise<void>;
     private patch;
 }
-export interface Message extends BaseMessage, ObjectToLower<Omit<MessageData, 'timestamp' | 'author' | 'mentions' | 'components'>> {
+export interface Message extends BaseMessage, ObjectToLower<Omit<MessageData, 'timestamp' | 'author' | 'mentions' | 'components' | 'poll'>> {
 }
 export declare class Message extends BaseMessage {
     constructor(client: UsingClient, data: MessageData);