seyfert 1.3.3 → 1.4.0

package/lib/components/handler.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentHandler = void 0;
 const collection_1 = require("../collection");
+const commands_1 = require("../commands");
 const common_1 = require("../common");
-const command_1 = require("./command");
-const componentcontext_1 = require("./componentcontext");
+const componentcommand_1 = require("./componentcommand");
+const modalcommand_1 = require("./modalcommand");
 class ComponentHandler extends common_1.BaseHandler {
     client;
     onFail = err => this.logger.warn('<Client>.components.onFail', err);
@@ -116,8 +117,11 @@ class ComponentHandler extends common_1.BaseHandler {
     onMessageDelete(id) {
         this.deleteValue(id, 'messageDelete');
     }
-    async load(componentsDir) {
-        const paths = await this.loadFilesK(await this.getFiles(componentsDir));
+    async load(componentsDir, instances) {
+        const paths = instances?.map(x => {
+            const i = new x();
+            return { file: x, path: i.__filePath ?? '*' };
+        }) ?? (await this.loadFilesK(await this.getFiles(componentsDir)));
         for (let i = 0; i < paths.length; i++) {
             let component;
             try {
@@ -126,7 +130,7 @@ class ComponentHandler extends common_1.BaseHandler {
                     continue;
             }
             catch (e) {
-                if (e instanceof Error && e.message === 'paths[i].file is not a constructor') {
+                if (e instanceof Error && e.message.includes('is not a constructor')) {
                     this.logger.warn(`${paths[i].path
                         .split(process.cwd())
                         .slice(1)
@@ -136,8 +140,20 @@ class ComponentHandler extends common_1.BaseHandler {
                     this.logger.warn(e, paths[i]);
                 continue;
             }
-            if (!(component instanceof command_1.ModalCommand) && !(component instanceof command_1.ComponentCommand))
+            if (!(component instanceof modalcommand_1.ModalCommand) && !(component instanceof componentcommand_1.ComponentCommand))
                 continue;
+            if (component instanceof modalcommand_1.ModalCommand) {
+                component.onInternalError ??= this.client.options?.modals?.defaults?.onInternalError;
+                component.onMiddlewaresError ??= this.client.options?.modals?.defaults?.onMiddlewaresError;
+                component.onRunError ??= this.client.options?.modals?.defaults?.onRunError;
+                component.onAfterRun ??= this.client.options?.modals?.defaults?.onAfterRun;
+            }
+            else {
+                component.onInternalError ??= this.client.options?.components?.defaults?.onInternalError;
+                component.onMiddlewaresError ??= this.client.options?.components?.defaults?.onMiddlewaresError;
+                component.onRunError ??= this.client.options?.components?.defaults?.onRunError;
+                component.onAfterRun ??= this.client.options?.components?.defaults?.onAfterRun;
+            }
             component.__filePath = paths[i].path;
             this.commands.push(component);
         }
@@ -171,16 +187,45 @@ class ComponentHandler extends common_1.BaseHandler {
             await this.reload(i.__filePath);
         }
     }
-    async executeComponent(interaction) {
+    async executeComponent(context) {
         for (const i of this.commands) {
             try {
-                if (i.type === command_1.InteractionCommandType.COMPONENT && i.cType === interaction.componentType) {
-                    const context = new componentcontext_1.ComponentContext(this.client, interaction);
-                    const extended = this.client.options?.context?.(interaction) ?? {};
-                    Object.assign(context, extended);
-                    if (!(await i.filter(context)))
-                        continue;
-                    await i.run(context);
+                if (i.type === componentcommand_1.InteractionCommandType.COMPONENT &&
+                    i.cType === context.interaction.componentType &&
+                    (await i.filter(context))) {
+                    context.command = i;
+                    try {
+                        const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
+                        if (resultRunGlobalMiddlewares.pass) {
+                            return;
+                        }
+                        if ('error' in resultRunGlobalMiddlewares) {
+                            return i.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
+                        }
+                        const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, i.middlewares, false);
+                        if (resultRunMiddlewares.pass) {
+                            return;
+                        }
+                        if ('error' in resultRunMiddlewares) {
+                            return i.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
+                        }
+                        try {
+                            await i.run(context);
+                            await i.onAfterRun?.(context, undefined);
+                        }
+                        catch (error) {
+                            await i.onRunError?.(context, error);
+                            await i.onAfterRun?.(context, error);
+                        }
+                    }
+                    catch (error) {
+                        try {
+                            await i.onInternalError?.(this.client, error);
+                        }
+                        catch {
+                            // supress error
+                        }
+                    }
                     break;
                 }
             }
@@ -189,11 +234,43 @@ class ComponentHandler extends common_1.BaseHandler {
             }
         }
     }
-    async executeModal(interaction) {
+    async executeModal(context) {
         for (const i of this.commands) {
             try {
-                if (i.type === command_1.InteractionCommandType.MODAL && (await i.filter(interaction))) {
-                    await i.run(interaction);
+                if (i.type === componentcommand_1.InteractionCommandType.MODAL && (await i.filter(context))) {
+                    context.command = i;
+                    try {
+                        const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
+                        if (resultRunGlobalMiddlewares.pass) {
+                            return;
+                        }
+                        if ('error' in resultRunGlobalMiddlewares) {
+                            return i.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
+                        }
+                        const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, i.middlewares, false);
+                        if (resultRunMiddlewares.pass) {
+                            return;
+                        }
+                        if ('error' in resultRunMiddlewares) {
+                            return i.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
+                        }
+                        try {
+                            await i.run(context);
+                            await i.onAfterRun?.(context, undefined);
+                        }
+                        catch (error) {
+                            await i.onRunError?.(context, error);
+                            await i.onAfterRun?.(context, error);
+                        }
+                    }
+                    catch (error) {
+                        try {
+                            await i.onInternalError?.(this.client, error);
+                        }
+                        catch {
+                            // supress error
+                        }
+                    }
                     break;
                 }
             }

package/lib/components/index.d.ts

@@ -9,8 +9,10 @@ import type { TextInputComponent } from './TextInputComponent';
 import { UserSelectMenuComponent } from './UserSelectMenuComponent';
 export type MessageComponents = ButtonComponent | LinkButtonComponent | RoleSelectMenuComponent | UserSelectMenuComponent | StringSelectMenuComponent | ChannelSelectMenuComponent | MentionableSelectMenuComponent | TextInputComponent;
 export type ActionRowMessageComponents = Exclude<MessageComponents, TextInputComponent>;
-export * from './command';
+export * from './componentcommand';
 export * from './componentcontext';
+export * from './modalcommand';
+export * from './modalcontext';
 /**
  * Return a new component instance based on the component type.
  *

package/lib/components/index.js

@@ -23,8 +23,10 @@ const MentionableSelectMenuComponent_1 = require("./MentionableSelectMenuCompone
 const RoleSelectMenuComponent_1 = require("./RoleSelectMenuComponent");
 const StringSelectMenuComponent_1 = require("./StringSelectMenuComponent");
 const UserSelectMenuComponent_1 = require("./UserSelectMenuComponent");
-__exportStar(require("./command"), exports);
+__exportStar(require("./componentcommand"), exports);
 __exportStar(require("./componentcontext"), exports);
+__exportStar(require("./modalcommand"), exports);
+__exportStar(require("./modalcontext"), exports);
 /**
  * Return a new component instance based on the component type.
  *

package/lib/components/modalcommand.d.ts

@@ -0,0 +1,15 @@
+import type { RegisteredMiddlewares, UsingClient } from '../commands';
+import type { ModalContext } from './modalcontext';
+export interface ModalCommand {
+    __filePath?: string;
+}
+export declare abstract class ModalCommand {
+    type: 1;
+    abstract filter(context: ModalContext): Promise<boolean> | boolean;
+    abstract run(context: ModalContext): any;
+    middlewares: (keyof RegisteredMiddlewares)[];
+    onAfterRun?(context: ModalContext, error: unknown | undefined): any;
+    onRunError?(context: ModalContext, error: unknown): any;
+    onMiddlewaresError?(context: ModalContext, error: string): any;
+    onInternalError?(client: UsingClient, error?: unknown): any;
+}

package/lib/components/modalcommand.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalCommand = void 0;
+const componentcommand_1 = require("./componentcommand");
+class ModalCommand {
+    type = componentcommand_1.InteractionCommandType.MODAL;
+    middlewares = [];
+}
+exports.ModalCommand = ModalCommand;

package/lib/components/modalcontext.d.ts

@@ -0,0 +1,104 @@
+import type { AllChannels, Guild, GuildMember, Message, ModalCommand, ModalSubmitInteraction, ReturnCache, WebhookMessage } from '..';
+import type { CommandMetadata, ExtendContext, GlobalMetadata, RegisteredMiddlewares, UsingClient } from '../commands';
+import { BaseContext } from '../commands/basecontext';
+import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, ModalCreateBodyRequest, UnionToTuple, When } from '../common';
+export interface ModalContext extends BaseContext, ExtendContext {
+}
+/**
+ * Represents a context for interacting with components in a Discord bot.
+ * @template Type - The type of component interaction.
+ */
+export declare class ModalContext<M extends keyof RegisteredMiddlewares = never> extends BaseContext {
+    readonly client: UsingClient;
+    interaction: ModalSubmitInteraction;
+    /**
+     * Creates a new instance of the ComponentContext class.
+     * @param client - The UsingClient instance.
+     * @param interaction - The component interaction object.
+     */
+    constructor(client: UsingClient, interaction: ModalSubmitInteraction);
+    command?: ModalCommand;
+    metadata: CommandMetadata<UnionToTuple<M>>;
+    globalMetadata: GlobalMetadata;
+    get customId(): string;
+    get components(): {
+        components: {
+            type: import("discord-api-types/v10").ComponentType;
+            customId: string;
+            value: string;
+        }[];
+        type: import("discord-api-types/v10").ComponentType.ActionRow;
+    }[];
+    /**
+     * Gets the language object for the interaction's locale.
+     */
+    get t(): import("..").__InternalParseLocale<import("..").DefaultLocale> & {
+        get(locale?: string | undefined): import("..").DefaultLocale;
+    };
+    /**
+     * Writes a response to the interaction.
+     * @param body - The body of the response.
+     * @param fetchReply - Whether to fetch the reply or not.
+     */
+    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void>>;
+    /**
+     * Defers the reply to the interaction.
+     * @param ephemeral - Whether the reply should be ephemeral or not.
+     */
+    deferReply(ephemeral?: boolean): Promise<void>;
+    /**
+     * Edits the response of the interaction.
+     * @param body - The updated body of the response.
+     */
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessage>;
+    /**
+     * Edits the response or replies to the interaction.
+     * @param body - The body of the response or updated body of the interaction.
+     * @param fetchReply - Whether to fetch the reply or not.
+     */
+    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
+    /**
+     * Deletes the response of the interaction.
+     * @returns A promise that resolves when the response is deleted.
+     */
+    deleteResponse(): Promise<void | undefined>;
+    modal(body: ModalCreateBodyRequest): any;
+    /**
+     * Gets the channel of the interaction.
+     * @param mode - The mode to fetch the channel.
+     * @returns A promise that resolves to the channel.
+     */
+    channel(mode?: 'rest' | 'flow'): Promise<AllChannels>;
+    channel(mode?: 'cache'): ReturnCache<AllChannels>;
+    /**
+     * Gets the bot member in the guild of the interaction.
+     * @param mode - The mode to fetch the member.
+     * @returns A promise that resolves to the bot member.
+     */
+    me(mode?: 'rest' | 'flow'): Promise<GuildMember>;
+    me(mode?: 'cache'): ReturnCache<GuildMember | undefined>;
+    /**
+     * Gets the guild of the interaction.
+     * @param mode - The mode to fetch the guild.
+     * @returns A promise that resolves to the guild.
+     */
+    guild(mode?: 'rest' | 'flow'): Promise<Guild<'cached' | 'api'> | undefined>;
+    guild(mode?: 'cache'): ReturnCache<Guild<'cached'> | undefined>;
+    /**
+     * Gets the ID of the guild of the interaction.
+     */
+    get guildId(): string | undefined;
+    /**
+     * Gets the ID of the channel of the interaction.
+     */
+    get channelId(): string;
+    /**
+     * Gets the author of the interaction.
+     */
+    get author(): import("..").User;
+    /**
+     * Gets the member of the interaction.
+     */
+    get member(): import("..").InteractionGuildMember | undefined;
+    isModal(): this is ModalContext;
+}

package/lib/components/modalcontext.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalContext = void 0;
+const v10_1 = require("discord-api-types/v10");
+const basecontext_1 = require("../commands/basecontext");
+/**
+ * Represents a context for interacting with components in a Discord bot.
+ * @template Type - The type of component interaction.
+ */
+class ModalContext extends basecontext_1.BaseContext {
+    client;
+    interaction;
+    /**
+     * Creates a new instance of the ComponentContext class.
+     * @param client - The UsingClient instance.
+     * @param interaction - The component interaction object.
+     */
+    constructor(client, interaction) {
+        super(client);
+        this.client = client;
+        this.interaction = interaction;
+    }
+    command;
+    metadata = {};
+    globalMetadata = {};
+    get customId() {
+        return this.interaction.customId;
+    }
+    get components() {
+        return this.interaction.components;
+    }
+    /**
+     * Gets the language object for the interaction's locale.
+     */
+    get t() {
+        return this.client.t(this.interaction?.locale ?? this.client.langs?.defaultLang ?? 'en-US');
+    }
+    /**
+     * Writes a response to the interaction.
+     * @param body - The body of the response.
+     * @param fetchReply - Whether to fetch the reply or not.
+     */
+    write(body, fetchReply) {
+        return this.interaction.write(body, fetchReply);
+    }
+    /**
+     * Defers the reply to the interaction.
+     * @param ephemeral - Whether the reply should be ephemeral or not.
+     */
+    deferReply(ephemeral = false) {
+        return this.interaction.deferReply(ephemeral ? v10_1.MessageFlags.Ephemeral : undefined);
+    }
+    /**
+     * Edits the response of the interaction.
+     * @param body - The updated body of the response.
+     */
+    editResponse(body) {
+        return this.interaction.editResponse(body);
+    }
+    /**
+     * Edits the response or replies to the interaction.
+     * @param body - The body of the response or updated body of the interaction.
+     * @param fetchReply - Whether to fetch the reply or not.
+     */
+    editOrReply(body, fetchReply) {
+        return this.interaction.editOrReply(body, fetchReply);
+    }
+    /**
+     * Deletes the response of the interaction.
+     * @returns A promise that resolves when the response is deleted.
+     */
+    deleteResponse() {
+        return this.interaction.deleteResponse();
+    }
+    modal(body) {
+        //@ts-expect-error
+        return this.interaction.modal(body);
+    }
+    channel(mode = 'cache') {
+        if (this.interaction?.channel && mode === 'cache')
+            return this.client.cache.adapter.isAsync ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
+        return this.client.channels.fetch(this.channelId, mode === 'rest');
+    }
+    me(mode = 'cache') {
+        if (!this.guildId)
+            return mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();
+        switch (mode) {
+            case 'cache':
+                return this.client.cache.members?.get(this.client.botId, this.guildId);
+            default:
+                return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
+        }
+    }
+    guild(mode = 'cache') {
+        if (!this.guildId)
+            return (mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve());
+        switch (mode) {
+            case 'cache':
+                return this.client.cache.guilds?.get(this.guildId);
+            default:
+                return this.client.guilds.fetch(this.guildId, mode === 'rest');
+        }
+    }
+    /**
+     * Gets the ID of the guild of the interaction.
+     */
+    get guildId() {
+        return this.interaction.guildId;
+    }
+    /**
+     * Gets the ID of the channel of the interaction.
+     */
+    get channelId() {
+        return this.interaction.channelId;
+    }
+    /**
+     * Gets the author of the interaction.
+     */
+    get author() {
+        return this.interaction.user;
+    }
+    /**
+     * Gets the member of the interaction.
+     */
+    get member() {
+        return this.interaction.member;
+    }
+    isModal() {
+        return true;
+    }
+}
+exports.ModalContext = ModalContext;

package/lib/events/handler.d.ts

@@ -11,7 +11,10 @@ export declare class EventHandler extends BaseHandler {
     onFail: (event: GatewayEvents, err: unknown) => void;
     protected filter: (path: string) => boolean;
     values: Partial<Record<GatewayEvents, EventValue>>;
-    load(eventsDir: string): Promise<void>;
+    load(eventsDir: string, instances?: {
+        file: ClientEvent;
+        path: 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>;
     reload(name: ClientNameEvents): Promise<any>;

package/lib/events/handler.js

@@ -30,8 +30,8 @@ class EventHandler extends common_1.BaseHandler {
     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))) {
+    async load(eventsDir, instances) {
+        for (const i of instances ?? (await this.loadFilesK(await this.getFiles(eventsDir)))) {
             const instance = this.callback(i.file);
             if (!instance)
                 continue;
@@ -45,11 +45,6 @@ class EventHandler extends common_1.BaseHandler {
     }
     async execute(name, ...args) {
         switch (name) {
-            case 'GUILD_DELETE':
-            case 'CHANNEL_UPDATE':
-                await this.runEvent(args[0].t, args[1], args[0], args[2]);
-                await args[1].cache.onPacket(args[0]);
-                return;
             case 'MESSAGE_CREATE':
                 {
                     const { d: data } = args[0];

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

@@ -1,6 +1,6 @@
 import type { GatewayApplicationCommandPermissionsUpdateDispatchData } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
-export declare const APPLICATION_COMMAND_PERMISSIONS_UPDATE: (_self: BaseClient, data: GatewayApplicationCommandPermissionsUpdateDispatchData) => {
+import type { UsingClient } from '../../commands';
+export declare const APPLICATION_COMMAND_PERMISSIONS_UPDATE: (_self: UsingClient, data: GatewayApplicationCommandPermissionsUpdateDispatchData) => {
     id: string;
     applicationId: string;
     guildId: string;

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

@@ -1,7 +1,7 @@
 import type { GatewayAutoModerationActionExecutionDispatchData, GatewayAutoModerationRuleCreateDispatchData, GatewayAutoModerationRuleDeleteDispatchData, GatewayAutoModerationRuleUpdateDispatchData } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
 import { AutoModerationRule } from '../../structures';
-export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: BaseClient, data: GatewayAutoModerationActionExecutionDispatchData) => {
+import type { UsingClient } from '../../commands';
+export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: UsingClient, data: GatewayAutoModerationActionExecutionDispatchData) => {
     guildId: string;
     action: {
         type: import("discord-api-types/v10").AutoModerationActionType;
@@ -21,6 +21,6 @@ export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: BaseClient, data:
     matchedKeyword: string | null;
     matchedContent: string | null;
 };
-export declare const AUTO_MODERATION_RULE_CREATE: (self: BaseClient, data: GatewayAutoModerationRuleCreateDispatchData) => AutoModerationRule;
-export declare const AUTO_MODERATION_RULE_DELETE: (self: BaseClient, data: GatewayAutoModerationRuleDeleteDispatchData) => AutoModerationRule;
-export declare const AUTO_MODERATION_RULE_UPDATE: (self: BaseClient, data: GatewayAutoModerationRuleUpdateDispatchData) => AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_CREATE: (self: UsingClient, data: GatewayAutoModerationRuleCreateDispatchData) => AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_DELETE: (self: UsingClient, data: GatewayAutoModerationRuleDeleteDispatchData) => AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_UPDATE: (self: UsingClient, data: GatewayAutoModerationRuleUpdateDispatchData) => AutoModerationRule;

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

@@ -1,11 +1,11 @@
 import type { GatewayChannelCreateDispatchData, GatewayChannelDeleteDispatchData, GatewayChannelPinsUpdateDispatchData, GatewayChannelUpdateDispatchData } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
 import type { AllChannels } from '../../structures';
-export declare const CHANNEL_CREATE: (self: BaseClient, data: GatewayChannelCreateDispatchData) => AllChannels;
-export declare const CHANNEL_DELETE: (self: BaseClient, data: GatewayChannelDeleteDispatchData) => AllChannels;
-export declare const CHANNEL_PINS_UPDATE: (_self: BaseClient, data: GatewayChannelPinsUpdateDispatchData) => {
+import type { UsingClient } from '../../commands';
+export declare const CHANNEL_CREATE: (self: UsingClient, data: GatewayChannelCreateDispatchData) => AllChannels;
+export declare const CHANNEL_DELETE: (self: UsingClient, data: GatewayChannelDeleteDispatchData) => AllChannels;
+export declare const CHANNEL_PINS_UPDATE: (_self: UsingClient, data: GatewayChannelPinsUpdateDispatchData) => {
     guildId?: string | undefined;
     channelId: string;
     lastPinTimestamp?: string | null | undefined;
 };
-export declare const CHANNEL_UPDATE: (self: BaseClient, data: GatewayChannelUpdateDispatchData) => Promise<[channel: AllChannels, old?: AllChannels]>;
+export declare const CHANNEL_UPDATE: (self: UsingClient, data: GatewayChannelUpdateDispatchData) => Promise<[channel: AllChannels, old?: AllChannels]>;

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

@@ -1,4 +1,4 @@
-import type { BaseClient } from '../../client/base';
+import type { UsingClient } from '../../commands';
 import type { ClientUser } from '../../structures';
-export declare const BOT_READY: (_self: BaseClient, me: ClientUser) => ClientUser;
-export declare const WORKER_READY: (_self: BaseClient, me: ClientUser) => ClientUser;
+export declare const BOT_READY: (_self: UsingClient, me: ClientUser) => ClientUser;
+export declare const WORKER_READY: (_self: UsingClient, me: ClientUser) => ClientUser;

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

@@ -1,6 +1,6 @@
 import type { GatewayDispatchPayload, GatewayReadyDispatchData, GatewayResumedDispatch } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
 import { ClientUser } from '../../structures';
-export declare const READY: (self: BaseClient, data: GatewayReadyDispatchData) => ClientUser;
-export declare const RESUMED: (_self: BaseClient, _data: GatewayResumedDispatch['d']) => void;
-export declare const RAW: (_self: BaseClient, data: GatewayDispatchPayload) => GatewayDispatchPayload;
+import type { UsingClient } from '../../commands';
+export declare const READY: (self: UsingClient, data: GatewayReadyDispatchData) => ClientUser;
+export declare const RESUMED: (_self: UsingClient, _data: GatewayResumedDispatch['d']) => void;
+export declare const RAW: (_self: UsingClient, data: GatewayDispatchPayload) => GatewayDispatchPayload;

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

@@ -1,6 +1,6 @@
 import type { APIEntitlement } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
-export declare const ENTITLEMENT_CREATE: (_: BaseClient, data: APIEntitlement) => {
+import type { UsingClient } from '../../commands';
+export declare const ENTITLEMENT_CREATE: (_: UsingClient, data: APIEntitlement) => {
     id: string;
     skuId: string;
     userId?: string | undefined;
@@ -12,7 +12,7 @@ export declare const ENTITLEMENT_CREATE: (_: BaseClient, data: APIEntitlement) =
     endsAt?: string | undefined;
     consumed?: boolean | undefined;
 };
-export declare const ENTITLEMENT_UPDATE: (_: BaseClient, data: APIEntitlement) => {
+export declare const ENTITLEMENT_UPDATE: (_: UsingClient, data: APIEntitlement) => {
     id: string;
     skuId: string;
     userId?: string | undefined;
@@ -24,7 +24,7 @@ export declare const ENTITLEMENT_UPDATE: (_: BaseClient, data: APIEntitlement) =
     endsAt?: string | undefined;
     consumed?: boolean | undefined;
 };
-export declare const ENTITLEMENT_DELETE: (_: BaseClient, data: APIEntitlement) => {
+export declare const ENTITLEMENT_DELETE: (_: UsingClient, data: APIEntitlement) => {
     id: string;
     skuId: string;
     userId?: string | undefined;