seyfert 0.1.0

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

@@ -0,0 +1,139 @@
+import type { APIApplicationCommandBasicOption, APIApplicationCommandOption, APIAttachment, LocaleString } from '../../common';
+import { ApplicationCommandOptionType, ApplicationCommandType } from '../../common';
+import type { AllChannels, AutocompleteInteraction, GuildRole, InteractionGuildMember, User } from '../../structures';
+import type { Groups, RegisteredMiddlewares } from '../decorators';
+import type { CommandContext } from './chatcontext';
+import type { OKFunction, OnOptionsReturnObject, StopFunction, UsingClient } from './shared';
+export interface ReturnOptionsTypes {
+    1: never;
+    2: never;
+    3: string;
+    4: number;
+    5: boolean;
+    6: InteractionGuildMember | User;
+    7: AllChannels;
+    8: GuildRole;
+    9: GuildRole | AllChannels | User;
+    10: number;
+    11: APIAttachment;
+}
+type Wrap<N extends ApplicationCommandOptionType> = N extends ApplicationCommandOptionType.Subcommand | ApplicationCommandOptionType.SubcommandGroup ? never : {
+    required?: boolean;
+    value?(data: {
+        context: CommandContext;
+        value: ReturnOptionsTypes[N];
+    }, ok: OKFunction<any>, fail: StopFunction): void;
+} & {
+    description: string;
+    description_localizations?: APIApplicationCommandBasicOption['description_localizations'];
+    name_localizations?: APIApplicationCommandBasicOption['name_localizations'];
+};
+export type __TypeWrapper<T extends ApplicationCommandOptionType> = Wrap<T>;
+export type __TypesWrapper = {
+    [P in keyof typeof ApplicationCommandOptionType]: `${(typeof ApplicationCommandOptionType)[P]}` extends `${infer D extends number}` ? Wrap<D> : never;
+};
+export type AutocompleteCallback = (interaction: AutocompleteInteraction) => any;
+export type OnAutocompleteErrorCallback = (interaction: AutocompleteInteraction, error: unknown) => any;
+export type CommandBaseOption = __TypesWrapper[keyof __TypesWrapper];
+export type CommandBaseAutocompleteOption = __TypesWrapper[keyof __TypesWrapper] & {
+    autocomplete: AutocompleteCallback;
+    onAutocompleteError?: OnAutocompleteErrorCallback;
+};
+export type CommandAutocompleteOption = CommandBaseAutocompleteOption & {
+    name: string;
+};
+export type __CommandOption = CommandBaseOption;
+export type CommandOption = __CommandOption & {
+    name: string;
+};
+export type OptionsRecord = Record<string, __CommandOption & {
+    type: ApplicationCommandOptionType;
+}>;
+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 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']];
+};
+export type ContextOptions<T extends OptionsRecord> = ContextOptionsAux<T>;
+declare class BaseCommand {
+    middlewares: (keyof RegisteredMiddlewares)[];
+    __filePath?: string;
+    __t?: {
+        name: string;
+        description: string;
+    };
+    __d?: true;
+    __tGroups?: Record<string, {
+        name: string;
+        description: string;
+        defaultDescription: string;
+    }>;
+    guild_id?: string[];
+    name: string;
+    type: number;
+    nsfw?: boolean;
+    description: string;
+    default_member_permissions?: string;
+    permissions?: 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;
+    };
+    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;
+}
+export declare class Command extends BaseCommand {
+    type: ApplicationCommandType;
+    groups?: Parameters<typeof Groups>[0];
+    toJSON(): {
+        options: APIApplicationCommandOption[];
+        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;
+    };
+}
+export declare abstract class SubCommand extends BaseCommand {
+    type: ApplicationCommandOptionType;
+    group?: string;
+    options?: CommandOption[];
+    toJSON(): {
+        options: APIApplicationCommandBasicOption[];
+        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;
+    };
+    abstract run(context: CommandContext<any>): any;
+    onRunError?(context: CommandContext<any>, error: unknown): any;
+}
+export {};

