seyfert 1.1.0 → 1.2.0

package/lib/client/workerclient.d.ts

@@ -3,21 +3,22 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+import { type GatewayDispatchPayload } from 'discord-api-types/v10';
+import { Logger } from '..';
 import type { Cache } from '../cache';
-import type { GatewayDispatchPayload, When } from '../common';
-import { Logger, type DeepPartial } from '../common';
-import { EventHandler } from '../events';
+import { type DeepPartial, type When } from '../common';
+import { type EventHandlerLike } from '../events';
 import { ClientUser } from '../structures';
 import { Shard, type ShardManagerOptions } from '../websocket';
 import type { WorkerShardInfo } from '../websocket/discord/worker';
 import type { ManagerMessages } from '../websocket/discord/workermanager';
-import type { BaseClientOptions, StartOptions } from './base';
+import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 import type { Client } from './client';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
     logger: Logger;
-    events: EventHandler;
+    events?: EventHandlerLike;
     me: When<Ready, ClientUser>;
     promises: Map<string, {
         resolve: (value: any) => void;
@@ -28,6 +29,11 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     constructor(options?: WorkerClientOptions);
     get workerId(): number;
     get latency(): number;
+    setServices({ ...rest }: ServicesOptions & {
+        handlers?: ServicesOptions['handlers'] & {
+            events?: EventHandlerLike;
+        };
+    }): void;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
     loadEvents(dir?: string): Promise<void>;
     postMessage(body: any): boolean | void;

package/lib/client/workerclient.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateShardInfo = exports.WorkerClient = void 0;
+const v10_1 = require("discord-api-types/v10");
 const node_crypto_1 = require("node:crypto");
 const node_worker_threads_1 = require("node:worker_threads");
 const __1 = require("..");
@@ -27,7 +28,7 @@ try {
 catch { }
 class WorkerClient extends base_1.BaseClient {
     __handleGuilds = new Set();
-    logger = new common_1.Logger({
+    logger = new __1.Logger({
         name: `[Worker #${workerData.workerId}]`,
     });
     events = new events_1.EventHandler(this.logger);
@@ -51,7 +52,7 @@ class WorkerClient extends base_1.BaseClient {
             },
         });
         if (workerData.debug) {
-            this.debugger = new common_1.Logger({
+            this.debugger = new __1.Logger({
                 name: `[Worker #${workerData.workerId}]`,
                 logLevel: common_1.LogLevels.Debug,
             });
@@ -74,6 +75,12 @@ class WorkerClient extends base_1.BaseClient {
         this.shards.forEach(s => (acc += s.latency));
         return acc / this.shards.size;
     }
+    setServices({ ...rest }) {
+        super.setServices(rest);
+        if (rest.handlers && 'events' in rest.handlers) {
+            this.events = rest.handlers.events;
+        }
+    }
     async start(options = {}) {
         await super.start(options);
         await this.loadEvents(options.eventsDir);
@@ -81,7 +88,7 @@ class WorkerClient extends base_1.BaseClient {
     }
     async loadEvents(dir) {
         dir ??= await this.getRC().then(x => x.events);
-        if (dir) {
+        if (dir && this.events) {
             await this.events.load(dir);
             this.logger.info('EventHandler loaded');
         }
@@ -191,7 +198,7 @@ class WorkerClient extends base_1.BaseClient {
                 }
                 break;
             case 'BOT_READY':
-                await this.events.runEvent('BOT_READY', this, this.me, -1);
+                await this.events?.runEvent('BOT_READY', this, this.me, -1);
                 break;
             case 'API_RESPONSE':
                 {
@@ -270,14 +277,14 @@ class WorkerClient extends base_1.BaseClient {
         return this.generateSendPromise(nonce);
     }
     async onPacket(packet, shardId) {
-        await this.events.execute('RAW', packet, this, shardId);
+        await this.events?.execute('RAW', packet, this, shardId);
         switch (packet.t) {
             case 'GUILD_MEMBER_UPDATE':
-                await this.events.execute(packet.t, packet, this, shardId);
+                await this.events?.execute(packet.t, packet, this, shardId);
                 await this.cache.onPacket(packet);
                 break;
             case 'PRESENCE_UPDATE':
-                await this.events.execute(packet.t, packet, this, shardId);
+                await this.events?.execute(packet.t, packet, this, shardId);
                 await this.cache.onPacket(packet);
                 break;
             //rest of the events
@@ -292,13 +299,13 @@ class WorkerClient extends base_1.BaseClient {
                             this.applicationId = packet.d.application.id;
                             this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
                             if (!this.__handleGuilds?.size ||
-                                !((workerData.intents & common_1.GatewayIntentBits.Guilds) === common_1.GatewayIntentBits.Guilds)) {
+                                !((workerData.intents & v10_1.GatewayIntentBits.Guilds) === v10_1.GatewayIntentBits.Guilds)) {
                                 if ([...this.shards.values()].every(shard => shard.data.session_id)) {
                                     this.postMessage({
                                         type: 'WORKER_READY',
                                         workerId: this.workerId,
                                     });
-                                    await this.events.runEvent('WORKER_READY', this, this.me, -1);
+                                    await this.events?.runEvent('WORKER_READY', this, this.me, -1);
                                 }
                                 delete this.__handleGuilds;
                             }
@@ -318,7 +325,7 @@ class WorkerClient extends base_1.BaseClient {
                                         type: 'WORKER_READY',
                                         workerId: this.workerId,
                                     });
-                                    await this.events.runEvent('WORKER_READY', this, this.me, -1);
+                                    await this.events?.runEvent('WORKER_READY', this, this.me, -1);
                                 }
                                 if (!this.__handleGuilds.size)
                                     delete this.__handleGuilds;
@@ -326,7 +333,7 @@ class WorkerClient extends base_1.BaseClient {
                             }
                         }
                     }
-                    await this.events.execute(packet.t, packet, this, shardId);
+                    await this.events?.execute(packet.t, packet, this, shardId);
                 }
                 break;
         }

package/lib/commands/applications/chat.d.ts

@@ -1,7 +1,7 @@
-import type { SeyfertNumberOption, SeyfertStringOption } from '../..';
+import { type APIApplicationCommandBasicOption, type APIApplicationCommandOption, ApplicationCommandOptionType, ApplicationCommandType, type LocaleString } from 'discord-api-types/v10';
+import type { PermissionStrings, SeyfertNumberOption, SeyfertStringOption } from '../..';
 import type { Attachment } from '../../builders';
-import type { APIApplicationCommandBasicOption, APIApplicationCommandOption, FlatObjectKeys, LocaleString, PermissionStrings } from '../../common';
-import { ApplicationCommandOptionType, ApplicationCommandType } from '../../common';
+import { type FlatObjectKeys } from '../../common';
 import type { AllChannels, AutocompleteInteraction, GuildRole, InteractionGuildMember, User } from '../../structures';
 import type { Groups, IntegrationTypes, InteractionContextTypes, RegisteredMiddlewares } from '../decorators';
 import type { CommandContext } from './chatcontext';
@@ -71,7 +71,7 @@ declare class BaseCommand {
         name: string | undefined;
         description: string | undefined;
     };
-    __d?: true;
+    __autoload?: true;
     __tGroups?: Record<string, {
         name: string | undefined;
         description: string | undefined;

package/lib/commands/applications/chat.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubCommand = exports.Command = void 0;
+const v10_1 = require("discord-api-types/v10");
 const common_1 = require("../../common");
 class BaseCommand {
     middlewares = [];
     __filePath;
     __t;
-    __d;
+    __autoload;
     __tGroups;
     guild_id;
     name;
@@ -76,19 +77,21 @@ class BaseCommand {
                 running = false;
                 return res({ pass: true });
             };
-            const next = obj => {
+            function next(obj) {
                 if (!running) {
                     return;
                 }
-                context[global ? 'globalMetadata' : 'metadata'] ??= {};
-                // @ts-expect-error
-                context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
+                // biome-ignore lint/style/noArguments: yes
+                if (arguments.length) {
+                    // @ts-expect-error
+                    context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
+                }
                 if (++index >= middlewares.length) {
                     running = false;
                     return res({});
                 }
                 context.client.middlewares[middlewares[index]]({ context, next, stop, pass });
-            };
+            }
             const stop = err => {
                 if (!running) {
                     return;
@@ -126,10 +129,15 @@ class BaseCommand {
         delete require.cache[this.__filePath];
         const __tempCommand = await (0, common_1.magicImport)(this.__filePath).then(x => x.default ?? x);
         Object.setPrototypeOf(this, __tempCommand.prototype);
+        for (const i of this.options ?? []) {
+            if (i instanceof SubCommand && i.__filePath) {
+                await i.reload();
+            }
+        }
     }
 }
 class Command extends BaseCommand {
-    type = common_1.ApplicationCommandType.ChatInput;
+    type = v10_1.ApplicationCommandType.ChatInput;
     groups;
     toJSON() {
         const options = [];
@@ -141,7 +149,7 @@ class Command extends BaseCommand {
             if (i.group) {
                 if (!options.find(x => x.name === i.group)) {
                     options.push({
-                        type: common_1.ApplicationCommandOptionType.SubcommandGroup,
+                        type: v10_1.ApplicationCommandOptionType.SubcommandGroup,
                         name: i.group,
                         description: this.groups[i.group].defaultDescription,
                         description_localizations: Object.fromEntries(this.groups?.[i.group].description ?? []),
@@ -178,7 +186,7 @@ class Command extends BaseCommand {
 }
 exports.Command = Command;
 class SubCommand extends BaseCommand {
-    type = common_1.ApplicationCommandOptionType.Subcommand;
+    type = v10_1.ApplicationCommandOptionType.Subcommand;
     group;
     toJSON() {
         return {

package/lib/commands/applications/chatcontext.d.ts

@@ -1,14 +1,15 @@
-import { MenuCommandContext, User, type AllChannels, type Guild, type InferWithPrefix, type MessageCommandInteraction, type ReturnCache, type UserCommandInteraction, type WebhookMessage } from '../..';
-import { type If, type UnionToTuple, type When } from '../../common';
+import type { AllChannels, Guild, InferWithPrefix, ReturnCache, WebhookMessage } from '../..';
+import type { If, UnionToTuple, When } from '../../common';
 import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest } from '../../common/types/write';
 import { Message, type ChatInputCommandInteraction, type GuildMember, type InteractionGuildMember } from '../../structures';
+import { BaseContext } from '../basecontex';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { OptionResolver } from '../optionresolver';
 import type { Command, ContextOptions, OptionsRecord, SubCommand } from './chat';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
-export interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends ExtendContext {
+export interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends BaseContext, ExtendContext {
 }
-export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> {
+export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends BaseContext {
     readonly client: UsingClient;
     readonly resolver: OptionResolver;
     readonly shardId: number;
@@ -28,7 +29,7 @@ export declare class CommandContext<T extends OptionsRecord = {}, M extends keyo
     write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
     deferReply(ephemeral?: boolean): Promise<void | Message>;
     editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message>;
-    deleteResponse(): Promise<void>;
+    deleteResponse(): Promise<void | undefined>;
     editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
     fetchResponse(): Promise<If<InferWithPrefix, WebhookMessage | Message | undefined, WebhookMessage | undefined>>;
     channel(mode?: 'rest' | 'flow'): Promise<If<InferWithPrefix, AllChannels | undefined, AllChannels>>;
@@ -39,10 +40,6 @@ export declare class CommandContext<T extends OptionsRecord = {}, M extends keyo
     guild(mode?: 'cache'): ReturnCache<Guild<'cached'> | undefined>;
     get guildId(): string | undefined;
     get channelId(): string;
-    get author(): User;
+    get author(): import("../..").User;
     get member(): If<InferWithPrefix, GuildMember | InteractionGuildMember | undefined, InteractionGuildMember | undefined>;
-    isChat(): this is CommandContext;
-    isMenu(): this is MenuCommandContext<any>;
-    isMenuUser(): this is MenuCommandContext<UserCommandInteraction>;
-    isMenuMessage(): this is MenuCommandContext<MessageCommandInteraction>;
 }

package/lib/commands/applications/chatcontext.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandContext = void 0;
-const __1 = require("../..");
-const common_1 = require("../../common");
+const v10_1 = require("discord-api-types/v10");
 const structures_1 = require("../../structures");
-class CommandContext {
+const basecontex_1 = require("../basecontex");
+class CommandContext extends basecontex_1.BaseContext {
     client;
     resolver;
     shardId;
@@ -13,6 +13,7 @@ class CommandContext {
     interaction;
     messageResponse;
     constructor(client, data, resolver, shardId, command) {
+        super(client);
         this.client = client;
         this.resolver = resolver;
         this.shardId = shardId;
@@ -31,7 +32,7 @@ class CommandContext {
         return this.client.proxy;
     }
     get t() {
-        return this.client.langs.get(this.interaction?.locale ?? this.client.langs.defaultLang ?? 'en-US');
+        return this.client.t(this.interaction?.locale ?? this.client.langs?.defaultLang ?? 'en-US');
     }
     get fullCommandName() {
         return this.resolver.fullCommandName;
@@ -44,7 +45,7 @@ class CommandContext {
     }
     async deferReply(ephemeral = false) {
         if (this.interaction)
-            return this.interaction.deferReply(ephemeral ? common_1.MessageFlags.Ephemeral : undefined);
+            return this.interaction.deferReply(ephemeral ? v10_1.MessageFlags.Ephemeral : undefined);
         const options = this.client.options?.commands;
         return (this.messageResponse = await this.message[options?.reply?.(this) ? 'reply' : 'write'](options?.deferReplyResponse?.(this) ?? { content: 'Thinking...' }));
     }
@@ -121,17 +122,5 @@ class CommandContext {
     get member() {
         return this.interaction?.member || this.message?.member;
     }
-    isChat() {
-        return this instanceof CommandContext;
-    }
-    isMenu() {
-        return this instanceof __1.MenuCommandContext;
-    }
-    isMenuUser() {
-        return this instanceof __1.MenuCommandContext && this.target instanceof __1.User;
-    }
-    isMenuMessage() {
-        return this instanceof __1.MenuCommandContext && this.target instanceof structures_1.Message;
-    }
 }
 exports.CommandContext = CommandContext;

package/lib/commands/applications/menu.d.ts

@@ -1,4 +1,5 @@
-import { type ApplicationCommandType, type LocaleString, type PermissionStrings } from '../../common';
+import type { ApplicationCommandType, LocaleString } from 'discord-api-types/v10';
+import { type PermissionStrings } from '../../common';
 import type { IntegrationTypes, InteractionContextTypes, RegisteredMiddlewares } from '../decorators';
 import type { MenuCommandContext } from './menucontext';
 import type { UsingClient } from './shared';

package/lib/commands/applications/menu.js

@@ -33,19 +33,21 @@ class ContextMenuCommand {
                 running = false;
                 return res({ pass: true });
             };
-            const next = obj => {
+            function next(obj) {
                 if (!running) {
                     return;
                 }
-                context[global ? 'globalMetadata' : 'metadata'] ??= {};
-                // @ts-expect-error
-                context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
+                // biome-ignore lint/style/noArguments: yes
+                if (arguments.length) {
+                    // @ts-expect-error
+                    context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
+                }
                 if (++index >= middlewares.length) {
                     running = false;
                     return res({});
                 }
                 context.client.middlewares[middlewares[index]]({ context, next, stop, pass });
-            };
+            }
             const stop = err => {
                 if (!running) {
                     return;

package/lib/commands/applications/menucontext.d.ts

@@ -1,12 +1,13 @@
-import { CommandContext, type ContextMenuCommand, type ReturnCache, type WebhookMessage } from '../..';
+import type { ContextMenuCommand, ReturnCache, WebhookMessage } from '../..';
 import { type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type UnionToTuple, type When } from '../../common';
 import { Message, User, type AllChannels, type Guild, type GuildMember, type MessageCommandInteraction, type UserCommandInteraction } from '../../structures';
+import { BaseContext } from '../basecontex';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
 export type InteractionTarget<T> = T extends MessageCommandInteraction ? Message : User;
-export interface MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof RegisteredMiddlewares = never> extends ExtendContext {
+export interface MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof RegisteredMiddlewares = never> extends BaseContext, ExtendContext {
 }
-export declare class MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof RegisteredMiddlewares = never> {
+export declare class MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof RegisteredMiddlewares = never> extends BaseContext {
     readonly client: UsingClient;
     readonly interaction: T;
     readonly shardId: number;
@@ -14,7 +15,6 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
     constructor(client: UsingClient, interaction: T, shardId: number, command: ContextMenuCommand);
     metadata: CommandMetadata<UnionToTuple<M>>;
     globalMetadata: GlobalMetadata;
-    get proxy(): import("../..").APIRoutes;
     get target(): InteractionTarget<T>;
     get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
         get(locale?: string | undefined): import("./shared").DefaultLocale;
@@ -24,7 +24,7 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
     get modal(): ((body: import("../../common").ModalCreateBodyRequest) => Promise<void>) | ((body: import("../../common").ModalCreateBodyRequest) => Promise<void>);
     deferReply(ephemeral?: boolean): Promise<void>;
     editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message>;
-    deleteResponse(): Promise<void>;
+    deleteResponse(): Promise<void | undefined>;
     editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
     fetchResponse(): Promise<WebhookMessage | undefined>;
     channel(mode?: 'rest' | 'flow'): Promise<AllChannels>;
@@ -37,8 +37,4 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
     get channelId(): string;
     get author(): User;
     get member(): import("../..").InteractionGuildMember | undefined;
-    isChat(): this is CommandContext;
-    isMenu(): this is MenuCommandContext<any>;
-    isMenuUser(): this is MenuCommandContext<UserCommandInteraction>;
-    isMenuMessage(): this is MenuCommandContext<MessageCommandInteraction>;
 }

package/lib/commands/applications/menucontext.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MenuCommandContext = void 0;
-const __1 = require("../..");
+const v10_1 = require("discord-api-types/v10");
 const common_1 = require("../../common");
 const structures_1 = require("../../structures");
-class MenuCommandContext {
+const basecontex_1 = require("../basecontex");
+class MenuCommandContext extends basecontex_1.BaseContext {
     client;
     interaction;
     shardId;
     command;
     constructor(client, interaction, shardId, command) {
+        super(client);
         this.client = client;
         this.interaction = interaction;
         this.shardId = shardId;
@@ -17,24 +19,21 @@ class MenuCommandContext {
     }
     metadata = {};
     globalMetadata = {};
-    get proxy() {
-        return this.client.proxy;
-    }
     // biome-ignore lint/suspicious/useGetterReturn: default don't exist.
     get target() {
         switch (this.interaction.data.type) {
-            case common_1.ApplicationCommandType.Message: {
+            case v10_1.ApplicationCommandType.Message: {
                 const data = this.interaction.data.resolved.messages[this.interaction.data.targetId];
                 return new structures_1.Message(this.client, (0, common_1.toSnakeCase)(data));
             }
-            case common_1.ApplicationCommandType.User: {
+            case v10_1.ApplicationCommandType.User: {
                 const data = this.interaction.data.resolved.users[this.interaction.data.targetId];
                 return new structures_1.User(this.client, (0, common_1.toSnakeCase)(data));
             }
         }
     }
     get t() {
-        return this.client.langs.get(this.interaction.locale);
+        return this.client.langs.get(this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US');
     }
     get fullCommandName() {
         return this.command.name;
@@ -46,7 +45,7 @@ class MenuCommandContext {
         return this.interaction.modal;
     }
     deferReply(ephemeral = false) {
-        return this.interaction.deferReply(ephemeral ? common_1.MessageFlags.Ephemeral : undefined);
+        return this.interaction.deferReply(ephemeral ? v10_1.MessageFlags.Ephemeral : undefined);
     }
     editResponse(body) {
         return this.interaction.editResponse(body);
@@ -97,17 +96,5 @@ class MenuCommandContext {
     get member() {
         return this.interaction.member;
     }
-    isChat() {
-        return this instanceof __1.CommandContext;
-    }
-    isMenu() {
-        return this instanceof MenuCommandContext;
-    }
-    isMenuUser() {
-        return this instanceof MenuCommandContext && this.target instanceof structures_1.User;
-    }
-    isMenuMessage() {
-        return this instanceof MenuCommandContext && this.target instanceof structures_1.Message;
-    }
 }
 exports.MenuCommandContext = MenuCommandContext;

package/lib/commands/applications/shared.d.ts

@@ -1,8 +1,9 @@
 import type { BaseClient } from '../../client/base';
+import type { IsStrictlyUndefined } from '../../common';
 import type { RegisteredMiddlewares } from '../decorators';
 export type OKFunction<T> = (value: T) => void;
 export type StopFunction = (error: string) => void;
-export type NextFunction<T = unknown> = (data: T) => void;
+export type NextFunction<T = unknown> = IsStrictlyUndefined<T> extends true ? () => void : (data: T) => void;
 export type PassFunction = () => void;
 export type InferWithPrefix = InternalOptions extends {
     withPrefix: infer P;
@@ -24,13 +25,13 @@ export type MiddlewareContext<T = any, C = any> = (context: {
     stop: StopFunction;
     pass: PassFunction;
 }) => any;
-export type MetadataMiddleware<T extends MiddlewareContext> = Parameters<Parameters<T>[0]['next']>[0];
+export type MetadataMiddleware<T extends MiddlewareContext> = IsStrictlyUndefined<Parameters<Parameters<T>[0]['next']>[0]> extends true ? never : Parameters<Parameters<T>[0]['next']>[0];
 export type CommandMetadata<T extends readonly (keyof RegisteredMiddlewares)[]> = T extends readonly [
     infer first,
     ...infer rest
-] ? first extends keyof RegisteredMiddlewares ? {
+] ? first extends keyof RegisteredMiddlewares ? (MetadataMiddleware<RegisteredMiddlewares[first]> extends never ? {} : {
     [key in first]: MetadataMiddleware<RegisteredMiddlewares[first]>;
-} & (rest extends readonly (keyof RegisteredMiddlewares)[] ? CommandMetadata<rest> : {}) : {} : {};
+}) & (rest extends readonly (keyof RegisteredMiddlewares)[] ? CommandMetadata<rest> : {}) : {} : {};
 export type OnOptionsReturnObject = Record<string, {
     failed: false;
     value: unknown;

package/lib/commands/basecontex.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentCommandInteractionMap, ComponentContext } from '../components/componentcontext';
+import { type MessageCommandInteraction, type UserCommandInteraction } from '../structures';
+import type { CommandContext } from './applications/chatcontext';
+import type { MenuCommandContext } from './applications/menucontext';
+import type { UsingClient } from './applications/shared';
+export declare class BaseContext {
+    readonly client: UsingClient;
+    constructor(client: UsingClient);
+    get proxy(): import("..").APIRoutes;
+    isChat(): this is CommandContext;
+    isMenu(): this is MenuCommandContext<UserCommandInteraction | MessageCommandInteraction>;
+    isMenuUser(): this is MenuCommandContext<UserCommandInteraction>;
+    isMenuMessage(): this is MenuCommandContext<MessageCommandInteraction>;
+    isComponent(): this is ComponentContext<keyof ComponentCommandInteractionMap>;
+}

package/lib/commands/basecontex.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContext = void 0;
+const v10_1 = require("discord-api-types/v10");
+const structures_1 = require("../structures");
+class BaseContext {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    get proxy() {
+        return this.client.proxy;
+    }
+    isChat() {
+        //@ts-expect-error
+        return this.message || this.interaction.type === v10_1.ApplicationCommandType.ChatInput;
+    }
+    isMenu() {
+        return this.isMenuUser() || this.isMenuMessage();
+    }
+    isMenuUser() {
+        //@ts-expect-error
+        return this.target instanceof structures_1.User;
+    }
+    isMenuMessage() {
+        //@ts-expect-error
+        return this.target instanceof structures_1.Message;
+    }
+    isComponent() {
+        //@ts-expect-error
+        return this.interaction.type === v10_1.InteractionType.MessageComponent;
+    }
+}
+exports.BaseContext = BaseContext;

package/lib/commands/decorators.d.ts

@@ -1,4 +1,5 @@
-import { ApplicationCommandType, type FlatObjectKeys, type LocaleString, type PermissionStrings } from '../common';
+import { ApplicationCommandType, type LocaleString } from 'discord-api-types/v10';
+import type { FlatObjectKeys, PermissionStrings } from '../common';
 import type { CommandOption, OptionsRecord, SubCommand } from './applications/chat';
 import type { DefaultLocale, MiddlewareContext } from './applications/shared';
 export interface RegisteredMiddlewares {
@@ -92,7 +93,7 @@ export declare function Options(options: (new () => SubCommand)[] | OptionsRecor
 } & T;
 export declare function AutoLoad(): <T extends new (...args: any[]) => {}>(target: T) => {
     new (...args: any[]): {
-        __d: boolean;
+        __autoload: boolean;
     };
 } & T;
 export type ParseMiddlewares<T extends Record<string, MiddlewareContext>> = {

package/lib/commands/decorators.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Declare = exports.Middlewares = exports.AutoLoad = exports.Options = exports.Group = exports.Groups = exports.GroupsT = exports.LocalesT = exports.Locales = exports.InteractionContextTypes = exports.IntegrationTypes = void 0;
-const common_1 = require("../common");
+const v10_1 = require("discord-api-types/v10");
 var IntegrationTypes;
 (function (IntegrationTypes) {
     IntegrationTypes[IntegrationTypes["GUILD_INSTALL"] = 0] = "GUILD_INSTALL";
@@ -59,7 +59,7 @@ function Options(options) {
 exports.Options = Options;
 function AutoLoad() {
     return (target) => class extends target {
-        __d = true;
+        __autoload = true;
     };
 }
 exports.AutoLoad = AutoLoad;
@@ -76,13 +76,13 @@ function Declare(declare) {
         contexts = declare.contexts?.map(i => InteractionContextTypes[i]);
         integration_types = declare.integrationTypes?.map(i => IntegrationTypes[i]);
         default_member_permissions = Array.isArray(declare.defaultMemberPermissions)
-            ? declare.defaultMemberPermissions?.reduce((acc, prev) => acc | common_1.PermissionFlagsBits[prev], BigInt(0)).toString()
+            ? declare.defaultMemberPermissions?.reduce((acc, prev) => acc | v10_1.PermissionFlagsBits[prev], BigInt(0)).toString()
             : declare.defaultMemberPermissions;
         botPermissions = Array.isArray(declare.botPermissions)
-            ? declare.botPermissions?.reduce((acc, prev) => acc | common_1.PermissionFlagsBits[prev], BigInt(0))
+            ? declare.botPermissions?.reduce((acc, prev) => acc | v10_1.PermissionFlagsBits[prev], BigInt(0))
             : declare.botPermissions;
         description = '';
-        type = common_1.ApplicationCommandType.ChatInput;
+        type = v10_1.ApplicationCommandType.ChatInput;
         guild_id;
         constructor(...args) {
             super(...args);

package/lib/commands/handler.d.ts

@@ -3,6 +3,12 @@ import { BaseHandler } from '../common';
 import { Command } from './applications/chat';
 import { ContextMenuCommand } from './applications/menu';
 import type { UsingClient } from './applications/shared';
+export interface CommandHandlerLike {
+    values: CommandHandler['values'];
+    load: CommandHandler['load'];
+    reload: CommandHandler['reload'];
+    reloadAll: CommandHandler['reloadAll'];
+}
 export declare class CommandHandler extends BaseHandler {
     protected logger: Logger;
     protected client: UsingClient;