seyfert 1.0.1 → 1.1.1

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;

package/lib/common/shorters/webhook.js

@@ -5,65 +5,120 @@ const builders_1 = require("../../builders");
 const structures_1 = require("../../structures");
 const base_1 = require("./base");
 class WebhookShorter extends base_1.BaseShorter {
-    get webhooks() {
-        return {
-            delete: (webhookId, { token, reason }) => {
-                if (token) {
-                    return this.client.proxy.webhooks(webhookId)(token).delete({ reason, auth: false });
-                }
-                return this.client.proxy.webhooks(webhookId).delete({ reason });
-            },
-            edit: (webhookId, body, { token, reason }) => {
-                if (token) {
-                    return this.client.proxy.webhooks(webhookId)(token).patch({ body, reason, auth: false });
-                }
-                return this.client.proxy.webhooks(webhookId).patch({ body, reason });
-            },
-            fetch: async (webhookId, token) => {
-                let webhook;
-                if (token) {
-                    webhook = await this.client.proxy.webhooks(webhookId)(token).get({ auth: false });
-                }
-                else {
-                    webhook = await this.client.proxy.webhooks(webhookId).get();
-                }
-                return new structures_1.Webhook(this.client, webhook);
-            },
-            messages: this.messages,
-        };
+    async create(channelId, body) {
+        const webhook = await this.client.proxy.channels(channelId).webhooks.post({
+            body,
+        });
+        return new structures_1.Webhook(this.client, webhook);
     }
-    get messages() {
-        return {
-            write: async (webhookId, token, { body: data, ...payload }) => {
-                const { files, ...body } = data;
-                const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
-                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
-                return this.client.proxy
-                    .webhooks(webhookId)(token)
-                    .post({ ...payload, files: parsedFiles, body: transformedBody })
-                    .then(m => (m?.id ? new structures_1.WebhookMessage(this.client, m, webhookId, token) : null));
-            },
-            edit: async (webhookId, token, { messageId, body: data, ...json }) => {
-                const { files, ...body } = data;
-                const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
-                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
-                return this.client.proxy
-                    .webhooks(webhookId)(token)
-                    .messages(messageId)
-                    .patch({ ...json, auth: false, files: parsedFiles, body: transformedBody })
-                    .then(m => new structures_1.WebhookMessage(this.client, m, webhookId, token));
-            },
-            delete: async (webhookId, token, messageId, reason) => {
-                return this.client.proxy.webhooks(webhookId)(token).messages(messageId).delete({ reason });
-            },
-            fetch: async (webhookId, token, messageId, threadId) => {
-                const message = await this.client.proxy
-                    .webhooks(webhookId)(token)
-                    .messages(messageId)
-                    .get({ auth: false, query: { threadId } });
-                return message ? new structures_1.WebhookMessage(this.client, message, webhookId, token) : undefined;
-            },
-        };
+    /**
+     * 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, options) {
+        if (options.token) {
+            return this.client.proxy.webhooks(webhookId)(options.token).delete({ reason: options.reason, auth: false });
+        }
+        return this.client.proxy.webhooks(webhookId).delete({ reason: options.reason });
+    }
+    /**
+     * 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, 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).patch({ body, reason: options.reason });
+    }
+    /**
+     * 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.
+     */
+    async fetch(webhookId, token) {
+        let webhook;
+        if (token) {
+            webhook = await this.client.proxy.webhooks(webhookId)(token).get({ auth: false });
+        }
+        else {
+            webhook = await this.client.proxy.webhooks(webhookId).get();
+        }
+        return new structures_1.Webhook(this.client, 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.
+     */
+    async writeMessage(webhookId, token, { body: data, ...payload }) {
+        const { files, ...body } = data;
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
+        const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        return this.client.proxy
+            .webhooks(webhookId)(token)
+            .post({ ...payload, files: parsedFiles, body: transformedBody })
+            .then(m => (m?.id ? new structures_1.WebhookMessage(this.client, m, webhookId, token) : 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.
+     */
+    async editMessage(webhookId, token, { messageId, body: data, ...json }) {
+        const { files, ...body } = data;
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
+        const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        return this.client.proxy
+            .webhooks(webhookId)(token)
+            .messages(messageId)
+            .patch({ ...json, auth: false, files: parsedFiles, body: transformedBody })
+            .then(m => new structures_1.WebhookMessage(this.client, m, webhookId, token));
+    }
+    /**
+     * 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, token, messageId, reason) {
+        return this.client.proxy.webhooks(webhookId)(token).messages(messageId).delete({ reason });
+    }
+    /**
+     * 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.
+     */
+    async fetchMessage(webhookId, token, messageId, threadId) {
+        const message = await this.client.proxy
+            .webhooks(webhookId)(token)
+            .messages(messageId)
+            .get({ auth: false, query: { threadId } });
+        return message ? new structures_1.WebhookMessage(this.client, message, webhookId, token) : undefined;
+    }
+    async listFromGuild(guildId) {
+        const webhooks = await this.client.proxy.guilds(guildId).webhooks.get();
+        return webhooks.map(webhook => new structures_1.Webhook(this.client, webhook));
+    }
+    async listFromChannel(channelId) {
+        const webhooks = await this.client.proxy.channels(channelId).webhooks.get();
+        return webhooks.map(webhook => new structures_1.Webhook(this.client, webhook));
     }
 }
 exports.WebhookShorter = WebhookShorter;

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

@@ -1,9 +1,9 @@
 import type { Identify } from '..';
 import type { ImageURLOptions } from '../../api';
-import type { BaseClient } from '../../client/base';
+import type { UsingClient } from '../../commands';
 export type ImageOptions = ImageURLOptions;
 export type MethodContext<T = {}> = Identify<{
-    client: BaseClient;
+    client: UsingClient;
 } & T>;
 export type MessageWebhookPayload<Body, Extra = {}> = Identify<{
     body: Body;

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

@@ -34,6 +34,8 @@ export type Identify<T> = T extends infer U ? {
 } : never;
 export type TypeArray<T> = T | T[];
 export type When<T extends boolean, A, B = never> = T extends true ? A : B;
+export type AuxIsStrictlyUndefined<T> = T extends undefined | null | never | void ? true : false;
+export type IsStrictlyUndefined<T> = AuxIsStrictlyUndefined<T> extends true ? true : AuxIsStrictlyUndefined<T> extends false ? false : false;
 export type If<T extends boolean, A, B = null> = T extends true ? A : B extends null ? A | null : B;
 export type PickPartial<T, K extends keyof T> = {
     [P in keyof T]?: T[P] | undefined;
@@ -88,4 +90,5 @@ export type AtLeastOne<T, U = {
     [K in keyof T]: Pick<T, K>;
 }> = Partial<T> & U[keyof U];
 export type FlatObjectKeys<T extends Record<string, any>, Key = keyof T> = Key extends string ? T[Key] extends Record<string, unknown> ? `${Key}.${FlatObjectKeys<T[Key]>}` : T[Key] extends string ? `${Key}` : never : never;
+export type Awaitable<V> = Promise<V> | V;
 export {};

package/lib/components/handler.d.ts

@@ -1,33 +1,52 @@
 /// <reference types="node" />
 import type { ComponentCallback, ListenerOptions, ModalSubmitCallback } from '../builders/types';
-import type { BaseClient } from '../client/base';
 import { LimitedCollection } from '../collection';
+import type { UsingClient } from '../commands';
 import { BaseHandler, type Logger, type OnFailCallback } from '../common';
 import type { ComponentInteraction, ModalSubmitInteraction } from '../structures';
 import { ComponentCommand, ModalCommand } from './command';
 type COMPONENTS = {
-    components: Partial<Record<string, ComponentCallback>>;
+    components: {
+        match: string | string[] | RegExp;
+        callback: ComponentCallback;
+    }[];
     options?: ListenerOptions;
     messageId?: string;
     idle?: NodeJS.Timeout;
     timeout?: NodeJS.Timeout;
-    __run: (customId: string, callback: ComponentCallback) => any;
+    __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: BaseClient;
-    protected onFail?: OnFailCallback;
+    protected client: UsingClient;
+    onFail: OnFailCallback;
     readonly values: Map<string, COMPONENTS>;
     readonly modals: LimitedCollection<string, ModalSubmitCallback>;
     readonly commands: (ComponentCommand | ModalCommand)[];
     protected filter: (path: string) => boolean;
-    constructor(logger: Logger, client: BaseClient);
-    set OnFail(cb: OnFailCallback);
+    constructor(logger: Logger, client: UsingClient);
     createComponentCollector(messageId: string, options?: ListenerOptions): {
-        run: (customId: string, callback: ComponentCallback) => any;
+        run: (customId: string | RegExp | string[], callback: ComponentCallback) => any;
         stop: (reason?: string) => void;
     };
     onComponent(id: string, interaction: ComponentInteraction): Promise<void>;
-    hasComponent(id: string, customId: string): ComponentCallback | undefined;
+    hasComponent(id: string, customId: string): boolean;
     resetTimeouts(id: string): void;
     hasModal(interaction: ModalSubmitInteraction): boolean;
     onModalSubmit(interaction: ModalSubmitInteraction): any;

package/lib/components/handler.js

@@ -6,7 +6,7 @@ const common_1 = require("../common");
 const command_1 = require("./command");
 class ComponentHandler extends common_1.BaseHandler {
     client;
-    onFail;
+    onFail = err => this.logger.warn('<Client>.components.onFail', err);
     values = new Map();
     // 10 minutes timeout, because discord dont send an event when the user cancel the modal
     modals = new collection_1.LimitedCollection({ expire: 60e3 * 10 });
@@ -16,12 +16,9 @@ class ComponentHandler extends common_1.BaseHandler {
         super(logger);
         this.client = client;
     }
-    set OnFail(cb) {
-        this.onFail = cb;
-    }
     createComponentCollector(messageId, options = {}) {
         this.values.set(messageId, {
-            components: {},
+            components: [],
             options,
             idle: options.idle
                 ? setTimeout(() => {
@@ -41,7 +38,10 @@ class ComponentHandler extends common_1.BaseHandler {
                 : undefined,
             __run: (customId, callback) => {
                 if (this.values.has(messageId)) {
-                    this.values.get(messageId).components[customId] = callback;
+                    this.values.get(messageId).components.push({
+                        callback,
+                        match: customId,
+                    });
                 }
             },
         });
@@ -57,7 +57,13 @@ class ComponentHandler extends common_1.BaseHandler {
     }
     async onComponent(id, interaction) {
         const row = this.values.get(id);
-        const component = row?.components?.[interaction.customId];
+        const component = row?.components?.find(x => {
+            if (typeof x.match === 'string')
+                return x.match === interaction.customId;
+            if (Array.isArray(x.match))
+                return x.match.includes(interaction.customId);
+            return interaction.customId.match(x.match);
+        });
         if (!component)
             return;
         if (row.options?.filter) {
@@ -65,7 +71,7 @@ class ComponentHandler extends common_1.BaseHandler {
                 return;
         }
         row.idle?.refresh();
-        await component(interaction, reason => {
+        await component.callback(interaction, reason => {
             row.options?.onStop?.(reason ?? 'stop');
             this.deleteValue(id);
         }, () => {
@@ -73,7 +79,13 @@ class ComponentHandler extends common_1.BaseHandler {
         });
     }
     hasComponent(id, customId) {
-        return this.values.get(id)?.components?.[customId];
+        return (this.values.get(id)?.components?.some(x => {
+            if (typeof x.match === 'string')
+                return x.match === customId;
+            if (Array.isArray(x.match))
+                return x.match.includes(customId);
+            return customId.match(x.match);
+        }) ?? false);
     }
     resetTimeouts(id) {
         const listener = this.values.get(id);
@@ -124,9 +136,12 @@ class ComponentHandler extends common_1.BaseHandler {
                 continue;
             component.__filePath = paths[i].path;
             this.commands.push(component);
+            await this.__callback?.(component);
         }
     }
     async reload(path) {
+        if (!this.client.components)
+            return;
         const component = this.client.components.commands.find(x => x.__filePath?.endsWith(`${path}.js`) ||
             x.__filePath?.endsWith(`${path}.ts`) ||
             x.__filePath?.endsWith(path) ||
@@ -145,6 +160,8 @@ class ComponentHandler extends common_1.BaseHandler {
         return imported;
     }
     async reloadAll() {
+        if (!this.client.components)
+            return;
         for (const i of this.client.components.commands) {
             if (!i.__filePath)
                 return this.logger.warn('Unknown command dont have __filePath property', i);
@@ -162,7 +179,7 @@ class ComponentHandler extends common_1.BaseHandler {
                 }
             }
             catch (e) {
-                await this.onFail?.(e);
+                await this.onFail(e);
             }
         }
     }
@@ -175,7 +192,7 @@ class ComponentHandler extends common_1.BaseHandler {
                 }
             }
             catch (e) {
-                await this.onFail?.(e);
+                await this.onFail(e);
             }
         }
     }

package/lib/events/handler.d.ts

@@ -6,11 +6,19 @@ 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 declare class EventHandler extends BaseHandler {
-    protected onFail: OnFailCallback;
+    onFail: OnFailCallback;
     protected filter: (path: string) => boolean;
     values: Partial<Record<GatewayEvents, EventValue>>;
-    set OnFail(cb: OnFailCallback);
     load(eventsDir: string): Promise<void>;
     execute(name: GatewayEvents, ...args: [GatewayDispatchPayload, Client<true> | WorkerClient<true>, number]): Promise<void>;
     runEvent(name: GatewayEvents, client: Client | WorkerClient, packet: any, shardId: number): Promise<void>;

package/lib/events/handler.js

@@ -27,12 +27,9 @@ 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 = err => this.logger.warn('<Client>.events.onFail', err);
     filter = (path) => path.endsWith('.js') || (!path.endsWith('.d.ts') && path.endsWith('.ts'));
     values = {};
-    set OnFail(cb) {
-        this.onFail = cb;
-    }
     async load(eventsDir) {
         for (const i of await this.loadFilesK(await this.getFiles(eventsDir))) {
             const instance = i.file;
@@ -42,6 +39,7 @@ class EventHandler extends common_1.BaseHandler {
             }
             instance.__filePath = i.path;
             this.values[common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()] = instance;
+            await this.__callback?.(instance);
         }
     }
     async execute(name, ...args) {
@@ -54,7 +52,7 @@ class EventHandler extends common_1.BaseHandler {
             case 'MESSAGE_CREATE':
                 {
                     const { d: data } = args[0];
-                    if (args[1].components.values.has(data.interaction?.id ?? data.id)) {
+                    if (args[1].components?.values.has(data.interaction?.id ?? data.id)) {
                         args[1].components.values.get(data.interaction?.id ?? data.id).messageId = data.id;
                     }
                 }
@@ -62,7 +60,7 @@ class EventHandler extends common_1.BaseHandler {
             case 'MESSAGE_DELETE':
                 {
                     const { d: data } = args[0];
-                    const value = [...args[1].components.values].find(x => x[1].messageId === data.id);
+                    const value = [...(args[1].components?.values ?? [])].find(x => x[1].messageId === data.id);
                     if (value) {
                         args[1].components.onMessageDelete(value[0]);
                     }
@@ -71,7 +69,7 @@ class EventHandler extends common_1.BaseHandler {
             case 'MESSAGE_DELETE_BULK':
                 {
                     const { d: data } = args[0];
-                    const values = [...args[1].components.values];
+                    const values = [...(args[1].components?.values ?? [])];
                     data.ids.forEach(id => {
                         const value = values.find(x => x[1].messageId === id);
                         if (value) {
@@ -97,7 +95,7 @@ class EventHandler extends common_1.BaseHandler {
             await Event.run(...[hook, client, shardId]);
         }
         catch (e) {
-            await this.onFail?.(e);
+            await this.onFail(e);
         }
     }
     async reload(name) {

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 import type { InternalRuntimeConfig, InternalRuntimeConfigHTTP, RuntimeConfig, RuntimeConfigHTTP } from './client/base';
+import type { InferWithPrefix } from './commands';
+import { type When } from './common';
 import type { ClientNameEvents, EventContext } from './events';
-import type { ChatInputCommandInteraction, MessageCommandInteraction, UserCommandInteraction } from './structures';
+import type { ChatInputCommandInteraction, Message, MessageCommandInteraction, UserCommandInteraction } from './structures';
 export { Logger, PermissionFlagsBits, PermissionStrings, Watcher } from './common';
 export { Collection, LimitedCollection } from './collection';
 export * from './api';
@@ -79,4 +81,4 @@ export declare const config: {
  * 	};
  * });
  */
-export declare function extendContext<T extends {}>(cb: (interaction: ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction) => T): (interaction: ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction) => T;
+export declare function extendContext<T extends {}>(cb: (interaction: ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction | When<InferWithPrefix, Message, never>) => T): (interaction: ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction | When<InferWithPrefix, Message, never>) => T;

package/lib/index.js

@@ -77,7 +77,7 @@ exports.config = {
             intents: 'intents' in data
                 ? typeof data.intents === 'number'
                     ? data.intents
-                    : data.intents?.reduce((pr, acc) => pr | common_1.GatewayIntentBits[acc], 0) ?? 0
+                    : data.intents?.reduce((pr, acc) => pr | (typeof acc === 'number' ? acc : common_1.GatewayIntentBits[acc]), 0) ?? 0
                 : 0,
         };
     },

package/lib/langs/handler.d.ts

@@ -1,4 +1,12 @@
 import { BaseHandler, type LocaleString } 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;

package/lib/langs/handler.js

@@ -13,8 +13,13 @@ class LangsHandler extends common_1.BaseHandler {
     }
     getKey(lang, message) {
         let value = this.values[lang];
-        for (const i of message.split('.')) {
-            value = value[i];
+        try {
+            for (const i of message.split('.')) {
+                value = value[i];
+            }
+        }
+        catch {
+            return;
         }
         if (typeof value !== 'string') {
             return;
@@ -30,6 +35,7 @@ class LangsHandler extends common_1.BaseHandler {
         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);
         }
     }
 }

package/lib/structures/AutoModerationRule.d.ts

@@ -1,10 +1,10 @@
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIAutoModerationRule, MethodContext, ObjectToLower, RESTPatchAPIAutoModerationRuleJSONBody, RESTPostAPIAutoModerationRuleJSONBody } from '../common';
 import { DiscordBase } from './extra/DiscordBase';
 export interface AutoModerationRule extends ObjectToLower<APIAutoModerationRule> {
 }
 export declare class AutoModerationRule extends DiscordBase<APIAutoModerationRule> {
-    constructor(client: BaseClient, data: APIAutoModerationRule);
+    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>;