package/lib/commands/applications/chat.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubCommand = exports.Command = void 0;
+const common_1 = require("../../common");
+class BaseCommand {
+    middlewares = [];
+    __filePath;
+    __t;
+    __d;
+    __tGroups;
+    guild_id;
+    name;
+    type; // ApplicationCommandType.ChatInput | ApplicationCommandOptionType.Subcommand
+    nsfw;
+    description;
+    default_member_permissions;
+    permissions;
+    dm;
+    name_localizations;
+    description_localizations;
+    options;
+    /** @internal */
+    async __runOptions(ctx, resolver) {
+        const command = resolver.getCommand();
+        if (!resolver.hoistedOptions.length || !command) {
+            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;
+                data[i.name] = {
+                    failed: true,
+                    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;
+                }
+            }
+            // @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);
+        }
+        let index = 0;
+        return new Promise(res => {
+            let running = true;
+            const pass = () => {
+                if (!running) {
+                    return;
+                }
+                running = false;
+                return res('pass');
+            };
+            const next = obj => {
+                if (!running) {
+                    return;
+                }
+                context[global ? 'globalMetadata' : 'metadata'] ??= {};
+                // @ts-expect-error
+                context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
+                if (++index >= middlewares.length) {
+                    running = false;
+                    return res(undefined);
+                }
+                context.client.middlewares[middlewares[index]]({ context, next, stop, pass });
+            };
+            const stop = err => {
+                if (!running) {
+                    return;
+                }
+                running = false;
+                return res(err);
+            };
+            context.client.middlewares[middlewares[0]]({ context, next, stop, pass });
+        });
+    }
+    /** @internal */
+    __runMiddlewares(context) {
+        return BaseCommand.__runMiddlewares(context, this.middlewares, false);
+    }
+    /** @internal */
+    __runGlobalMiddlewares(context) {
+        return BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            type: this.type,
+            nsfw: this.nsfw || false,
+            description: this.description,
+            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,
+        };
+    }
+    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;
+    groups;
+    toJSON() {
+        const options = [];
+        for (const i of this.options ?? []) {
+            if (!(i instanceof SubCommand)) {
+                options.push({ ...i, autocomplete: 'autocomplete' in i });
+                continue;
+            }
+            if (i.group) {
+                if (!options.find(x => x.name === i.group)) {
+                    options.push({
+                        type: common_1.ApplicationCommandOptionType.SubcommandGroup,
+                        name: i.group,
+                        description: this.groups[i.group].defaultDescription,
+                        description_localizations: Object.fromEntries(this.groups?.[i.group].description ?? []),
+                        name_localizations: Object.fromEntries(this.groups?.[i.group].name ?? []),
+                        options: [],
+                    });
+                }
+                const group = options.find(x => x.name === i.group);
+                group.options?.push(i.toJSON());
+                continue;
+            }
+            options.push(i.toJSON());
+        }
+        return {
+            ...super.toJSON(),
+            options,
+        };
+    }
+}
+exports.Command = Command;
+class SubCommand extends BaseCommand {
+    type = common_1.ApplicationCommandOptionType.Subcommand;
+    group;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            options: (this.options ?? []).map(x => ({ ...x, autocomplete: 'autocomplete' in x })),
+        };
+    }
+}
+exports.SubCommand = SubCommand;

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

@@ -0,0 +1,28 @@
+import { type UnionToTuple } from '../../common';
+import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, ModalCreateBodyRequest } from '../../common/types/write';
+import type { ChatInputCommandInteraction } 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 {
+    readonly client: UsingClient;
+    readonly interaction: ChatInputCommandInteraction;
+    resolver: OptionResolver;
+    readonly shardId: number;
+    constructor(client: UsingClient, interaction: ChatInputCommandInteraction, 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>;
+    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;
+}

package/lib/commands/applications/chatcontext.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandContext = void 0;
+const common_1 = require("../../common");
+class CommandContext {
+    client;
+    interaction;
+    resolver;
+    shardId;
+    constructor(client, interaction, resolver, shardId) {
+        this.client = client;
+        this.interaction = interaction;
+        this.resolver = resolver;
+        this.shardId = shardId;
+    }
+    options = {};
+    metadata = {};
+    globalMetadata = {};
+    get proxy() {
+        return this.client.proxy;
+    }
+    get t() {
+        return this.client.langs.get(this.interaction.locale);
+    }
+    write(body) {
+        return this.interaction.write(body);
+    }
+    modal(body) {
+        return this.interaction.modal(body);
+    }
+    deferReply(ephemeral = false) {
+        return this.interaction.deferReply(ephemeral ? common_1.MessageFlags.Ephemeral : undefined);
+    }
+    editResponse(body) {
+        return this.interaction.editResponse(body);
+    }
+    deleteResponse() {
+        return this.interaction.deleteResponse();
+    }
+    editOrReply(body) {
+        return this.interaction.editOrReply(body);
+    }
+    fetchResponse() {
+        return this.interaction.fetchResponse();
+    }
+    get author() {
+        return this.interaction.user;
+    }
+    get member() {
+        return this.interaction.member;
+    }
+}
+exports.CommandContext = CommandContext;

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

@@ -0,0 +1,39 @@
+import type { BaseClient } from '../../client/base';
+import { type ApplicationCommandType, type LocaleString } from '../../common';
+import type { RegisteredMiddlewares } from '../decorators';
+import type { MenuCommandContext } from './menucontext';
+export declare abstract class ContextMenuCommand {
+    middlewares: (keyof RegisteredMiddlewares)[];
+    __filePath?: string;
+    __t?: {
+        name: string;
+        description: string;
+    };
+    guild_id?: string[];
+    name: string;
+    type: ApplicationCommandType.User | ApplicationCommandType.Message;
+    nsfw?: boolean;
+    description: string;
+    default_member_permissions?: string;
+    permissions?: bigint;
+    dm?: boolean;
+    name_localizations?: Partial<Record<LocaleString, string>>;
+    description_localizations?: Partial<Record<LocaleString, string>>;
+    toJSON(): {
+        name: string;
+        type: ApplicationCommandType.User | ApplicationCommandType.Message;
+        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;
+    };
+    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;
+}

package/lib/commands/applications/menu.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextMenuCommand = void 0;
+const common_1 = require("../../common");
+class ContextMenuCommand {
+    middlewares = [];
+    __filePath;
+    __t;
+    guild_id;
+    name;
+    type;
+    nsfw;
+    description;
+    default_member_permissions;
+    permissions;
+    dm;
+    name_localizations;
+    description_localizations;
+    /** @internal */
+    static __runMiddlewares(context, middlewares, global) {
+        if (!middlewares.length) {
+            return Promise.resolve(undefined);
+        }
+        let index = 0;
+        return new Promise(res => {
+            let running = true;
+            const pass = () => {
+                if (!running) {
+                    return;
+                }
+                running = false;
+                return res('pass');
+            };
+            const next = obj => {
+                if (!running) {
+                    return;
+                }
+                context[global ? 'globalMetadata' : 'metadata'] ??= {};
+                // @ts-expect-error
+                context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
+                if (++index >= middlewares.length) {
+                    running = false;
+                    return res(undefined);
+                }
+                context.client.middlewares[middlewares[index]]({ context, next, stop, pass });
+            };
+            const stop = err => {
+                if (!running) {
+                    return;
+                }
+                running = false;
+                return res(err);
+            };
+            context.client.middlewares[middlewares[0]]({ context, next, stop, pass });
+        });
+    }
+    /** @internal */
+    __runMiddlewares(context) {
+        return ContextMenuCommand.__runMiddlewares(context, this.middlewares, false);
+    }
+    /** @internal */
+    __runGlobalMiddlewares(context) {
+        return ContextMenuCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            type: this.type,
+            nsfw: this.nsfw,
+            description: this.description,
+            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,
+        };
+    }
+    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);
+    }
+}
+exports.ContextMenuCommand = ContextMenuCommand;

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

