seyfert 0.1.0 → 1.0.0

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

@@ -1,4 +1,6 @@
-import type { APIApplicationCommandBasicOption, APIApplicationCommandOption, APIAttachment, LocaleString } from '../../common';
+import type { SeyfertNumberOption, SeyfertStringOption } from '../..';
+import type { Attachment } from '../../builders';
+import type { APIApplicationCommandBasicOption, APIApplicationCommandOption, LocaleString, PermissionStrings } from '../../common';
 import { ApplicationCommandOptionType, ApplicationCommandType } from '../../common';
 import type { AllChannels, AutocompleteInteraction, GuildRole, InteractionGuildMember, User } from '../../structures';
 import type { Groups, RegisteredMiddlewares } from '../decorators';
@@ -15,7 +17,7 @@ export interface ReturnOptionsTypes {
     8: GuildRole;
     9: GuildRole | AllChannels | User;
     10: number;
-    11: APIAttachment;
+    11: Attachment;
 }
 type Wrap<N extends ApplicationCommandOptionType> = N extends ApplicationCommandOptionType.Subcommand | ApplicationCommandOptionType.SubcommandGroup ? never : {
     required?: boolean;
@@ -53,22 +55,22 @@ type KeysWithoutRequired<T extends OptionsRecord> = {
     [K in keyof T]-?: T[K]['required'] extends true ? never : K;
 }[keyof T];
 type ContextOptionsAux<T extends OptionsRecord> = {
-    [K in Exclude<keyof T, KeysWithoutRequired<T>>]: T[K]['value'] extends (...args: any) => any ? T[K]['required'] extends true ? Parameters<Parameters<T[K]['value']>[1]>[0] : never : T[K]['required'] extends true ? ReturnOptionsTypes[T[K]['type']] : never;
+    [K in Exclude<keyof T, KeysWithoutRequired<T>>]: T[K]['value'] extends (...args: any) => any ? Parameters<Parameters<T[K]['value']>[1]>[0] : T[K] extends SeyfertStringOption | SeyfertNumberOption ? T[K]['choices'] extends NonNullable<SeyfertStringOption['choices'] | SeyfertNumberOption['choices']> ? T[K]['choices'][number]['value'] : ReturnOptionsTypes[T[K]['type']] : ReturnOptionsTypes[T[K]['type']];
 } & {
-    [K in KeysWithoutRequired<T>]?: T[K]['value'] extends (...args: any) => any ? T[K]['required'] extends true ? never : Parameters<Parameters<T[K]['value']>[1]>[0] : T[K]['required'] extends true ? never : ReturnOptionsTypes[T[K]['type']];
+    [K in KeysWithoutRequired<T>]?: T[K]['value'] extends (...args: any) => any ? Parameters<Parameters<T[K]['value']>[1]>[0] : T[K] extends SeyfertStringOption | SeyfertNumberOption ? T[K]['choices'] extends NonNullable<SeyfertStringOption['choices'] | SeyfertNumberOption['choices']> ? T[K]['choices'][number]['value'] : ReturnOptionsTypes[T[K]['type']] : ReturnOptionsTypes[T[K]['type']];
 };
 export type ContextOptions<T extends OptionsRecord> = ContextOptionsAux<T>;
 declare class BaseCommand {
     middlewares: (keyof RegisteredMiddlewares)[];
     __filePath?: string;
     __t?: {
-        name: string;
-        description: string;
+        name: string | undefined;
+        description: string | undefined;
     };
     __d?: true;
     __tGroups?: Record<string, {
-        name: string;
-        description: string;
+        name: string | undefined;
+        description: string | undefined;
         defaultDescription: string;
     }>;
     guild_id?: string[];
@@ -77,29 +79,30 @@ declare class BaseCommand {
     nsfw?: boolean;
     description: string;
     default_member_permissions?: string;
-    permissions?: bigint;
+    botPermissions?: bigint;
     dm?: boolean;
     name_localizations?: Partial<Record<LocaleString, string>>;
     description_localizations?: Partial<Record<LocaleString, string>>;
     options?: CommandOption[] | SubCommand[];
     toJSON(): {
-        name: string;
-        type: number;
-        nsfw: boolean;
-        description: string;
-        name_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
-        description_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
-        guild_id: string[] | undefined;
-        dm_permission: boolean | undefined;
-        default_member_permissions: string | undefined;
+        name: BaseCommand['name'];
+        type: BaseCommand['type'];
+        nsfw: BaseCommand['nsfw'];
+        description: BaseCommand['description'];
+        name_localizations: BaseCommand['name_localizations'];
+        description_localizations: BaseCommand['description_localizations'];
+        guild_id: BaseCommand['guild_id'];
+        default_member_permissions: BaseCommand['default_member_permissions'];
+        dm_permission?: boolean | undefined;
     };
     reload(): Promise<void>;
     run?(context: CommandContext<any>): any;
     onAfterRun?(context: CommandContext<any>, error: unknown | undefined): any;
     onRunError?(context: CommandContext<any>, error: unknown): any;
     onOptionsError?(context: CommandContext<{}, never>, metadata: OnOptionsReturnObject): any;
-    onMiddlewaresError?(context: CommandContext<{}, never>, error: Error): any;
-    onInternalError(client: UsingClient, error?: unknown): any;
+    onMiddlewaresError?(context: CommandContext<{}, never>, error: string): any;
+    onPermissionsFail?(context: CommandContext<{}, never>, permissions: PermissionStrings): any;
+    onInternalError?(client: UsingClient, error?: unknown): any;
 }
 export declare class Command extends BaseCommand {
     type: ApplicationCommandType;
@@ -108,14 +111,19 @@ export declare class Command extends BaseCommand {
         options: APIApplicationCommandOption[];
         name: string;
         type: number;
-        nsfw: boolean;
+        nsfw: boolean | undefined;
         description: string;
         name_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
         description_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
         guild_id: string[] | undefined;
-        dm_permission: boolean | undefined;
         default_member_permissions: string | undefined;
+        dm_permission?: boolean | undefined;
     };
+    onRunError(context: CommandContext<any>, error: unknown): any;
+    onOptionsError(context: CommandContext<{}, never>, metadata: OnOptionsReturnObject): any;
+    onMiddlewaresError(context: CommandContext<{}, never>, error: string): any;
+    onPermissionsFail(context: CommandContext<{}, never>, permissions: PermissionStrings): any;
+    onInternalError(client: UsingClient, error?: unknown): any;
 }
 export declare abstract class SubCommand extends BaseCommand {
     type: ApplicationCommandOptionType;
@@ -125,15 +133,14 @@ export declare abstract class SubCommand extends BaseCommand {
         options: APIApplicationCommandBasicOption[];
         name: string;
         type: number;
-        nsfw: boolean;
+        nsfw: boolean | undefined;
         description: string;
         name_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
         description_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
         guild_id: string[] | undefined;
-        dm_permission: boolean | undefined;
         default_member_permissions: string | undefined;
+        dm_permission?: boolean | undefined;
     };
     abstract run(context: CommandContext<any>): any;
-    onRunError?(context: CommandContext<any>, error: unknown): any;
 }
 export {};

package/lib/commands/applications/chat.js

@@ -14,7 +14,7 @@ class BaseCommand {
     nsfw;
     description;
     default_member_permissions;
-    permissions;
+    botPermissions;
     dm;
     name_localizations;
     description_localizations;
@@ -22,46 +22,49 @@ class BaseCommand {
     /** @internal */
     async __runOptions(ctx, resolver) {
         const command = resolver.getCommand();
-        if (!resolver.hoistedOptions.length || !command) {
+        if (!command?.options?.length) {
             return [false, {}];
         }
         const data = {};
         let errored = false;
-        for (const i of resolver.hoistedOptions) {
-            const option = command.options.find(x => x.name === i.name);
-            const value = (await new Promise(resolve => option.value?.({ context: ctx, value: resolver.getValue(i.name) }, resolve, resolve) ||
-                resolve(resolver.getValue(i.name))));
-            if (value instanceof Error) {
-                errored = true;
+        for (const i of command.options ?? []) {
+            try {
+                const option = command.options.find(x => x.name === i.name);
+                const value = resolver.getHoisted(i.name)?.value !== undefined
+                    ? await new Promise((res, rej) => option.value?.({ context: ctx, value: resolver.getValue(i.name) }, res, rej) ||
+                        res(resolver.getValue(i.name)))
+                    : undefined;
+                if (value === undefined) {
+                    if (option.required) {
+                        errored = true;
+                        data[i.name] = {
+                            failed: true,
+                            value: `${i.name} is required but returned no value`,
+                        };
+                        continue;
+                    }
+                }
+                // @ts-expect-error
+                ctx.options[i.name] = value;
                 data[i.name] = {
-                    failed: true,
+                    failed: false,
                     value,
                 };
-                continue;
             }
-            if (value === undefined) {
-                if (option.required) {
-                    errored = true;
-                    data[i.name] = {
-                        failed: true,
-                        value: new Error(`${i.name} is required but returned no value`),
-                    };
-                    continue;
-                }
+            catch (e) {
+                errored = true;
+                data[i.name] = {
+                    failed: true,
+                    value: e instanceof Error ? e.message : `${e}`,
+                };
             }
-            // @ts-expect-error
-            ctx.options[i.name] = value;
-            data[i.name] = {
-                failed: false,
-                value,
-            };
         }
         return [errored, data];
     }
     /** @internal */
     static __runMiddlewares(context, middlewares, global) {
         if (!middlewares.length) {
-            return Promise.resolve(undefined);
+            return Promise.resolve({});
         }
         let index = 0;
         return new Promise(res => {
@@ -71,7 +74,7 @@ class BaseCommand {
                     return;
                 }
                 running = false;
-                return res('pass');
+                return res({ pass: true });
             };
             const next = obj => {
                 if (!running) {
@@ -82,7 +85,7 @@ class BaseCommand {
                 context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
                 if (++index >= middlewares.length) {
                     running = false;
-                    return res(undefined);
+                    return res({});
                 }
                 context.client.middlewares[middlewares[index]]({ context, next, stop, pass });
             };
@@ -91,7 +94,7 @@ class BaseCommand {
                     return;
                 }
                 running = false;
-                return res(err);
+                return res({ error: err });
             };
             context.client.middlewares[middlewares[0]]({ context, next, stop, pass });
         });
@@ -105,7 +108,7 @@ class BaseCommand {
         return BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
     }
     toJSON() {
-        return {
+        const data = {
             name: this.name,
             type: this.type,
             nsfw: this.nsfw || false,
@@ -113,18 +116,17 @@ class BaseCommand {
             name_localizations: this.name_localizations,
             description_localizations: this.description_localizations,
             guild_id: this.guild_id,
-            dm_permission: this.dm,
             default_member_permissions: this.default_member_permissions,
         };
+        if ('dm' in this)
+            data.dm_permission = this.dm;
+        return data;
     }
     async reload() {
         delete require.cache[this.__filePath];
         const __tempCommand = await (0, common_1.magicImport)(this.__filePath).then(x => x.default ?? x);
         Object.setPrototypeOf(this, __tempCommand.prototype);
     }
-    onInternalError(client, error) {
-        client.logger.fatal(error);
-    }
 }
 class Command extends BaseCommand {
     type = common_1.ApplicationCommandType.ChatInput;
@@ -158,6 +160,21 @@ class Command extends BaseCommand {
             options,
         };
     }
+    onRunError(context, error) {
+        context.client.logger.fatal(`${this.name}.<onRunError>`, context.author.id, error);
+    }
+    onOptionsError(context, metadata) {
+        context.client.logger.fatal(`${this.name}.<onOptionsError>`, context.author.id, metadata);
+    }
+    onMiddlewaresError(context, error) {
+        context.client.logger.fatal(`${this.name}.<onMiddlewaresError>`, context.author.id, error);
+    }
+    onPermissionsFail(context, permissions) {
+        context.client.logger.fatal(`${this.name}.<onPermissionsFail>`, context.author.id, permissions);
+    }
+    onInternalError(client, error) {
+        client.logger.fatal(`${this.name}.<onInternalError>`, error);
+    }
 }
 exports.Command = Command;
 class SubCommand extends BaseCommand {

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

@@ -1,28 +1,46 @@
-import { type UnionToTuple } from '../../common';
-import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, ModalCreateBodyRequest } from '../../common/types/write';
-import type { ChatInputCommandInteraction } from '../../structures';
+import { MenuCommandContext, User, type AllChannels, type Guild, type InferWithPrefix, type MessageCommandInteraction, type ReturnCache, type UserCommandInteraction, type WebhookMessage } from '../..';
+import { type When, type If, type UnionToTuple } from '../../common';
+import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest } from '../../common/types/write';
+import { Message, type ChatInputCommandInteraction, type GuildMember, type InteractionGuildMember } from '../../structures';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { OptionResolver } from '../optionresolver';
 import type { ContextOptions, OptionsRecord } from './chat';
-import type { CommandMetadata, DefaultLocale, ExtendContext, GlobalMetadata, UsingClient } from './shared';
-export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> implements ExtendContext {
+import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
+export interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends ExtendContext {
+}
+export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> {
     readonly client: UsingClient;
-    readonly interaction: ChatInputCommandInteraction;
     resolver: OptionResolver;
     readonly shardId: number;
-    constructor(client: UsingClient, interaction: ChatInputCommandInteraction, resolver: OptionResolver, shardId: number);
+    message: If<InferWithPrefix, Message | undefined, undefined>;
+    interaction: If<InferWithPrefix, ChatInputCommandInteraction | undefined, ChatInputCommandInteraction>;
+    messageResponse?: If<InferWithPrefix, Message | undefined>;
+    constructor(client: UsingClient, data: ChatInputCommandInteraction | Message, resolver: OptionResolver, shardId: number);
     options: ContextOptions<T>;
     metadata: CommandMetadata<UnionToTuple<M>>;
     globalMetadata: GlobalMetadata;
     get proxy(): import("../..").APIRoutes;
-    get t(): DefaultLocale;
-    write(body: InteractionCreateBodyRequest): Promise<void>;
-    modal(body: ModalCreateBodyRequest): Promise<void>;
-    deferReply(ephemeral?: boolean): Promise<void>;
-    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<import("../../structures").Message>;
+    get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
+        get(locale?: string | undefined): import("./shared").DefaultLocale;
+    };
+    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>;
-    editOrReply(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest): Promise<void>;
-    fetchResponse(): Promise<import("../../structures").WebhookMessage | undefined>;
-    get author(): import("../../structures").User;
-    get member(): import("../../structures").InteractionGuildMember | 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>>;
+    channel(mode?: 'cache'): ReturnCache<If<InferWithPrefix, AllChannels | undefined, AllChannels>>;
+    me(mode?: 'rest' | 'flow'): Promise<GuildMember>;
+    me(mode?: 'cache'): ReturnCache<GuildMember | undefined>;
+    guild(mode?: 'rest' | 'flow'): Promise<Guild<'cached' | 'api'> | undefined>;
+    guild(mode?: 'cache'): ReturnCache<Guild<'cached'> | undefined>;
+    get guildId(): string | undefined;
+    get channelId(): string;
+    get author(): 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,17 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandContext = void 0;
+const __1 = require("../..");
 const common_1 = require("../../common");
+const structures_1 = require("../../structures");
 class CommandContext {
     client;
-    interaction;
     resolver;
     shardId;
-    constructor(client, interaction, resolver, shardId) {
+    message;
+    interaction;
+    messageResponse;
+    constructor(client, data, resolver, shardId) {
         this.client = client;
-        this.interaction = interaction;
         this.resolver = resolver;
         this.shardId = shardId;
+        if (data instanceof structures_1.Message) {
+            this.message = data;
+        }
+        else {
+            this.interaction = data;
+        }
     }
     options = {};
     metadata = {};
@@ -20,34 +29,104 @@ class CommandContext {
         return this.client.proxy;
     }
     get t() {
-        return this.client.langs.get(this.interaction.locale);
-    }
-    write(body) {
-        return this.interaction.write(body);
+        return this.client.langs.get(this.interaction?.locale ?? this.client.langs.defaultLang ?? 'en-US');
     }
-    modal(body) {
-        return this.interaction.modal(body);
+    async write(body, fetchReply) {
+        if (this.interaction)
+            return this.interaction.write(body, fetchReply);
+        const options = this.client.options?.commands;
+        return (this.messageResponse = await this.message[!this.messageResponse && options?.reply?.(this) ? 'reply' : 'write'](body));
     }
-    deferReply(ephemeral = false) {
-        return this.interaction.deferReply(ephemeral ? common_1.MessageFlags.Ephemeral : undefined);
+    async deferReply(ephemeral = false) {
+        if (this.interaction)
+            return this.interaction.deferReply(ephemeral ? common_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...' }));
     }
-    editResponse(body) {
-        return this.interaction.editResponse(body);
+    async editResponse(body) {
+        if (this.interaction)
+            return this.interaction.editResponse(body);
+        return (this.messageResponse = await this.messageResponse.edit(body));
     }
     deleteResponse() {
-        return this.interaction.deleteResponse();
+        if (this.interaction)
+            return this.interaction.deleteResponse();
+        return this.messageResponse.delete();
+    }
+    editOrReply(body, fetchReply) {
+        if (this.interaction)
+            return this.interaction.editOrReply(body, fetchReply);
+        if (this.messageResponse) {
+            return this.editResponse(body);
+        }
+        return this.write(body, fetchReply);
+    }
+    async fetchResponse() {
+        if (this.interaction)
+            return this.interaction.fetchResponse();
+        this.messageResponse = await this.messageResponse?.fetch();
+        return this.messageResponse;
+    }
+    channel(mode = 'cache') {
+        if (this.interaction?.channel && mode === 'cache')
+            return this.client.cache.asyncCache ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
+        switch (mode) {
+            case 'cache':
+                return (this.client.cache.channels?.get(this.channelId) ||
+                    (this.client.cache.asyncCache ? Promise.resolve() : undefined));
+            default:
+                return this.client.channels.fetch(this.channelId, mode === 'rest');
+        }
     }
-    editOrReply(body) {
-        return this.interaction.editOrReply(body);
+    me(mode = 'cache') {
+        if (!this.guildId)
+            return mode === 'cache' ? (this.client.cache.asyncCache ? Promise.resolve() : undefined) : Promise.resolve();
+        switch (mode) {
+            case 'cache':
+                return (this.client.cache.members?.get(this.client.botId, this.guildId) ||
+                    (this.client.cache.asyncCache ? Promise.resolve() : undefined));
+            default:
+                return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
+        }
     }
-    fetchResponse() {
-        return this.interaction.fetchResponse();
+    guild(mode = 'cache') {
+        if (!this.guildId)
+            return (mode === 'cache'
+                ? this.client.cache.asyncCache
+                    ? Promise.resolve()
+                    : undefined
+                : Promise.resolve());
+        switch (mode) {
+            case 'cache':
+                return (this.client.cache.guilds?.get(this.guildId) ||
+                    (this.client.cache.asyncCache ? Promise.resolve() : undefined));
+            default:
+                return this.client.guilds.fetch(this.guildId, mode === 'rest');
+        }
+    }
+    get guildId() {
+        return this.interaction?.guildId || this.message?.guildId;
+    }
+    get channelId() {
+        return this.interaction?.channelId || this.message.channelId;
     }
     get author() {
-        return this.interaction.user;
+        return this.interaction?.user || this.message.author;
     }
     get member() {
-        return this.interaction.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,13 +1,13 @@
-import type { BaseClient } from '../../client/base';
-import { type ApplicationCommandType, type LocaleString } from '../../common';
+import { type ApplicationCommandType, type LocaleString, type PermissionStrings } from '../../common';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { MenuCommandContext } from './menucontext';
+import type { UsingClient } from './shared';
 export declare abstract class ContextMenuCommand {
     middlewares: (keyof RegisteredMiddlewares)[];
     __filePath?: string;
     __t?: {
-        name: string;
-        description: string;
+        name: string | undefined;
+        description: string | undefined;
     };
     guild_id?: string[];
     name: string;
@@ -15,7 +15,7 @@ export declare abstract class ContextMenuCommand {
     nsfw?: boolean;
     description: string;
     default_member_permissions?: string;
-    permissions?: bigint;
+    botPermissions?: bigint;
     dm?: boolean;
     name_localizations?: Partial<Record<LocaleString, string>>;
     description_localizations?: Partial<Record<LocaleString, string>>;
@@ -33,7 +33,8 @@ export declare abstract class ContextMenuCommand {
     reload(): Promise<void>;
     abstract run?(context: MenuCommandContext<any>): any;
     onAfterRun?(context: MenuCommandContext<any>, error: unknown | undefined): any;
-    onRunError?(context: MenuCommandContext<any>, error: unknown): any;
-    onMiddlewaresError?(context: MenuCommandContext<any, never>, error: Error): any;
-    onInternalError(client: BaseClient, error?: unknown): any;
+    onRunError(context: MenuCommandContext<any, never>, error: unknown): any;
+    onMiddlewaresError(context: MenuCommandContext<any, never>, error: string): any;
+    onPermissionsFail(context: MenuCommandContext<any, never>, permissions: PermissionStrings): any;
+    onInternalError(client: UsingClient, error?: unknown): any;
 }

package/lib/commands/applications/menu.js

@@ -12,14 +12,14 @@ class ContextMenuCommand {
     nsfw;
     description;
     default_member_permissions;
-    permissions;
+    botPermissions;
     dm;
     name_localizations;
     description_localizations;
     /** @internal */
     static __runMiddlewares(context, middlewares, global) {
         if (!middlewares.length) {
-            return Promise.resolve(undefined);
+            return Promise.resolve({});
         }
         let index = 0;
         return new Promise(res => {
@@ -29,7 +29,7 @@ class ContextMenuCommand {
                     return;
                 }
                 running = false;
-                return res('pass');
+                return res({ pass: true });
             };
             const next = obj => {
                 if (!running) {
@@ -40,7 +40,7 @@ class ContextMenuCommand {
                 context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
                 if (++index >= middlewares.length) {
                     running = false;
-                    return res(undefined);
+                    return res({});
                 }
                 context.client.middlewares[middlewares[index]]({ context, next, stop, pass });
             };
@@ -49,7 +49,7 @@ class ContextMenuCommand {
                     return;
                 }
                 running = false;
-                return res(err);
+                return res({ error: err });
             };
             context.client.middlewares[middlewares[0]]({ context, next, stop, pass });
         });
@@ -80,6 +80,15 @@ class ContextMenuCommand {
         const __tempCommand = await (0, common_1.magicImport)(this.__filePath).then(x => x.default ?? x);
         Object.setPrototypeOf(this, __tempCommand.prototype);
     }
+    onRunError(context, error) {
+        context.client.logger.fatal(`${this.name}.<onRunError>`, context.author.id, error);
+    }
+    onMiddlewaresError(context, error) {
+        context.client.logger.fatal(`${this.name}.<onMiddlewaresError>`, context.author.id, error);
+    }
+    onPermissionsFail(context, permissions) {
+        context.client.logger.fatal(`${this.name}.<onPermissionsFail>`, context.author.id, permissions);
+    }
     onInternalError(client, error) {
         client.logger.fatal(error);
     }