seyfert 4.5.0 → 5.0.0

package/lib/components/handler.d.ts

@@ -8,6 +8,7 @@ import { ComponentCommand } from './componentcommand';
 import type { ComponentContext } from './componentcontext';
 import { ModalCommand } from './modalcommand';
 import type { ModalContext } from './modalcontext';
+type ComponentSetTransformer = (component: ComponentCommands) => ComponentCommands | false | void;
 type UserMatches = string | string[] | RegExp;
 type COMPONENTS = {
     components: {
@@ -49,17 +50,26 @@ export declare class ComponentHandler extends BaseHandler {
     onModalSubmit(interaction: ModalSubmitInteraction): any;
     deleteValue(id: string, reason?: string): void;
     clearValue(id: string): COMPONENTS | undefined;
-    stablishDefaults(component: ComponentCommands): void;
-    set(instances: (new () => ComponentCommands)[]): void;
-    load(componentsDir: string): Promise<void>;
+    establishDefaults(component: ComponentCommands): void;
+    private normalizeLoadOptions;
+    private materializeComponent;
+    set(instances: SeteableComponentCommand[], optionsOrTransform?: ComponentSetTransformer | ComponentLoadOptions): ComponentCommands[];
+    load(componentsDir: string, options?: ComponentLoadOptions): Promise<void>;
     reload(path: string): Promise<any>;
     reloadAll(stopIfFail?: boolean): Promise<void>;
     execute(i: ComponentCommands, context: ComponentContext | ModalContext): Promise<any>;
     executeComponent(context: ComponentContext): Promise<void>;
     executeModal(context: ModalContext): Promise<void>;
-    onFile(file: FileLoaded<new () => ComponentCommands>): (new () => ComponentCommands)[] | undefined;
-    callback(file: {
-        new (): ComponentCommands;
-    }): ComponentCommands | false;
+    onFile(file: FileLoaded<HandleableComponentCommand>): HandleableComponentCommand[] | undefined;
+    callback(file: SeteableComponentCommand, create?: ComponentLoadCreator): ComponentCommands | false;
+}
+export type HandleableComponentCommand = (new () => ComponentCommand) | (new () => ModalCommand);
+export type SeteableComponentCommand = HandleableComponentCommand | ComponentCommands;
+export type ComponentLoadKind = 'component' | 'modal';
+export type ComponentLoadCreator = <T extends HandleableComponentCommand>(kind: ComponentLoadKind, constructor: T, next: () => InstanceType<T>) => InstanceType<T>;
+export type ComponentLoadTransformer = (kind: ComponentLoadKind, component: ComponentCommands) => ComponentCommands | false | void;
+export interface ComponentLoadOptions {
+    create?: ComponentLoadCreator;
+    transform?: ComponentLoadTransformer;
 }
 export {};

package/lib/components/handler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentHandler = void 0;
+const plugins_1 = require("../client/plugins");
 const collection_1 = require("../collection");
 const commands_1 = require("../commands");
 const common_1 = require("../common");
@@ -78,15 +79,29 @@ class ComponentHandler extends common_1.BaseHandler {
                 if (!collector)
                     return resolve(null);
                 let nodeTimeout;
-                this.values.get(messageId).__run(customId, interaction => {
+                let cleaned = false;
+                const component = {
+                    callback: interaction => {
+                        cleanup();
+                        //@ts-expect-error generic
+                        resolve(interaction);
+                    },
+                    match: this.createMatchCallback(customId),
+                };
+                const cleanup = () => {
+                    if (cleaned)
+                        return;
+                    cleaned = true;
                     clearTimeout(nodeTimeout);
-                    //@ts-expect-error generic
-                    resolve(interaction);
-                });
+                    const index = collector.components.indexOf(component);
+                    if (index !== -1)
+                        collector.components.splice(index, 1);
+                };
+                collector.components.push(component);
                 if (timeout && timeout > 0)
                     nodeTimeout = setTimeout(() => {
+                        cleanup();
                         resolve(null);
-                        // by default 15 seconds in case user don't do anything
                     }, timeout);
             }),
             resetTimeouts: () => {
@@ -144,8 +159,9 @@ class ComponentHandler extends common_1.BaseHandler {
         return this.modals.has(interaction.user.id);
     }
     onModalSubmit(interaction) {
-        setImmediate(() => this.modals.delete(interaction.user.id));
-        return this.modals.get(interaction.user.id)?.(interaction);
+        const callback = this.modals.get(interaction.user.id);
+        this.modals.delete(interaction.user.id);
+        return callback?.(interaction);
     }
     deleteValue(id, reason) {
         const component = this.clearValue(id);
@@ -164,7 +180,7 @@ class ComponentHandler extends common_1.BaseHandler {
         this.values.delete(id);
         return component;
     }
-    stablishDefaults(component) {
+    establishDefaults(component) {
         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;
@@ -173,11 +189,37 @@ class ComponentHandler extends common_1.BaseHandler {
         component.onAfterRun ??= this.client.options?.[is]?.defaults?.onAfterRun;
         component.onBeforeMiddlewares ??= this.client.options?.[is]?.defaults?.onBeforeMiddlewares;
     }
-    set(instances) {
+    normalizeLoadOptions(options) {
+        return typeof options === 'function' ? { transform: (_kind, component) => options(component) } : (options ?? {});
+    }
+    materializeComponent(value, options = {}, filePath) {
+        let component;
+        component = this.callback(value, options.create);
+        if (!component)
+            return false;
+        if (!(component instanceof modalcommand_1.ModalCommand || component instanceof componentcommand_1.ComponentCommand))
+            return false;
+        this.establishDefaults(component);
+        if (filePath)
+            component.__filePath = filePath;
+        const kind = component instanceof modalcommand_1.ModalCommand ? 'modal' : 'component';
+        const wrapped = options.transform?.(kind, component) ?? component;
+        if (!wrapped)
+            return false;
+        if (wrapped !== component) {
+            component = wrapped;
+            component.__filePath ??= filePath;
+            this.establishDefaults(component);
+        }
+        return component;
+    }
+    set(instances, optionsOrTransform) {
+        const options = this.normalizeLoadOptions(optionsOrTransform);
+        const added = [];
         for (const i of instances) {
             let component;
             try {
-                component = this.callback(i);
+                component = this.materializeComponent(i, options);
                 if (!component)
                     continue;
             }
@@ -185,11 +227,12 @@ class ComponentHandler extends common_1.BaseHandler {
                 this.logger.warn(e, i);
                 continue;
             }
-            this.stablishDefaults(component);
             this.commands.push(component);
+            added.push(component);
         }
+        return added;
     }
-    async load(componentsDir) {
+    async load(componentsDir, options = {}) {
         const paths = await this.loadFilesK(await this.getFiles(componentsDir));
         for (const { components, file } of paths.map(x => ({ components: this.onFile(x.file), file: x }))) {
             if (!components)
@@ -197,7 +240,7 @@ class ComponentHandler extends common_1.BaseHandler {
             for (const value of components) {
                 let component;
                 try {
-                    component = this.callback(value);
+                    component = this.callback(value, options.create);
                     if (!component)
                         continue;
                 }
@@ -214,8 +257,17 @@ class ComponentHandler extends common_1.BaseHandler {
                 }
                 if (!(component instanceof modalcommand_1.ModalCommand || component instanceof componentcommand_1.ComponentCommand))
                     continue;
-                this.stablishDefaults(component);
+                this.establishDefaults(component);
                 component.__filePath = file.path;
+                const kind = component instanceof modalcommand_1.ModalCommand ? 'modal' : 'component';
+                const wrapped = options.transform?.(kind, component) ?? component;
+                if (!wrapped)
+                    continue;
+                if (wrapped !== component) {
+                    component = wrapped;
+                    component.__filePath ??= file.path;
+                    this.establishDefaults(component);
+                }
                 this.commands.push(component);
             }
         }
@@ -223,7 +275,7 @@ class ComponentHandler extends common_1.BaseHandler {
     async reload(path) {
         if (!this.client.components)
             return;
-        if ((0, common_1.isCloudfareWorker)()) {
+        if ((0, common_1.isCloudflareWorker)()) {
             throw new common_1.SeyfertError('RELOAD_NOT_SUPPORTED', {
                 metadata: { detail: 'Reload in Cloudflare worker is not supported' },
             });
@@ -240,9 +292,11 @@ class ComponentHandler extends common_1.BaseHandler {
             return null;
         this.client.components.commands.splice(index, 1);
         const imported = await (0, common_1.magicImport)(component.__filePath).then(x => x.default ?? x);
-        const command = new imported();
-        command.__filePath = component.__filePath;
-        this.client.components.commands.push(command);
+        const options = this.client.createPluginComponentLoadOptions?.() ?? {};
+        const command = this.materializeComponent(imported, options, component.__filePath);
+        if (!command)
+            return null;
+        this.client.components.commands.splice(index, 0, command);
         return imported;
     }
     async reloadAll(stopIfFail = true) {
@@ -258,39 +312,41 @@ class ComponentHandler extends common_1.BaseHandler {
         }
     }
     async execute(i, context) {
-        try {
-            await i.onBeforeMiddlewares?.(context);
-            const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
-            if (resultRunGlobalMiddlewares.pass) {
-                return;
-            }
-            if ('error' in resultRunGlobalMiddlewares) {
-                return await 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 await i.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
-            }
+        return (0, plugins_1.runContextScopes)(context.client.options.contextScopes, context, async () => {
             try {
-                await i.run(context);
-                await i.onAfterRun?.(context, undefined);
+                await i.onBeforeMiddlewares?.(context);
+                const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
+                if (resultRunGlobalMiddlewares.pass) {
+                    return;
+                }
+                if ('error' in resultRunGlobalMiddlewares) {
+                    return await i.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error', resultRunGlobalMiddlewares.metadata ?? { middleware: 'unknown', scope: 'global' });
+                }
+                const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, i.middlewares, false);
+                if (resultRunMiddlewares.pass) {
+                    return;
+                }
+                if ('error' in resultRunMiddlewares) {
+                    return await i.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error', resultRunMiddlewares.metadata ?? { middleware: 'unknown', scope: 'command' });
+                }
+                try {
+                    await i.run(context);
+                    await i.onAfterRun?.(context, undefined);
+                }
+                catch (error) {
+                    await i.onRunError?.(context, error);
+                    await i.onAfterRun?.(context, error);
+                }
             }
             catch (error) {
-                await i.onRunError?.(context, error);
-                await i.onAfterRun?.(context, error);
-            }
-        }
-        catch (error) {
-            try {
-                await i.onInternalError?.(this.client, error);
-            }
-            catch (err) {
-                this.client.logger.error(`[${i.customId ?? 'Component/Modal command'}] Internal error:`, err);
+                try {
+                    await i.onInternalError?.(this.client, i, error);
+                }
+                catch (err) {
+                    this.client.logger.error(`[${i.customId ?? 'Component/Modal command'}] Internal error:`, err);
+                }
             }
-        }
+        });
     }
     async executeComponent(context) {
         for (const i of this.commands) {
@@ -323,8 +379,11 @@ class ComponentHandler extends common_1.BaseHandler {
     onFile(file) {
         return file.default ? [file.default] : undefined;
     }
-    callback(file) {
-        return new file();
+    callback(file, create) {
+        if (typeof file !== 'function')
+            return file;
+        const kind = file.prototype instanceof modalcommand_1.ModalCommand ? 'modal' : 'component';
+        return create?.(kind, file, () => new file()) ?? new file();
     }
 }
 exports.ComponentHandler = ComponentHandler;

package/lib/components/index.d.ts

@@ -19,6 +19,7 @@ export type ActionRowMessageComponents = Exclude<MessageComponents, TextInputCom
 export type AllComponents = MessageComponents | TopLevelComponents | ContainerComponents | BaseComponent<ComponentType>;
 export * from './componentcommand';
 export * from './componentcontext';
+export * from './interactioncontext';
 export * from './modalcommand';
 export * from './modalcontext';
 export type TopLevelComponents = SectionComponent | ActionRowMessageComponents | TextDisplayComponent | ContainerComponent | FileComponent | MediaGalleryComponent | BaseComponent<APITopLevelComponent['type']>;

package/lib/components/index.js

@@ -34,6 +34,7 @@ const Thumbnail_1 = require("./Thumbnail");
 const UserSelectMenuComponent_1 = require("./UserSelectMenuComponent");
 __exportStar(require("./componentcommand"), exports);
 __exportStar(require("./componentcontext"), exports);
+__exportStar(require("./interactioncontext"), exports);
 __exportStar(require("./modalcommand"), exports);
 __exportStar(require("./modalcontext"), exports);
 /**

package/lib/components/interactioncontext.d.ts

@@ -0,0 +1,45 @@
+import type { AllChannels, ReturnCache } from '..';
+import type { GuildMemberStructure, GuildStructure, InteractionGuildMemberStructure, UserStructure, WebhookMessageStructure } from '../client/transformers';
+import type { CommandMetadata, ExtendContext, GlobalMetadata, RegisteredMiddlewares, UsingClient } from '../commands';
+import { BaseContext } from '../commands/basecontext';
+import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MakeRequired, MessageWebhookCreateBodyRequest, ModalCreateBodyRequest, ModalCreateOptions, UnionToTuple, When } from '../common';
+import type { ModalSubmitInteraction } from '../structures';
+import { type RESTGetAPIGuildQuery } from '../types';
+export interface InteractionResponseContext<I> extends BaseContext, ExtendContext {
+}
+export declare abstract class InteractionResponseContext<I = unknown, M extends keyof RegisteredMiddlewares = never> extends BaseContext {
+    readonly client: UsingClient;
+    interaction: I;
+    constructor(client: UsingClient, interaction: I);
+    metadata: CommandMetadata<UnionToTuple<M>>;
+    globalMetadata: GlobalMetadata;
+    private get _interaction();
+    get t(): import("..").SeyfertLocale;
+    get customId(): string;
+    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure, void>>;
+    deferReply<FR extends boolean = false>(ephemeral?: boolean, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure, undefined>>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessageStructure>;
+    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure, void>>;
+    followup(body: MessageWebhookCreateBodyRequest): Promise<WebhookMessageStructure>;
+    fetchResponse(): Promise<WebhookMessageStructure>;
+    deleteResponse(): Promise<void>;
+    modal(body: ModalCreateBodyRequest, options?: undefined): Promise<undefined>;
+    modal(body: ModalCreateBodyRequest, options: ModalCreateOptions): Promise<ModalSubmitInteraction | null>;
+    channel(mode?: 'rest' | 'flow'): Promise<AllChannels>;
+    channel(mode: 'cache'): ReturnCache<AllChannels>;
+    me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure | undefined>;
+    me(mode: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
+    guild(mode?: 'rest' | 'flow', query?: RESTGetAPIGuildQuery): Promise<GuildStructure<'cached' | 'api'> | undefined>;
+    guild(mode: 'cache', query?: RESTGetAPIGuildQuery): ReturnCache<GuildStructure<'cached'> | undefined>;
+    get guildId(): string | undefined;
+    get channelId(): string;
+    get author(): UserStructure;
+    get member(): InteractionGuildMemberStructure | undefined;
+    inGuild(): boolean;
+}
+export interface GuildInteractionResponseContext<M extends keyof RegisteredMiddlewares = never> extends Omit<MakeRequired<InteractionResponseContext<unknown, M>, 'guildId' | 'member'>, 'guild' | 'me'> {
+    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'>>;
+    guild(mode: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
+    me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
+    me(mode: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
+}

package/lib/components/interactioncontext.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionResponseContext = void 0;
+const basecontext_1 = require("../commands/basecontext");
+const types_1 = require("../types");
+class InteractionResponseContext extends basecontext_1.BaseContext {
+    client;
+    interaction;
+    constructor(client, interaction) {
+        super(client);
+        this.client = client;
+        this.interaction = interaction;
+    }
+    metadata = {};
+    globalMetadata = {};
+    get _interaction() {
+        return this.interaction;
+    }
+    get t() {
+        return this.client.t(this._interaction.locale ?? this.client.langs?.defaultLang ?? 'en-US');
+    }
+    get customId() {
+        return this._interaction.customId;
+    }
+    write(body, fetchReply) {
+        return this._interaction.write(body, fetchReply);
+    }
+    deferReply(ephemeral = false, fetchReply) {
+        return this._interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined, fetchReply);
+    }
+    editResponse(body) {
+        return this._interaction.editResponse(body);
+    }
+    editOrReply(body, fetchReply) {
+        return this._interaction.editOrReply(body, fetchReply);
+    }
+    followup(body) {
+        return this._interaction.followup(body);
+    }
+    fetchResponse() {
+        return this._interaction.fetchResponse();
+    }
+    deleteResponse() {
+        return this._interaction.deleteResponse();
+    }
+    modal(body, options) {
+        if (options === undefined)
+            return this._interaction.modal(body);
+        return this._interaction.modal(body, options);
+    }
+    channel(mode = 'flow') {
+        if (mode === 'cache')
+            return this.client.cache.adapter.isAsync ? Promise.resolve(this._interaction.channel) : this._interaction.channel;
+        return this.client.channels.fetch(this.channelId, mode === 'rest');
+    }
+    me(mode = 'flow') {
+        if (!this.guildId)
+            return mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();
+        switch (mode) {
+            case 'cache':
+                return this.client.cache.members?.get(this.client.botId, this.guildId);
+            default:
+                return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
+        }
+    }
+    guild(mode = 'flow', query) {
+        if (!this.guildId)
+            return (mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve());
+        switch (mode) {
+            case 'cache':
+                return (this.client.cache.guilds?.get(this.guildId) ||
+                    (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined));
+            default:
+                return this.client.guilds.fetch(this.guildId, { force: mode === 'rest', query });
+        }
+    }
+    get guildId() {
+        return this._interaction.guildId;
+    }
+    get channelId() {
+        return this._interaction.channelId ?? this._interaction.channel.id;
+    }
+    get author() {
+        return this._interaction.user;
+    }
+    get member() {
+        return this._interaction.member;
+    }
+    inGuild() {
+        return !!this.guildId;
+    }
+}
+exports.InteractionResponseContext = InteractionResponseContext;

package/lib/components/modalcommand.d.ts

@@ -1,4 +1,5 @@
-import type { ExtraProps, RegisteredMiddlewares, UsingClient } from '../commands';
+import type { PluginMiddlewareDenialMetadata } from '../client/plugins/types';
+import type { ExtraProps, ResolvedRegisteredMiddlewares, UsingClient } from '../commands';
 import type { ModalContext } from './modalcontext';
 export interface ModalCommand {
     __filePath?: string;
@@ -8,11 +9,11 @@ export declare abstract class ModalCommand {
     filter?(context: ModalContext): Promise<boolean> | boolean;
     customId?: string | RegExp;
     abstract run(context: ModalContext): any;
-    middlewares: (keyof RegisteredMiddlewares)[];
+    middlewares: readonly (keyof ResolvedRegisteredMiddlewares)[];
     props: ExtraProps;
     onBeforeMiddlewares?(context: ModalContext): any;
     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;
+    onMiddlewaresError?(context: ModalContext, error: string, metadata: PluginMiddlewareDenialMetadata): any;
+    onInternalError?(client: UsingClient, modal: ModalCommand, error?: unknown): any;
 }

package/lib/components/modalcontext.d.ts

@@ -1,15 +1,16 @@
-import type { AllChannels, ModalCommand, ModalSubmitInteraction, ReturnCache } from '..';
-import type { GuildMemberStructure, GuildStructure, InteractionGuildMemberStructure, UserStructure, WebhookMessageStructure } from '../client/transformers';
-import type { CommandMetadata, ExtendContext, GlobalMetadata, RegisteredMiddlewares, UsingClient } from '../commands';
+import type { AllChannels, Attachment, ModalCommand, ModalSubmitInteraction, ReturnCache } from '..';
+import type { GuildMemberStructure, GuildRoleStructure, GuildStructure, InteractionGuildMemberStructure, UserStructure, WebhookMessageStructure } from '../client/transformers';
+import type { CommandMetadata, ExtendContext, GlobalMetadata, ResolvedRegisteredMiddlewares, UsingClient } from '../commands';
 import { BaseContext } from '../commands/basecontext';
-import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MakeRequired, MessageWebhookCreateBodyRequest, ModalCreateBodyRequest, ModalCreateOptions, UnionToTuple, When } from '../common';
+import type { ComponentInteractionMessageUpdate, InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MakeRequired, MessageWebhookCreateBodyRequest, ModalCreateBodyRequest, ModalCreateOptions, When } from '../common';
+import { type RESTGetAPIGuildQuery } from '../types';
 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 {
+export declare class ModalContext<M extends keyof ResolvedRegisteredMiddlewares = never> extends BaseContext {
     readonly client: UsingClient;
     interaction: ModalSubmitInteraction;
     /**
@@ -19,50 +20,66 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      */
     constructor(client: UsingClient, interaction: ModalSubmitInteraction);
     command: ModalCommand;
-    metadata: CommandMetadata<UnionToTuple<M>>;
+    metadata: CommandMetadata<M>;
     globalMetadata: GlobalMetadata;
-    get customId(): string;
     get components(): {
-        type: import("../types").ComponentType.Label;
+        type: import("..").ComponentType.Label;
         id?: number | undefined;
         component?: {
-            type: import("../types").ComponentType.FileUpload;
+            type: import("..").ComponentType.FileUpload;
             values: string[];
             id?: number | undefined;
             customId: string;
         } | {
-            type: import("../types").ComponentType.RadioGroup;
+            type: import("..").ComponentType.RadioGroup;
             value: string;
             id?: number | undefined;
             customId: string;
         } | {
-            type: import("../types").ComponentType.CheckboxGroup;
+            type: import("..").ComponentType.CheckboxGroup;
             values: string[];
             id?: number | undefined;
             customId: string;
         } | {
-            type: import("../types").ComponentType.Checkbox;
+            type: import("..").ComponentType.Checkbox;
             value: boolean;
             id?: number | undefined;
             customId: string;
         } | {
-            type: import("../types").ComponentType.TextInput;
+            type: import("..").ComponentType.TextInput;
             value: string;
             id?: number | undefined;
             customId: string;
         } | {
-            type: import("../types").ComponentType.StringSelect | import("../types").ComponentType.UserSelect | import("../types").ComponentType.RoleSelect | import("../types").ComponentType.MentionableSelect | import("../types").ComponentType.ChannelSelect;
+            type: import("..").ComponentType.StringSelect | import("..").ComponentType.UserSelect | import("..").ComponentType.RoleSelect | import("..").ComponentType.MentionableSelect | import("..").ComponentType.ChannelSelect;
             values: string[];
             id?: number | undefined;
             customId: string;
         } | undefined;
     }[];
+    get customId(): string;
     /**
      * Gets the language object for the interaction's locale.
      */
-    get t(): import("..").__InternalParseLocale<import("..").DefaultLocale> & {
-        get(locale?: string): import("..").DefaultLocale;
-    };
+    get t(): import("..").SeyfertLocale;
+    getChannels(customId: string, required: true): AllChannels[];
+    getChannels(customId: string, required?: false): AllChannels[] | void;
+    getRoles(customId: string, required: true): GuildRoleStructure[];
+    getRoles(customId: string, required?: false): GuildRoleStructure[] | void;
+    getUsers(customId: string, required: true): UserStructure[];
+    getUsers(customId: string, required?: false): UserStructure[] | void;
+    getMentionables(customId: string, required: true): (UserStructure | GuildRoleStructure | InteractionGuildMemberStructure)[];
+    getMentionables(customId: string, required?: false): (UserStructure | GuildRoleStructure | InteractionGuildMemberStructure)[] | void;
+    getRadioValues(customId: string, required: true): string;
+    getRadioValues(customId: string, required?: false): string | void;
+    getCheckboxValues(customId: string, required: true): string[];
+    getCheckboxValues(customId: string, required?: false): string[] | void;
+    getCheckbox(customId: string, required: true): boolean;
+    getCheckbox(customId: string, required?: false): boolean | void;
+    getInputValue(customId: string, required: true): string | string[];
+    getInputValue(customId: string, required?: false): string | string[] | undefined;
+    getFiles(customId: string, required: true): Attachment[];
+    getFiles(customId: string, required?: false): Attachment[] | undefined;
     /**
      * Writes a response to the interaction.
      * @param body - The body of the response.
@@ -74,6 +91,8 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      * @param ephemeral - Whether the reply should be ephemeral or not.
      */
     deferReply<FR extends boolean = false>(ephemeral?: boolean, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure, undefined>>;
+    update<WR extends boolean = false>(body: ComponentInteractionMessageUpdate, withResponse?: WR): Promise<When<WR, WebhookMessageStructure, undefined>>;
+    deferUpdate(): Promise<undefined>;
     /**
      * Edits the response of the interaction.
      * @param body - The updated body of the response.
@@ -116,7 +135,7 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      * @param mode - The mode to fetch the guild.
      * @returns A promise that resolves to the guild.
      */
-    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'> | undefined>;
+    guild(mode?: 'rest' | 'flow', query?: RESTGetAPIGuildQuery): Promise<GuildStructure<'cached' | 'api'> | undefined>;
     guild(mode: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
     /**
      * Gets the ID of the guild of the interaction.
@@ -137,8 +156,8 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
     isModal(): this is ModalContext<M>;
     inGuild(): this is GuildModalContext<M>;
 }
-export interface GuildModalContext<M extends keyof RegisteredMiddlewares = never> extends Omit<MakeRequired<ModalContext<M>, 'guildId' | 'member'>, 'guild' | 'me'> {
-    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'>>;
+export interface GuildModalContext<M extends keyof ResolvedRegisteredMiddlewares = never> extends Omit<MakeRequired<ModalContext<M>, 'guildId' | 'member'>, 'guild' | 'me'> {
+    guild(mode?: 'rest' | 'flow', query?: RESTGetAPIGuildQuery): Promise<GuildStructure<'cached' | 'api'>>;
     guild(mode: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
     me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
     me(mode: 'cache'): ReturnCache<GuildMemberStructure | undefined>;