@@ -0,0 +1,25 @@
+import { type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type ModalCreateBodyRequest, type UnionToTuple } from '../../common';
+import { Message, User, type MessageCommandInteraction, type UserCommandInteraction } from '../../structures';
+import type { RegisteredMiddlewares } from '../decorators';
+import type { CommandMetadata, DefaultLocale, ExtendContext, GlobalMetadata, UsingClient } from './shared';
+export type InteractionTarget<T> = T extends MessageCommandInteraction ? Message : User;
+export declare class MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof RegisteredMiddlewares = never> implements ExtendContext {
+    readonly client: UsingClient;
+    readonly interaction: T;
+    readonly shardId: number;
+    constructor(client: UsingClient, interaction: T, shardId: number);
+    metadata: CommandMetadata<UnionToTuple<M>>;
+    globalMetadata: GlobalMetadata;
+    get proxy(): import("../..").APIRoutes;
+    get target(): InteractionTarget<T>;
+    get t(): DefaultLocale;
+    write(body: InteractionCreateBodyRequest): Promise<void>;
+    modal(body: ModalCreateBodyRequest): Promise<void>;
+    deferReply(ephemeral?: boolean): Promise<void>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message>;
+    deleteResponse(): Promise<void>;
+    editOrReply(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest): Promise<void>;
+    fetchResponse(): Promise<import("../../structures").WebhookMessage | undefined>;
+    get author(): User;
+    get member(): import("../../structures").InteractionGuildMember | undefined;
+}

package/lib/commands/applications/menucontext.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuCommandContext = void 0;
+const common_1 = require("../../common");
+const structures_1 = require("../../structures");
+class MenuCommandContext {
+    client;
+    interaction;
+    shardId;
+    constructor(client, interaction, shardId) {
+        this.client = client;
+        this.interaction = interaction;
+        this.shardId = shardId;
+    }
+    metadata = {};
+    globalMetadata = {};
+    get proxy() {
+        return this.client.proxy;
+    }
+    // biome-ignore lint/suspicious/useGetterReturn: bugged
+    get target() {
+        switch (this.interaction.data.type) {
+            case common_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: {
+                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);
+    }
+    write(body) {
+        return this.interaction.write(body);
+    }
+    modal(body) {
+        return this.interaction.modal(body);
+    }
+    deferReply(ephemeral = false) {
+        return this.interaction.deferReply(ephemeral ? common_1.MessageFlags.Ephemeral : undefined);
+    }
+    editResponse(body) {
+        return this.interaction.editResponse(body);
+    }
+    deleteResponse() {
+        return this.interaction.deleteResponse();
+    }
+    editOrReply(body) {
+        return this.interaction.editOrReply(body);
+    }
+    fetchResponse() {
+        return this.interaction.fetchResponse();
+    }
+    get author() {
+        return this.interaction.user;
+    }
+    get member() {
+        return this.interaction.member;
+    }
+}
+exports.MenuCommandContext = MenuCommandContext;