seyfert 1.3.3 → 1.5.0

package/lib/common/shorters/messages.js

@@ -7,7 +7,7 @@ const base_1 = require("./base");
 class MessageShorter extends base_1.BaseShorter {
     async write(channelId, { files, ...body }) {
         const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
-        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body, parsedFiles, this.client);
         return this.client.proxy
             .channels(channelId)
             .messages.post({
@@ -25,7 +25,7 @@ class MessageShorter extends base_1.BaseShorter {
             .channels(channelId)
             .messages(messageId)
             .patch({
-            body: structures_1.MessagesMethods.transformMessageBody(body),
+            body: structures_1.MessagesMethods.transformMessageBody(body, parsedFiles, this.client),
             files: parsedFiles,
         })
             .then(async (message) => {

package/lib/common/shorters/webhook.js

@@ -67,8 +67,8 @@ class WebhookShorter extends base_1.BaseShorter {
      */
     async writeMessage(webhookId, token, { body: data, ...payload }) {
         const { files, ...body } = data;
-        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
         const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body, parsedFiles, this.client);
         return this.client.proxy
             .webhooks(webhookId)(token)
             .post({ ...payload, files: parsedFiles, body: transformedBody })
@@ -84,8 +84,8 @@ class WebhookShorter extends base_1.BaseShorter {
      */
     async editMessage(webhookId, token, { messageId, body: data, ...json }) {
         const { files, ...body } = data;
-        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
         const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body, parsedFiles, this.client);
         return this.client.proxy
             .webhooks(webhookId)(token)
             .messages(messageId)

package/lib/components/componentcommand.d.ts

@@ -0,0 +1,22 @@
+import type { ContextComponentCommandInteractionMap, ComponentContext } from './componentcontext';
+import type { ExtraProps, RegisteredMiddlewares, UsingClient } from '../commands';
+export declare const InteractionCommandType: {
+    readonly COMPONENT: 0;
+    readonly MODAL: 1;
+};
+export interface ComponentCommand {
+    __filePath?: string;
+}
+export declare abstract class ComponentCommand {
+    type: 0;
+    abstract componentType: keyof ContextComponentCommandInteractionMap;
+    abstract filter(context: ComponentContext<typeof this.componentType>): Promise<boolean> | boolean;
+    abstract run(context: ComponentContext<typeof this.componentType>): any;
+    middlewares: (keyof RegisteredMiddlewares)[];
+    props: ExtraProps;
+    get cType(): number;
+    onAfterRun?(context: ComponentContext, error: unknown | undefined): any;
+    onRunError?(context: ComponentContext, error: unknown): any;
+    onMiddlewaresError?(context: ComponentContext, error: string): any;
+    onInternalError?(client: UsingClient, error?: unknown): any;
+}

package/lib/components/{command.js → componentcommand.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModalCommand = exports.ComponentCommand = exports.InteractionCommandType = void 0;
+exports.ComponentCommand = exports.InteractionCommandType = void 0;
 const v10_1 = require("discord-api-types/v10");
 exports.InteractionCommandType = {
     COMPONENT: 0,
@@ -8,12 +8,10 @@ exports.InteractionCommandType = {
 };
 class ComponentCommand {
     type = exports.InteractionCommandType.COMPONENT;
+    middlewares = [];
+    props;
     get cType() {
         return v10_1.ComponentType[this.componentType];
     }
 }
 exports.ComponentCommand = ComponentCommand;
-class ModalCommand {
-    type = exports.InteractionCommandType.MODAL;
-}
-exports.ModalCommand = ModalCommand;

package/lib/components/componentcontext.d.ts

@@ -1,26 +1,25 @@
-import type { AllChannels, ButtonInteraction, ChannelSelectMenuInteraction, ComponentInteraction, Guild, GuildMember, MentionableSelectMenuInteraction, Message, ReturnCache, RoleSelectMenuInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, WebhookMessage } from '..';
-import type { ExtendContext, UsingClient } from '../commands';
-import { BaseContext } from '../commands/basecontex';
-import type { ComponentInteractionMessageUpdate, InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, When } from '../common';
-export interface ComponentContext<Type extends keyof ComponentCommandInteractionMap> extends BaseContext, ExtendContext {
+import type { AllChannels, ButtonInteraction, ChannelSelectMenuInteraction, ComponentCommand, Guild, GuildMember, MentionableSelectMenuInteraction, Message, ReturnCache, RoleSelectMenuInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, WebhookMessage } from '..';
+import type { CommandMetadata, ExtendContext, GlobalMetadata, RegisteredMiddlewares, UsingClient } from '../commands';
+import { BaseContext } from '../commands/basecontext';
+import type { ComponentInteractionMessageUpdate, InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, ModalCreateBodyRequest, UnionToTuple, When } from '../common';
+export interface ComponentContext<Type extends keyof ContextComponentCommandInteractionMap = keyof ContextComponentCommandInteractionMap> extends BaseContext, ExtendContext {
 }
 /**
  * Represents a context for interacting with components in a Discord bot.
  * @template Type - The type of component interaction.
  */
-export declare class ComponentContext<Type extends keyof ComponentCommandInteractionMap> extends BaseContext {
+export declare class ComponentContext<Type extends keyof ContextComponentCommandInteractionMap, M extends keyof RegisteredMiddlewares = never> extends BaseContext {
     readonly client: UsingClient;
-    interaction: ComponentCommandInteractionMap[Type] | ComponentInteraction;
+    interaction: ContextComponentCommandInteractionMap[Type];
     /**
      * Creates a new instance of the ComponentContext class.
      * @param client - The UsingClient instance.
      * @param interaction - The component interaction object.
      */
-    constructor(client: UsingClient, interaction: ComponentCommandInteractionMap[Type] | ComponentInteraction);
-    /**
-     * Gets the proxy object.
-     */
-    get proxy(): import("..").APIRoutes;
+    constructor(client: UsingClient, interaction: ContextComponentCommandInteractionMap[Type]);
+    command: ComponentCommand;
+    metadata: CommandMetadata<UnionToTuple<M>>;
+    globalMetadata: GlobalMetadata;
     /**
      * Gets the language object for the interaction's locale.
      */
@@ -63,6 +62,7 @@ export declare class ComponentContext<Type extends keyof ComponentCommandInterac
      * @returns A promise that resolves when the response is deleted.
      */
     deleteResponse(): Promise<void | undefined>;
+    modal(body: ModalCreateBodyRequest): Promise<void>;
     /**
      * Gets the channel of the interaction.
      * @param mode - The mode to fetch the channel.
@@ -100,13 +100,17 @@ export declare class ComponentContext<Type extends keyof ComponentCommandInterac
      * Gets the member of the interaction.
      */
     get member(): import("..").InteractionGuildMember | undefined;
-    isComponent(): this is ComponentContext<keyof ComponentCommandInteractionMap>;
+    isComponent(): this is ComponentContext<keyof ContextComponentCommandInteractionMap>;
+    isButton(): this is ComponentContext<'Button'>;
+    isChannelSelectMenu(): this is ComponentContext<'ChannelSelect'>;
+    isRoleSelectMenu(): this is ComponentContext<'RoleSelect'>;
+    isMentionableSelectMenu(): this is ComponentContext<'MentionableSelect'>;
+    isUserSelectMenu(): this is ComponentContext<'UserSelect'>;
+    isStringSelectMenu(): this is ComponentContext<'StringSelect'>;
 }
-export interface ComponentCommandInteractionMap {
-    ActionRow: never;
+export interface ContextComponentCommandInteractionMap {
     Button: ButtonInteraction;
     StringSelect: StringSelectMenuInteraction;
-    TextInput: never;
     UserSelect: UserSelectMenuInteraction;
     RoleSelect: RoleSelectMenuInteraction;
     MentionableSelect: MentionableSelectMenuInteraction;

package/lib/components/componentcontext.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentContext = void 0;
 const v10_1 = require("discord-api-types/v10");
-const basecontex_1 = require("../commands/basecontex");
+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 ComponentContext extends basecontex_1.BaseContext {
+class ComponentContext extends basecontext_1.BaseContext {
     client;
     interaction;
     /**
@@ -20,17 +20,14 @@ class ComponentContext extends basecontex_1.BaseContext {
         this.client = client;
         this.interaction = interaction;
     }
-    /**
-     * Gets the proxy object.
-     */
-    get proxy() {
-        return this.client.proxy;
-    }
+    command;
+    metadata = {};
+    globalMetadata = {};
     /**
      * Gets the language object for the interaction's locale.
      */
     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');
     }
     /**
      * Gets the custom ID of the interaction.
@@ -82,6 +79,9 @@ class ComponentContext extends basecontex_1.BaseContext {
     deleteResponse() {
         return this.interaction.deleteResponse();
     }
+    modal(body) {
+        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;
@@ -134,5 +134,23 @@ class ComponentContext extends basecontex_1.BaseContext {
     isComponent() {
         return true;
     }
+    isButton() {
+        return this.interaction.data.componentType === v10_1.ComponentType.Button;
+    }
+    isChannelSelectMenu() {
+        return this.interaction.componentType === v10_1.ComponentType.ChannelSelect;
+    }
+    isRoleSelectMenu() {
+        return this.interaction.componentType === v10_1.ComponentType.RoleSelect;
+    }
+    isMentionableSelectMenu() {
+        return this.interaction.componentType === v10_1.ComponentType.MentionableSelect;
+    }
+    isUserSelectMenu() {
+        return this.interaction.componentType === v10_1.ComponentType.UserSelect;
+    }
+    isStringSelectMenu() {
+        return this.interaction.componentType === v10_1.ComponentType.StringSelect;
+    }
 }
 exports.ComponentContext = ComponentContext;

package/lib/components/handler.d.ts

@@ -1,10 +1,13 @@
 /// <reference types="node" />
 import type { ComponentCallback, ListenerOptions, ModalSubmitCallback } from '../builders/types';
 import { LimitedCollection } from '../collection';
-import type { UsingClient } from '../commands';
+import { type UsingClient } from '../commands';
 import { BaseHandler, type Logger, type OnFailCallback } from '../common';
 import type { ComponentInteraction, ModalSubmitInteraction, StringSelectMenuInteraction } from '../structures';
-import { ComponentCommand, ModalCommand } from './command';
+import { ComponentCommand } from './componentcommand';
+import type { ComponentContext } from './componentcontext';
+import { ModalCommand } from './modalcommand';
+import type { ModalContext } from './modalcontext';
 type COMPONENTS = {
     components: {
         match: string | string[] | RegExp;
@@ -35,11 +38,13 @@ export declare class ComponentHandler extends BaseHandler {
     onModalSubmit(interaction: ModalSubmitInteraction): any;
     deleteValue(id: string, reason?: string): void;
     onMessageDelete(id: string): void;
-    load(componentsDir: string): Promise<void>;
+    load(componentsDir: string, instances?: {
+        new (): ModalCommand | ComponentCommand;
+    }[]): Promise<void>;
     reload(path: string): Promise<any>;
-    reloadAll(): Promise<void>;
-    executeComponent(interaction: ComponentInteraction): Promise<void>;
-    executeModal(interaction: ModalSubmitInteraction): Promise<void>;
+    reloadAll(stopIfFail?: boolean): Promise<void>;
+    executeComponent(context: ComponentContext): Promise<any>;
+    executeModal(context: ModalContext): Promise<any>;
     setHandlers({ callback }: {
         callback: ComponentHandler['callback'];
     }): void;

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);
@@ -21,7 +22,7 @@ class ComponentHandler extends common_1.BaseHandler {
         this.values.set(messageId, {
             components: [],
             options,
-            idle: options.idle
+            idle: options.idle && options.idle > 0
                 ? setTimeout(() => {
                     this.deleteValue(messageId);
                     options.onStop?.('idle', () => {
@@ -29,7 +30,7 @@ class ComponentHandler extends common_1.BaseHandler {
                     });
                 }, options.idle)
                 : undefined,
-            timeout: options.timeout
+            timeout: options.timeout && options.timeout > 0
                 ? setTimeout(() => {
                     this.deleteValue(messageId);
                     options.onStop?.('timeout', () => {
@@ -116,29 +117,38 @@ class ComponentHandler extends common_1.BaseHandler {
     onMessageDelete(id) {
         this.deleteValue(id, 'messageDelete');
     }
-    async load(componentsDir) {
-        const paths = await this.loadFilesK(await this.getFiles(componentsDir));
-        for (let i = 0; i < paths.length; i++) {
+    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 (const value of paths) {
             let component;
             try {
-                component = this.callback(paths[i].file);
+                component = this.callback(value.file);
                 if (!component)
                     continue;
             }
             catch (e) {
-                if (e instanceof Error && e.message === 'paths[i].file is not a constructor') {
-                    this.logger.warn(`${paths[i].path
+                if (e instanceof Error && e.message.includes('is not a constructor')) {
+                    this.logger.warn(`${value.path
                         .split(process.cwd())
                         .slice(1)
                         .join(process.cwd())} doesn't export the class by \`export default <ComponentCommand>\``);
                 }
                 else
-                    this.logger.warn(e, paths[i]);
+                    this.logger.warn(e, value);
                 continue;
             }
-            if (!(component instanceof command_1.ModalCommand) && !(component instanceof command_1.ComponentCommand))
+            if (!(component instanceof modalcommand_1.ModalCommand || component instanceof componentcommand_1.ComponentCommand))
                 continue;
-            component.__filePath = paths[i].path;
+            component.props ??= this.client.options.commands?.defaults?.props ?? {};
+            const is = component instanceof modalcommand_1.ModalCommand ? 'modals' : 'components';
+            component.onInternalError ??= this.client.options?.[is]?.defaults?.onInternalError;
+            component.onMiddlewaresError ??= this.client.options?.[is]?.defaults?.onMiddlewaresError;
+            component.onRunError ??= this.client.options?.[is]?.defaults?.onRunError;
+            component.onAfterRun ??= this.client.options?.[is]?.defaults?.onAfterRun;
+            component.__filePath = value.path;
             this.commands.push(component);
         }
     }
@@ -149,7 +159,7 @@ class ComponentHandler extends common_1.BaseHandler {
             x.__filePath?.endsWith(`${path}.ts`) ||
             x.__filePath?.endsWith(path) ||
             x.__filePath === path);
-        if (!component || !component.__filePath)
+        if (!component?.__filePath)
             return null;
         delete require.cache[component.__filePath];
         const index = this.client.components.commands.findIndex(x => x.__filePath === component.__filePath);
@@ -162,25 +172,57 @@ class ComponentHandler extends common_1.BaseHandler {
         this.client.components.commands.push(command);
         return imported;
     }
-    async reloadAll() {
-        if (!this.client.components)
-            return;
-        for (const i of this.client.components.commands) {
-            if (!i.__filePath)
-                return this.logger.warn('Unknown command dont have __filePath property', i);
-            await this.reload(i.__filePath);
+    async reloadAll(stopIfFail = true) {
+        for (const i of this.commands) {
+            try {
+                await this.reload(i.__filePath ?? '');
+            }
+            catch (e) {
+                if (stopIfFail) {
+                    throw e;
+                }
+            }
         }
     }
-    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 +231,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,16 @@
+import type { ExtraProps, 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)[];
+    props: ExtraProps;
+    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,10 @@
+"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 = [];
+    props;
+}
+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;
+}