@seedcord/gateway 0.5.1 → 0.6.0

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import "reflect-metadata";
 import { WinstonConsoleSink, WinstonFileSink } from "@seedcord/logger/node";
-import { AutocompletableNames, AutocompleteRouteBrand, CacheFor, ChoiceValueOf, ComponentDefsBrand, ComponentKindBrand, ContextMenuKindBrand, ContextMenuLeaves, ContextMenuNamesBrand, EntryFor, FocusedField, GateFitsWith, HasComponentDefs, Initializeable, MatchArms, MenuCacheFor, NamesFor, PageCursor, SingleParams, SlashOptions as SlashOptions$1, SlashRouteBrand } from "@seedcord/core/internal";
-import { ArraySourceBase, AutocompleteOptions, BaseHandler as BaseHandler$1, BaseReplySender, Bus, CoreBase, CursorSourceBase, DispatchContext, Gate, GateContextBase, GateNoticeOptions, GuildPermissionsContext, InteractionKind, ModalLike, Notice, PageSourceBase, PaginatorBase, PaginatorConfig, PermissionNoticeOverrides, PermissionScope, RepliableHandler as RepliableHandler$1, RequiredOf, ResolvedEmoji, SlashRegistry, Subscriber as Subscriber$1, SubscriptionKey, WebhookLog as WebhookLog$1 } from "@seedcord/core";
+import { AutocompletableNames, AutocompleteRouteBrand, CacheFor, ChoiceValueOf, ComponentDefsBrand, ComponentKindBrand, ContextMenuKindBrand, ContextMenuLeaves, ContextMenuNamesBrand, EntryFor, FocusedField, GateFitsWith, HasComponentDefs, Initializeable, MatchArms, MenuCacheFor, MiddlewareKindsBrand, NamesFor, PageCursor, SingleParams, SlashOptions as SlashOptions$1, SlashRouteBrand } from "@seedcord/core/internal";
+import { ArraySourceBase, AutocompleteOptions, BaseHandler as BaseHandler$1, BaseReplySender, Bus, CoreBase, CursorSourceBase, DispatchContext, DispatchOutcome, DispatchResult, EventDispatchResult, Gate, GateContextBase, GateNoticeOptions, GuildPermissionsContext, HandlerOutcome, InteractionKind, MiddlewareKind, ModalLike, Notice, PageSourceBase, PaginatorBase, PaginatorConfig, PermissionNoticeOverrides, PermissionScope, RepliableHandler as RepliableHandler$1, RequiredOf, ResolvedEmoji, SlashRegistry, Subscriber as Subscriber$1, SubscriptionKey, WebhookLog as WebhookLog$1 } from "@seedcord/core";
 import { Logger } from "@seedcord/logger";
 import { APIInteractionGuildMember, APIModalInteractionResponseCallbackData, AnySelectMenuInteraction, ApplicationCommandOptionChoiceData, ApplicationCommandType, ApplicationEmoji, AutocompleteInteraction, BaseMessageOptions, BooleanCache, ButtonInteraction, ButtonStyle, CacheType, CacheTypeReducer, ChannelSelectMenuInteraction, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, CommandInteractionOption, ContextMenuCommandInteraction, Events, Guild, GuildEmoji, GuildMember, Interaction, MentionableSelectMenuInteraction, Message, MessageContextMenuCommandInteraction, ModalSubmitFields, ModalSubmitInteraction, Role, RoleSelectMenuInteraction, StringSelectMenuInteraction, TextChannel, User, UserContextMenuCommandInteraction, UserSelectMenuInteraction } from "discord.js";
 import { Plugin as Plugin$1, PluginLifecycleSpec, PluginOptions, PluginOptions as PluginOptions$1 } from "@seedcord/core/plugin";
@@ -27,9 +27,25 @@ declare module '@seedcord/core/internal' {
     };
     /** Triggered before an event's handlers run. An event that no handler registered never triggers it. */
     eventDispatching: { [Name in keyof ClientEvents]: {
+      dispatchId: string;
       name: Name;
       args: ClientEvents[Name];
     }; }[keyof ClientEvents];
+    /**
+     * Triggered once an event's handlers settle, pairing with `eventDispatching`. A fire that runs no
+     * handler triggers neither.
+     */
+    eventDispatched: {
+      /** The same id `eventDispatching` published for this fire. */
+      dispatchId: string;
+      name: keyof ClientEvents;
+      /** How the middleware chain ended. A chain that refused the event leaves `handlers` empty. */
+      outcome: DispatchOutcome;
+      /** One entry per handler that ran, in the order they ran. */
+      handlers: readonly HandlerOutcome[];
+      /** Dispatch entry until every handler settles. A clock change never affects it. */
+      durationMs: number;
+    };
     /** Triggered for every interaction the bot receives, before routing. */
     anyInteraction: {
       interaction: Interaction;
@@ -159,6 +175,8 @@ declare class InteractionDispatcher implements Initializeable, HmrAware {
   private processInteraction;
   private answer;
   private buildHandler;
+  private reporterFor;
+  private refusalBeforeHandler;
   private runMiddlewares;
   private gateRefusal;
   private handleInteraction;
@@ -469,7 +487,7 @@ type EventMatchArms<Names extends ValidNonInteractionKeys, Ret> = { [Name in Nam
  */
 declare abstract class EventHandler<in out Names extends ValidNonInteractionKeys> extends BaseHandler<ClientEvents[Names]> {
   private readonly firedEvent;
-  constructor(event: ClientEvents[Names], core: Core, eventName?: Names);
+  constructor(event: ClientEvents[Names], core: Core, dispatch: DispatchContext, eventName?: Names);
   protected readonly event: SingleEventPayload<Names>;
   /**
    * Run the arm for whichever event fired. Use this only when the handler is registered for several
@@ -513,7 +531,7 @@ declare abstract class EventHandler<in out Names extends ValidNonInteractionKeys
  */
 declare abstract class EventMiddleware<in out EventName extends ValidNonInteractionKeys = ValidNonInteractionKeys> extends BaseHandler<ClientEvents[EventName]> {
   private readonly firedEvent;
-  constructor(event: ClientEvents[EventName], core: Core, eventName?: EventName);
+  constructor(event: ClientEvents[EventName], core: Core, dispatch: DispatchContext, eventName?: EventName);
   protected readonly event: SingleEventPayload<EventName>;
   /**
    * The event that fired this middleware. Read it on a catchall or multi-event middleware, where `this.event`
@@ -521,6 +539,23 @@ declare abstract class EventMiddleware<in out EventName extends ValidNonInteract
    * `this.event` directly and does not need this.
    */
   protected get eventName(): EventName;
+  /**
+   * Runs once the event finishes, newest middleware first. Every middleware whose `execute()`
+   * started gets the call, a stopped chain and a throw included. Implement it to release something
+   * this middleware took in `execute()`. A throw in here is logged and goes no further.
+   *
+   * @param result - `outcome` reports the chain alone. `handlers` holds one entry per handler that
+   * ran, empty exactly when the chain stopped the event.
+   *
+   * @example
+   * ```ts
+   * // the base declares it. an implementation carries `override`.
+   * override async after(result: EventDispatchResult) {
+   *     this.span.end();
+   * }
+   * ```
+   */
+  after?(result: EventDispatchResult): Promise<void>;
 }
 //#endregion
 //#region src/bot/decorators/Events.d.ts
@@ -582,7 +617,7 @@ type SentMessage = Message;
 /** Writes interaction responses through discord.js. The repliable handler bases and the dispatcher construct it. */
 declare class ReplySender extends BaseReplySender<SentMessage, GatewayFile> {
   private readonly interaction;
-  constructor(interaction: Repliables, routeId: string, bus: Bus);
+  constructor(interaction: Repliables, dispatch: DispatchContext, bus: Bus);
   protected writeReply(response: GatewayReplyResponse | string, opts?: SendOpts): Promise<SentMessage | undefined>;
   protected writeDefer(opts?: DeferOpts): Promise<void>;
   protected writeDeferUpdate(): Promise<void>;
@@ -615,7 +650,7 @@ declare class ReplySender extends BaseReplySender<SentMessage, GatewayFile> {
 declare abstract class RepliableHandler<Event extends Repliables> extends RepliableHandler$1<Event, Core, SentMessage, GatewayFile, ReplySender> {
   /** @internal */
   getEvent(): Event;
-  protected buildSender(event: Event, core: Core, routeId: string): ReplySender;
+  protected buildSender(event: Event, core: Core, dispatch: DispatchContext): ReplySender;
 }
 //#endregion
 //#region src/handlers/interaction/InteractionHandler.d.ts
@@ -629,7 +664,7 @@ declare abstract class RepliableHandler<Event extends Repliables> extends Replia
  * @typeParam Repliable - The interaction type this handler processes
  */
 declare abstract class InteractionHandler<Repliable extends Repliables> extends RepliableHandler<Repliable> {
-  constructor(event: Repliable, core: Core, dispatch?: DispatchContext);
+  constructor(event: Repliable, core: Core, dispatch: DispatchContext);
   /**
    * Open a modal. Must be the initial response to this interaction. The modal kind rejects this call at
    * compile time (Discord forbids a modal in response to a modal).
@@ -771,248 +806,649 @@ type FitAll<TCtor extends AnyHandlerCtor, Gates extends readonly Gate<GateContex
  */
 declare function Gated<const Gates extends NonEmptyTuple<Gate<GateContextBase>>>(...gates: Gates): <TCtor extends AnyHandlerCtor>(ctor: FitAll<TCtor, Gates> extends Gates ? TCtor : FitAll<TCtor, Gates>) => void;
 //#endregion
-//#region src/handlers/interaction/InteractionMiddleware.d.ts
-/**
- * Base class for interaction middleware
- *
- * Middleware runs before interaction handlers and can modify behavior or block execution.
- * Unlike handlers, middleware should not send responses directly.
- *
- * @typeParam Repliable - The interaction type this middleware processes
- */
-declare abstract class InteractionMiddleware<Repliable extends Repliables> extends BaseHandler<Repliable> {
-  constructor(event: Repliable, core: Core);
-}
-//#endregion
-//#region src/inputs/SlashOptions.d.ts
-interface GatewayLens<Cache extends CacheType> {
-  user: NonNullable<CommandInteractionOption<Cache>['user']>;
-  member: NonNullable<CommandInteractionOption<Cache>['member']>;
-  channel: NonNullable<CommandInteractionOption<Cache>['channel']>;
-  role: NonNullable<CommandInteractionOption<Cache>['role']>;
-  mentionable: NonNullable<CommandInteractionOption<Cache>['member' | 'role' | 'user']>;
-  attachment: NonNullable<CommandInteractionOption<Cache>['attachment']>;
+//#region src/bot/decorators/Middlewares.d.ts
+/** Registration options for an event middleware. */
+interface EventMiddlewareOptions<Events extends NonEmptyTuple<ValidNonInteractionKeys>> {
+  /**
+   * Restrict this middleware to certain Discord client events. The middleware's `EventMiddleware`
+   * generic must list the same events, or applying the decorator is a compile error. Omit it to run on
+   * every event.
+   */
+  readonly events?: Events;
+  /** Lower runs earlier. Two middleware sharing a priority run in registration order.
+   *
+   * @defaultValue 0
+   */
+  readonly priority?: number;
 }
 /**
- * The typed view over a chat-input command's options for one route. Each getter mirrors the discord.js
- * resolver method but restricts its `name` to that route's options of the matching kind, drops the null
- * on required options, narrows `choices` to their literal union, and only appears when the route has an
- * option of that kind. The rich kinds return exactly what the djs resolver returns.
- *
- * A channel option declared with `addChannelTypes` narrows `getChannel` to the matching channel subtype.
- * Pass the raw `this.event.options` resolver for anything this view does not cover.
- *
- * @typeParam Route - A route key from the generated {@link SlashRegistry}.
- * @typeParam Cache - The interaction cache state. The command's contexts set it.
- */
-type SlashOptions<Route extends keyof SlashRegistry, Cache extends CacheType = CacheFor<Route>> = SlashOptions$1<Route, GatewayLens<Cache>>;
-//#endregion
-//#region src/handlers/interaction/SlashHandler.d.ts
-type SlashMatchArms<Route extends keyof SlashRegistry, Cache extends CacheType, Ret> = { [Key in Route]: (options: SlashOptions<Key, Cache>) => Promisable<Ret>; };
-/**
- * Base class for a chat-input (slash) command handler.
- *
- * Pass the route from the generated registry as the generic, the same string as `@SlashRoute`, then read
- * `this.options` for a single command or `this.match` for several. Command authoring stays plain
- * discord.js, `seedcord codegen` reads its `toJSON()` to type these options.
+ * Registers an event middleware. It runs before the handlers for every event it lists.
  *
- * @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
- * @typeParam Cache - The interaction cache state. The command's contexts set it.
+ * @param options - The events this middleware runs on and its ordering.
+ * @decorator
  *
  * @example
  * ```ts
- * \@SlashRoute('ban')
- * class BanHandler extends SlashHandler<'ban'> {
+ * \@RegisterEventMiddleware({ events: [Events.MessageCreate], priority: 10 })
+ * class Audit extends EventMiddleware<Events.MessageCreate> {
  *     async execute() {
- *         const target = this.options.getUser('target'); // User
- *         const reason = this.options.getString('reason'); // string | null
+ *         this.logger.info(this.event[0].id);
  *     }
  * }
  * ```
+ *
+ * @throws A **SeedcordTypeError** If `priority` is not a finite number.
  */
-declare abstract class SlashHandler<Route extends keyof SlashRegistry, Cache extends CacheType = CacheFor<Route>> extends InteractionHandler<ChatInputCommandInteraction<Cache>> {
-  /** @internal */
-  readonly [SlashRouteBrand]?: Route;
-  /**
-   * The typed options for this command's route. Only the getters for kinds this command declares appear.
-   * Each getter's name argument is restricted to that command's options of its kind.
-   *
-   * - A required option drops the null.
-   * - Choices narrow to their literal union.
-   * - A channel option declared with `addChannelTypes` narrows to those types.
-   *
-   * Use `this.event.options` directly for anything outside this view, such as `getSubcommand()`.
-   * However, for the common case, the methods in this would suffice.
-   */
-  protected get options(): SlashOptions<Route, Cache>;
-  /**
-   * Run the arm for whichever command fired. Use this only when the handler is registered for several
-   * routes.
-   *
-   * Provide one arm per registered route, keyed by its route string, and each arm receives that route's
-   * own narrowed options. The arms must cover every route in the generic, a missing route or an unknown
-   * key is a compile error.
-   *
-   * @param arms - One handler per registered route, keyed by route string.
-   * @returns The result of the arm that ran.
-   *
-   * @example
-   * ```ts
-   * \@SlashRoute('ban', 'kick')
-   * class ModHandler extends SlashHandler<'ban' | 'kick'> {
-   *     async execute() {
-   *         await this.match({
-   *             ban: (options) => this.event.guild?.members.ban(options.getUser('target').id),
-   *             kick: (options) => this.event.guild?.members.kick(options.getUser('member').id)
-   *         });
-   *     }
-   * }
-   * ```
-   */
-  protected match<Ret>(arms: SlashMatchArms<Route, Cache, Ret>): Promise<Ret>;
-}
+declare function RegisterEventMiddleware<const Events extends NonEmptyTuple<ValidNonInteractionKeys> = NonEmptyTuple<ValidNonInteractionKeys>>(options?: EventMiddlewareOptions<Events>): (ctor: Constructor<EventMiddleware<Events[number]>>) => void;
 //#endregion
-//#region src/handlers/interaction/ContextMenuHandler.d.ts
-type UserMenuArms<Names extends NamesFor<ApplicationCommandType.User>, Ret> = { [Name in Names]: (target: User, member: CacheTypeReducer<MenuCacheFor<ApplicationCommandType.User, Name>, GuildMember, APIInteractionGuildMember> | null) => Promisable<Ret>; };
-type MessageMenuArms<Names extends NamesFor<ApplicationCommandType.Message>, Ret> = { [Name in Names]: (target: Message<BooleanCache<MenuCacheFor<ApplicationCommandType.Message, Name>>>) => Promisable<Ret>; };
+//#region src/bot/gates/catalog/IgnoreBots.d.ts
 /**
- * Base class for a user context-menu command handler (right-click a user).
- *
- * Pass the command name(s) as the generic, the same as `@UserContextMenuRoute`. Read the right-clicked
- * user from `this.target` and that same user's guild member from `this.targetMember`.
+ * Drops a client event whose actor is a bot, with a {@link Silence} so nothing is replied. Event-only, because a
+ * Silence on an interaction would leave Discord's failed-interaction state. It rejects an interaction handler at
+ * the decorator line. Takes no options, so attach it directly without calling it.
  *
- * @typeParam Names - One or more command names from the generated user registry.
- * @typeParam Cache - The interaction cache state. The command's contexts set it.
+ * @see {@link Gated}
  *
  * @example
  * ```ts
- * \@UserContextMenuRoute('View Profile')
- * class ViewProfile extends UserContextMenuHandler<'View Profile'> {
+ * import { Events } from 'discord.js';
+ *
+ * \@Gated(IgnoreBots)
+ * class OnMessage extends EventHandler<Events.MessageCreate> {
  *     async execute() {
- *         const user = this.target;
+ *         // ...
  *     }
  * }
  * ```
  */
-declare abstract class UserContextMenuHandler<Names extends NamesFor<ApplicationCommandType.User>, Cache extends CacheType = MenuCacheFor<ApplicationCommandType.User, Names>> extends InteractionHandler<UserContextMenuCommandInteraction<Cache>> {
-  /** @internal */
-  readonly [ContextMenuKindBrand]?: ApplicationCommandType.User;
-  /** @internal */
-  readonly [ContextMenuNamesBrand]?: Names;
-  protected get target(): User;
-  /** The right-clicked user's guild member, null outside a guild. */
-  protected get targetMember(): CacheTypeReducer<Cache, GuildMember, APIInteractionGuildMember> | null;
-  /** Which of the registered commands fired. */
-  protected get commandName(): Names;
-  /**
-   * Run the arm for whichever command fired. Use this only when the handler is registered for several
-   * names.
-   *
-   * Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
-   * arm receives the clicked user and that user's guild member, both narrowed to the cache state of that
-   * one command. The arms must cover every name in the generic. A missing name or an unknown key is a
-   * compile error.
-   *
-   * @param arms - One handler per registered command name.
-   * @returns The result of the arm that ran.
-   *
-   * @example
-   * ```ts
-   * \@UserContextMenuRoute('View Profile', 'Warn')
-   * class Moderation extends UserContextMenuHandler<'View Profile' | 'Warn'> {
-   *     async execute() {
-   *         await this.match({
-   *             'View Profile': (user) => this.reply(`Profile for ${user.tag}.`),
-   *             Warn: (user, member) => this.reply(`Warned ${member?.displayName ?? user.tag}.`)
-   *         });
-   *     }
-   * }
-   * ```
-   */
-  protected match<Ret>(arms: UserMenuArms<Names, Ret>): Promise<Ret>;
-}
+declare const IgnoreBots: import("@seedcord/core").Gate<EventGateContext<ValidNonInteractionKeys>, "IgnoreBots">;
+//#endregion
+//#region src/bot/gates/catalog/Nsfw.d.ts
 /**
- * Base class for a message context-menu command handler (right-click a message).
+ * Requires an age-restricted channel, else refuses. Pass {@link GateNoticeOptions} to reword or replace the refusal.
  *
- * Pass the command name(s) as the generic, the same as `@MessageContextMenuRoute`. Read the right-clicked
- * message from `this.target`.
+ * A thread inherits its parent channel's nsfw flag. ModalSubmit has no reliable channel, so it is excluded.
  *
- * @typeParam Names - One or more command names from the generated message registry.
- * @typeParam Cache - The interaction cache state. The command's contexts set it.
+ * @param options - Reword the default refusal with `message`, or replace it with `notice`.
+ *
+ * @see {@link Gated}
  *
  * @example
  * ```ts
- * \@MessageContextMenuRoute('Report Message')
- * class ReportMessage extends MessageContextMenuHandler<'Report Message'> {
+ * \@Gated(Nsfw())
+ * \@SlashRoute('nsfwcmd')
+ * class NsfwHandler extends SlashHandler<'nsfwcmd'> {
  *     async execute() {
- *         const message = this.target;
+ *         // ...
  *     }
  * }
  * ```
  */
-declare abstract class MessageContextMenuHandler<Names extends NamesFor<ApplicationCommandType.Message>, Cache extends CacheType = MenuCacheFor<ApplicationCommandType.Message, Names>> extends InteractionHandler<MessageContextMenuCommandInteraction<Cache>> {
-  /** @internal */
-  readonly [ContextMenuKindBrand]?: ApplicationCommandType.Message;
-  /** @internal */
-  readonly [ContextMenuNamesBrand]?: Names;
-  protected get target(): Message<BooleanCache<Cache>>;
-  /** Which of the registered commands fired. */
-  protected get commandName(): Names;
-  /**
-   * Run the arm for whichever command fired. Use this only when the handler is registered for several
-   * names.
-   *
-   * Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
-   * arm receives the clicked message, narrowed to the cache state of that one command. The arms must
-   * cover every name in the generic. A missing name or an unknown key is a compile error.
-   *
-   * @param arms - One handler per registered command name.
-   * @returns The result of the arm that ran.
-   *
-   * @example
-   * ```ts
-   * \@MessageContextMenuRoute('Report Message', 'Pin Message')
-   * class MessageTools extends MessageContextMenuHandler<'Report Message' | 'Pin Message'> {
-   *     async execute() {
-   *         await this.match({
-   *             'Report Message': (message) => this.report(message),
-   *             'Pin Message': (message) => message.pin()
-   *         });
-   *     }
-   * }
-   * ```
-   */
-  protected match<Ret>(arms: MessageMenuArms<Names, Ret>): Promise<Ret>;
+declare function Nsfw(options?: GateNoticeOptions): Gate<InteractionGateContext<NonModalInteraction>, 'Nsfw'>;
+//#endregion
+//#region src/bot/injectors/EmojiInjector.d.ts
+type SavedEmojiType = GuildEmoji | ApplicationEmoji;
+/** A resolved emoji, plus the discord.js emoji it came from on {@link GatewayEmoji.source}. */
+declare class GatewayEmoji<Source extends SavedEmojiType = SavedEmojiType> extends ResolvedEmoji {
+  #private;
+  constructor(source: Source);
+  /** What discord.js resolved, for `.url` and the management calls. */
+  get source(): Source;
 }
+/**
+ * The global {@link Emojis} accessor type. Each key's `source` resolves to its precise class, `GuildEmoji`
+ * for a `'guild'` tag and `ApplicationEmoji` for an `'application'` tag, the tags `seedcord codegen`
+ * writes into {@link EmojiMap}.
+ */
+type InjectedEmojiMap = { [K in keyof EmojiMap]: EmojiMap[K] extends 'guild' ? GatewayEmoji<GuildEmoji> : GatewayEmoji<ApplicationEmoji>; };
+/**
+ * The bot's resolved emojis, keyed by {@link EmojiMap}. Filled by {@link EmojiInjector} during startup.
+ * Throws if you read a key the injector did not fill.
+ */
+declare const Emojis: InjectedEmojiMap;
 //#endregion
-//#region src/handlers/interaction/AutocompleteHandler.d.ts
-type FocusedArms<Route extends keyof SlashRegistry, Ret> = { [Name in AutocompletableNames<Route>]: (value: string, respond: (choices: readonly ApplicationCommandOptionChoiceData<ChoiceValueOf<EntryFor<Route, Name>>>[]) => Promise<void>) => Promisable<Ret>; };
+//#region src/bot/utilities/permissions/checkBotPermissions.d.ts
 /**
- * Base class for a Discord autocomplete handler.
- *
- * Pass the command route(s) from the generated registry as the generic, the same string(s) as
- * `@AutocompleteRoute`. Branch on the focused field with `this.match`, read already-entered sibling options
- * with `this.options`, and find which command fired with `this.route`.
- *
- * @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'search'` or `'search' | 'find'`.
- * @typeParam Cache - The interaction cache state. The command's contexts set it.
+ * Checks the bot's own permissions in a {@link Guild} or {@link TextChannel}. Refuses when a permission in
+ * `scope` is missing, or with `inverse` when one is present. When the bot member is uncached, the refusal
+ * reports every permission in `scope` as missing.
  *
  * @example
  * ```ts
- * \@AutocompleteRoute('search')
- * class SearchAutocomplete extends AutocompleteHandler<'search'> {
- *     async execute() {
- *         await this.match({
- *             query: (value, respond) => respond([{ name: value, value }])
- *         });
- *     }
- * }
- * ```
- */
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkBotPermissions } from '@seedcord/gateway';
+ *
+ * checkBotPermissions(textChannel, [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]);
+ * ```
+ */
+declare function checkBotPermissions(target: Guild | TextChannel, scope: PermissionScope, inverse?: boolean, errors?: PermissionNoticeOverrides): void;
+//#endregion
+//#region src/bot/utilities/permissions/checkPermissions.d.ts
+/** Options for {@link checkPermissions}. */
+interface CheckPermissionOptions extends PermissionNoticeOverrides {
+  /** The role or member to check. */
+  for: Role | GuildMember;
+  /** A guild reads the base bits from roles, a text channel reads the overwrite-resolved set. */
+  in: Guild | TextChannel;
+  /** The permission flag bits to check. */
+  scope: PermissionScope;
+  /** Refuse when the target holds a scope bit. */
+  inverse?: boolean;
+}
+/**
+ * Checks a {@link Role} or a {@link GuildMember} against the base permission bits in a {@link Guild},
+ * before channel overwrites. Refuses when a permission in `scope` is missing, or with `inverse` when one
+ * is present.
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkPermissions } from '@seedcord/gateway';
+ *
+ * checkPermissions(role, guild, [PermissionFlagsBits.ManageMessages, PermissionFlagsBits.KickMembers]);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // refuse when the member holds Administrator, and replace the refusal
+ * checkPermissions(member, guild, [PermissionFlagsBits.Administrator], true, {
+ *   dangerousNotice: CustomDangerousNotice
+ * });
+ * ```
+ */
+declare function checkPermissions(target: Role | GuildMember, ctx: Guild, scope: PermissionScope, inverse?: boolean, errors?: PermissionNoticeOverrides): void;
+/**
+ * Checks a {@link Role} or a {@link GuildMember} against the overwrite-resolved set in a
+ * {@link TextChannel}. Refuses when a permission in `scope` is missing, or with `inverse` when one is
+ * present.
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkPermissions } from '@seedcord/gateway';
+ *
+ * checkPermissions(role, textChannel, [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]);
+ * ```
+ */
+declare function checkPermissions(target: Role | GuildMember, ctx: TextChannel, scope: PermissionScope, inverse?: boolean, errors?: PermissionNoticeOverrides): void;
+/**
+ * Checks permissions with an options object. Refuses when a permission in
+ * {@link CheckPermissionOptions.scope} is missing, or with `options.inverse` when one is present.
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkPermissions } from '@seedcord/gateway';
+ *
+ * checkPermissions({
+ *   for: member,
+ *   in: textChannel,
+ *   scope: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]
+ * });
+ * ```
+ */
+declare function checkPermissions(options: CheckPermissionOptions): void;
+//#endregion
+//#region src/bot/utilities/permissions/hasPermsToAssign.d.ts
+/**
+ * Optional custom error constructors for {@link HasPermsToAssignOptions}.
+ */
+interface AssignRoleNoticeOverrides {
+  higherNotice?: new (message: string, role: Role, botRole: Role) => Notice;
+  managedNotice?: new (message: string) => Notice;
+  missingNotice?: new (message: string | undefined, subject: string, missingPerms: readonly string[]) => Notice;
+}
+/**
+ * Options for {@link hasPermsToAssign}.
+ */
+interface HasPermsToAssignOptions {
+  targetRole: Role;
+  noticeOverrides?: AssignRoleNoticeOverrides;
+}
+/**
+ * Validates that the bot can assign a target role. Refuses when the target role is above the bot's, is managed, or the bot lacks Manage Roles.
+ *
+ * @param roleOrOptions - Target role or complete options for the check
+ * @throws A `Notice` on refusal, or a `SeedcordError` when the bot has no role in the guild's role cache.
+ *
+ * @example
+ * ```ts
+ * import { hasPermsToAssign } from '@seedcord/gateway';
+ *
+ * // Check if the bot can assign a specific role
+ * hasPermsToAssign(role);
+ *
+ * // Check with custom error handling
+ * hasPermsToAssign({
+ *   targetRole: role,
+ *   noticeOverrides: {
+ *     higherNotice: CustomHigherNotice,
+ *     managedNotice: CustomManagedNotice,
+ *     missingNotice: CustomMissingPermissionsNotice
+ *   }
+ * });
+ * ```
+ */
+declare function hasPermsToAssign(roleOrOptions: Role | HasPermsToAssignOptions): void;
+//#endregion
+//#region src/bot/confirm/getConfirmation.d.ts
+type Outcome = ReplyResponse | (() => Promisable<ReplyResponse>);
+/** Options shared by both confirmation forms. */
+interface ConfirmOptions {
+  /**
+   * Whether the prompt is ephemeral. Only the invoking user can act on it either way, a non-invoker's
+   * click is ignored.
+   *
+   * @defaultValue `true`
+   */
+  ephemeral?: boolean;
+  /**
+   * Milliseconds to wait for a click before the prompt is settled and the result resolves to `false`.
+   *
+   * @defaultValue `30_000`
+   */
+  timeoutMs?: number;
+  /** Shown in place of the prompt when the user confirms. Absent removes the prompt. */
+  onConfirm?: Outcome;
+  /** Shown in place of the prompt when the user cancels. Absent removes the prompt. */
+  onCancel?: Outcome;
+  /** Shown in place of the prompt when the prompt times out. Absent removes the prompt. */
+  onTimeout?: Outcome;
+}
+/** Options for the string-prompt form, adding the built-in Confirm/Cancel buttons' labels and style. */
+interface DefaultConfirmOptions extends ConfirmOptions {
+  /**
+   * Confirm-button label.
+   *
+   * @defaultValue `'Confirm'`
+   */
+  confirmLabel?: string;
+  /**
+   * Cancel-button label.
+   *
+   * @defaultValue `'Cancel'`
+   */
+  cancelLabel?: string;
+  /**
+   * Confirm-button style.
+   *
+   * @defaultValue {@link ButtonStyle.Danger}
+   */
+  confirmStyle?: ButtonStyle;
+}
+/**
+ * Shows a confirm/cancel prompt with built-in Confirm and Cancel buttons and resolves to `true` only if the
+ * invoking user clicks confirm. A cancel click or a timeout resolves to `false`. Gate the action behind it
+ * with an early return. A failed prompt send throws into the fault boundary. A {@link ModalHandler} is
+ * excluded at compile time.
+ *
+ * @param handler - The handler to prompt from, `this` inside a non-modal handler.
+ * @param prompt - The message shown above the Confirm and Cancel buttons.
+ * @param options - Ephemeral flag, timeout, the built-in buttons' labels and style, and the optional
+ *   `onConfirm`/`onCancel`/`onTimeout` outcome replies that edit the prompt in place.
+ * @returns `true` if confirmed, `false` on cancel or timeout.
+ *
+ * @example
+ * ```ts
+ * import { getConfirmation } from '@seedcord/gateway';
+ *
+ * \@SlashRoute('ban')
+ * class BanHandler extends SlashHandler<'ban'> {
+ *     async execute() {
+ *         const target = this.options.getUser('target');
+ *         if (!(await getConfirmation(this, `Ban ${target.tag}? This cannot be undone.`))) return;
+ *         await this.event.guild?.members.ban(target.id);
+ *     }
+ * }
+ * ```
+ */
+declare function getConfirmation(handler: RepliableHandler<NonModalInteraction>, prompt: string, options?: DefaultConfirmOptions): Promise<boolean>;
+/**
+ * Shows a confirm/cancel prompt you build yourself and resolves to `true` only if the invoking user clicks
+ * confirm. The factory receives the two minted button ids. Set them on your own buttons. A cancel click or a
+ * timeout resolves to `false`. A failed prompt send throws into the fault boundary. A {@link ModalHandler} is
+ * excluded at compile time.
+ *
+ * @param handler - The handler to prompt from, `this` inside a non-modal handler.
+ * @param prompt - A factory given the minted `{ confirm, cancel }` ids that returns the reply to show. Build
+ *   it with the `BuilderComponent` and `RowComponent` wrappers.
+ * @param options - Ephemeral flag, timeout, and the optional `onConfirm`/`onCancel`/`onTimeout` outcome
+ *   replies that edit the prompt in place.
+ * @returns `true` if confirmed, `false` on cancel or timeout.
+ *
+ * @remarks
+ * The prompt is collected in-process, so it does not survive a bot restart. Without an outcome hook the
+ * prompt is gone once the user confirms, so deliver the result with a fresh `this.followUp(...)`.
+ *
+ * @example
+ * ```ts
+ * import { ButtonBuilder, TextDisplayBuilder } from '@discordjs/builders';
+ * import { ButtonStyle } from 'discord.js';
+ * import { BuilderComponent, RowComponent, getConfirmation } from '@seedcord/gateway';
+ *
+ * class BanPrompt extends BuilderComponent<'container'> {
+ *     constructor(text: string) {
+ *         super('container');
+ *         this.instance.addTextDisplayComponents(new TextDisplayBuilder().setContent(text));
+ *     }
+ * }
+ *
+ * class ConfirmRow extends RowComponent<'button'> {
+ *     constructor(ids: { confirm: string; cancel: string }) {
+ *         super('button');
+ *         const buttons = [
+ *             [ids.confirm, 'Ban', ButtonStyle.Danger],
+ *             [ids.cancel, 'Cancel', ButtonStyle.Secondary]
+ *         ] as const;
+ *         this.instance.addComponents(
+ *             ...buttons.map(([id, label, style]) => new ButtonBuilder().setCustomId(id).setLabel(label).setStyle(style))
+ *         );
+ *     }
+ * }
+ *
+ * const target = this.options.getUser('target');
+ * const confirmed = await getConfirmation(
+ *     this,
+ *     (ids) => ({ components: [new BanPrompt(`Ban ${target.tag}?`).component, new ConfirmRow(ids).component] }),
+ *     { onConfirm: { components: [new BanPrompt(`Banned ${target.tag}.`).component] } }
+ * );
+ * if (!confirmed) return;
+ * ```
+ */
+declare function getConfirmation(handler: RepliableHandler<NonModalInteraction>, prompt: (ids: {
+  confirm: string;
+  cancel: string;
+}) => Promisable<ReplyResponse>, options?: ConfirmOptions): Promise<boolean>;
+//#endregion
+//#region src/handlers/interaction/middlewareKinds.d.ts
+interface Payloads {
+  [InteractionKind.Slash]: ChatInputCommandInteraction;
+  [InteractionKind.Button]: ButtonInteraction;
+  [InteractionKind.Modal]: ModalSubmitInteraction;
+  [InteractionKind.StringMenu]: StringSelectMenuInteraction;
+  [InteractionKind.UserMenu]: UserSelectMenuInteraction;
+  [InteractionKind.RoleMenu]: RoleSelectMenuInteraction;
+  [InteractionKind.ChannelMenu]: ChannelSelectMenuInteraction;
+  [InteractionKind.MentionableMenu]: MentionableSelectMenuInteraction;
+  [InteractionKind.MessageContextMenu]: MessageContextMenuCommandInteraction;
+  [InteractionKind.UserContextMenu]: UserContextMenuCommandInteraction;
+}
+type InteractionForKind = { [Kind in MiddlewareKind]: Payloads[Kind]; };
+/** @internal */
+type InteractionOf<Kind extends MiddlewareKind> = InteractionForKind[Kind];
+//#endregion
+//#region src/handlers/interaction/InteractionMiddleware.d.ts
+/**
+ * Base class for interaction middleware.
+ *
+ * Middleware runs after the dispatcher builds the handler and before the gates, over the handler's own
+ * reply surface. Name the kinds in the generic and list the same ones in `{ kinds }`. Several kinds give
+ * `this.event` a union. The discord.js guards narrow it. A catchall reads every repliable kind.
+ *
+ * @typeParam Kind - One or more {@link InteractionKind} members. Defaults to every repliable kind.
+ *
+ * @example
+ * ```ts
+ * \@RegisterInteractionMiddleware({ kinds: [InteractionKind.Button] })
+ * class Audit extends InteractionMiddleware<InteractionKind.Button> {
+ *     async execute() {
+ *         this.logger.info(this.event.customId);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class InteractionMiddleware<in out Kind extends MiddlewareKind = MiddlewareKind> extends RepliableHandler<InteractionOf<Kind>> {
+  /** @internal */
+  readonly [MiddlewareKindsBrand]?: Kind;
+  constructor(event: InteractionOf<Kind>, core: Core, dispatch: DispatchContext, sender: ReplySender);
+  /**
+   * Runs once the handler settles, newest middleware first. A refusal or a throw still reaches it,
+   * since seedcord calls it on every middleware whose `execute()` started. Implement it to release
+   * something this middleware took in `execute()`, such as a lock or an open span. A throw in here
+   * is logged and goes no further.
+   *
+   * @param result - How the dispatch ended. Either failure state carries the thrown value on `caught`.
+   *
+   * @example
+   * ```ts
+   * // the base declares it. an implementation carries `override`.
+   * override async after(result: DispatchResult) {
+   *     this.lock.release();
+   * }
+   * ```
+   */
+  after?(result: DispatchResult): Promise<void>;
+}
+//#endregion
+//#region src/inputs/SlashOptions.d.ts
+interface GatewayLens<Cache extends CacheType> {
+  user: NonNullable<CommandInteractionOption<Cache>['user']>;
+  member: NonNullable<CommandInteractionOption<Cache>['member']>;
+  channel: NonNullable<CommandInteractionOption<Cache>['channel']>;
+  role: NonNullable<CommandInteractionOption<Cache>['role']>;
+  mentionable: NonNullable<CommandInteractionOption<Cache>['member' | 'role' | 'user']>;
+  attachment: NonNullable<CommandInteractionOption<Cache>['attachment']>;
+}
+/**
+ * The typed view over a chat-input command's options for one route. Each getter mirrors the discord.js
+ * resolver method but restricts its `name` to that route's options of the matching kind, drops the null
+ * on required options, narrows `choices` to their literal union, and only appears when the route has an
+ * option of that kind. The rich kinds return exactly what the djs resolver returns.
+ *
+ * A channel option declared with `addChannelTypes` narrows `getChannel` to the matching channel subtype.
+ * Pass the raw `this.event.options` resolver for anything this view does not cover.
+ *
+ * @typeParam Route - A route key from the generated {@link SlashRegistry}.
+ * @typeParam Cache - The interaction cache state. The command's contexts set it.
+ */
+type SlashOptions<Route extends keyof SlashRegistry, Cache extends CacheType = CacheFor<Route>> = SlashOptions$1<Route, GatewayLens<Cache>>;
+//#endregion
+//#region src/handlers/interaction/SlashHandler.d.ts
+type SlashMatchArms<Route extends keyof SlashRegistry, Cache extends CacheType, Ret> = { [Key in Route]: (options: SlashOptions<Key, Cache>) => Promisable<Ret>; };
+/**
+ * Base class for a chat-input (slash) command handler.
+ *
+ * Pass the route from the generated registry as the generic, the same string as `@SlashRoute`, then read
+ * `this.options` for a single command or `this.match` for several. Command authoring stays plain
+ * discord.js, `seedcord codegen` reads its `toJSON()` to type these options.
+ *
+ * @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
+ * @typeParam Cache - The interaction cache state. The command's contexts set it.
+ *
+ * @example
+ * ```ts
+ * \@SlashRoute('ban')
+ * class BanHandler extends SlashHandler<'ban'> {
+ *     async execute() {
+ *         const target = this.options.getUser('target'); // User
+ *         const reason = this.options.getString('reason'); // string | null
+ *     }
+ * }
+ * ```
+ */
+declare abstract class SlashHandler<Route extends keyof SlashRegistry, Cache extends CacheType = CacheFor<Route>> extends InteractionHandler<ChatInputCommandInteraction<Cache>> {
+  /** @internal */
+  readonly [SlashRouteBrand]?: Route;
+  /**
+   * The typed options for this command's route. Only the getters for kinds this command declares appear.
+   * Each getter's name argument is restricted to that command's options of its kind.
+   *
+   * - A required option drops the null.
+   * - Choices narrow to their literal union.
+   * - A channel option declared with `addChannelTypes` narrows to those types.
+   *
+   * Use `this.event.options` directly for anything outside this view, such as `getSubcommand()`.
+   * However, for the common case, the methods in this would suffice.
+   */
+  protected get options(): SlashOptions<Route, Cache>;
+  /**
+   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * routes.
+   *
+   * Provide one arm per registered route, keyed by its route string, and each arm receives that route's
+   * own narrowed options. The arms must cover every route in the generic, a missing route or an unknown
+   * key is a compile error.
+   *
+   * @param arms - One handler per registered route, keyed by route string.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@SlashRoute('ban', 'kick')
+   * class ModHandler extends SlashHandler<'ban' | 'kick'> {
+   *     async execute() {
+   *         await this.match({
+   *             ban: (options) => this.event.guild?.members.ban(options.getUser('target').id),
+   *             kick: (options) => this.event.guild?.members.kick(options.getUser('member').id)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: SlashMatchArms<Route, Cache, Ret>): Promise<Ret>;
+}
+//#endregion
+//#region src/handlers/interaction/ContextMenuHandler.d.ts
+type UserMenuArms<Names extends NamesFor<ApplicationCommandType.User>, Ret> = { [Name in Names]: (target: User, member: CacheTypeReducer<MenuCacheFor<ApplicationCommandType.User, Name>, GuildMember, APIInteractionGuildMember> | null) => Promisable<Ret>; };
+type MessageMenuArms<Names extends NamesFor<ApplicationCommandType.Message>, Ret> = { [Name in Names]: (target: Message<BooleanCache<MenuCacheFor<ApplicationCommandType.Message, Name>>>) => Promisable<Ret>; };
+/**
+ * Base class for a user context-menu command handler (right-click a user).
+ *
+ * Pass the command name(s) as the generic, the same as `@UserContextMenuRoute`. Read the right-clicked
+ * user from `this.target` and that same user's guild member from `this.targetMember`.
+ *
+ * @typeParam Names - One or more command names from the generated user registry.
+ * @typeParam Cache - The interaction cache state. The command's contexts set it.
+ *
+ * @example
+ * ```ts
+ * \@UserContextMenuRoute('View Profile')
+ * class ViewProfile extends UserContextMenuHandler<'View Profile'> {
+ *     async execute() {
+ *         const user = this.target;
+ *     }
+ * }
+ * ```
+ */
+declare abstract class UserContextMenuHandler<Names extends NamesFor<ApplicationCommandType.User>, Cache extends CacheType = MenuCacheFor<ApplicationCommandType.User, Names>> extends InteractionHandler<UserContextMenuCommandInteraction<Cache>> {
+  /** @internal */
+  readonly [ContextMenuKindBrand]?: ApplicationCommandType.User;
+  /** @internal */
+  readonly [ContextMenuNamesBrand]?: Names;
+  protected get target(): User;
+  /** The right-clicked user's guild member, null outside a guild. */
+  protected get targetMember(): CacheTypeReducer<Cache, GuildMember, APIInteractionGuildMember> | null;
+  /** Which of the registered commands fired. */
+  protected get commandName(): Names;
+  /**
+   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * names.
+   *
+   * Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
+   * arm receives the clicked user and that user's guild member, both narrowed to the cache state of that
+   * one command. The arms must cover every name in the generic. A missing name or an unknown key is a
+   * compile error.
+   *
+   * @param arms - One handler per registered command name.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@UserContextMenuRoute('View Profile', 'Warn')
+   * class Moderation extends UserContextMenuHandler<'View Profile' | 'Warn'> {
+   *     async execute() {
+   *         await this.match({
+   *             'View Profile': (user) => this.reply(`Profile for ${user.tag}.`),
+   *             Warn: (user, member) => this.reply(`Warned ${member?.displayName ?? user.tag}.`)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: UserMenuArms<Names, Ret>): Promise<Ret>;
+}
+/**
+ * Base class for a message context-menu command handler (right-click a message).
+ *
+ * Pass the command name(s) as the generic, the same as `@MessageContextMenuRoute`. Read the right-clicked
+ * message from `this.target`.
+ *
+ * @typeParam Names - One or more command names from the generated message registry.
+ * @typeParam Cache - The interaction cache state. The command's contexts set it.
+ *
+ * @example
+ * ```ts
+ * \@MessageContextMenuRoute('Report Message')
+ * class ReportMessage extends MessageContextMenuHandler<'Report Message'> {
+ *     async execute() {
+ *         const message = this.target;
+ *     }
+ * }
+ * ```
+ */
+declare abstract class MessageContextMenuHandler<Names extends NamesFor<ApplicationCommandType.Message>, Cache extends CacheType = MenuCacheFor<ApplicationCommandType.Message, Names>> extends InteractionHandler<MessageContextMenuCommandInteraction<Cache>> {
+  /** @internal */
+  readonly [ContextMenuKindBrand]?: ApplicationCommandType.Message;
+  /** @internal */
+  readonly [ContextMenuNamesBrand]?: Names;
+  protected get target(): Message<BooleanCache<Cache>>;
+  /** Which of the registered commands fired. */
+  protected get commandName(): Names;
+  /**
+   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * names.
+   *
+   * Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
+   * arm receives the clicked message, narrowed to the cache state of that one command. The arms must
+   * cover every name in the generic. A missing name or an unknown key is a compile error.
+   *
+   * @param arms - One handler per registered command name.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@MessageContextMenuRoute('Report Message', 'Pin Message')
+   * class MessageTools extends MessageContextMenuHandler<'Report Message' | 'Pin Message'> {
+   *     async execute() {
+   *         await this.match({
+   *             'Report Message': (message) => this.report(message),
+   *             'Pin Message': (message) => message.pin()
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: MessageMenuArms<Names, Ret>): Promise<Ret>;
+}
+//#endregion
+//#region src/handlers/interaction/AutocompleteHandler.d.ts
+type FocusedArms<Route extends keyof SlashRegistry, Ret> = { [Name in AutocompletableNames<Route>]: (value: string, respond: (choices: readonly ApplicationCommandOptionChoiceData<ChoiceValueOf<EntryFor<Route, Name>>>[]) => Promise<void>) => Promisable<Ret>; };
+/**
+ * Base class for a Discord autocomplete handler.
+ *
+ * Pass the command route(s) from the generated registry as the generic, the same string(s) as
+ * `@AutocompleteRoute`. Branch on the focused field with `this.match`, read already-entered sibling options
+ * with `this.options`, and find which command fired with `this.route`.
+ *
+ * @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'search'` or `'search' | 'find'`.
+ * @typeParam Cache - The interaction cache state. The command's contexts set it.
+ *
+ * @example
+ * ```ts
+ * \@AutocompleteRoute('search')
+ * class SearchAutocomplete extends AutocompleteHandler<'search'> {
+ *     async execute() {
+ *         await this.match({
+ *             query: (value, respond) => respond([{ name: value, value }])
+ *         });
+ *     }
+ * }
+ * ```
+ */
 declare abstract class AutocompleteHandler<Route extends keyof SlashRegistry, Cache extends CacheType = CacheFor<Route>> extends BaseHandler<AutocompleteInteraction<Cache>> {
   /** @internal */
   readonly [AutocompleteRouteBrand]?: Route;
-  constructor(event: AutocompleteInteraction<Cache>, core: Core, dispatch?: DispatchContext);
+  constructor(event: AutocompleteInteraction<Cache>, core: Core, dispatch: DispatchContext);
   private decodedFocused?;
   /**
    * The focused option for this interaction. `value` is always the raw partial string the user is typing,
@@ -1199,493 +1635,133 @@ declare abstract class SelectMenuHandler<Event extends AnySelectMenuInteraction,
  *
  * Register the customId definitions with `@StringMenuRoute`, list the same ones in the generic, then read
  * the chosen option values from `this.values`. Read `this.params` for a single route or `this.match` for
- * several. Reply through the handler members, or rewrite the source message with `this.update`.
- *
- * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof TopicsId]`.
- * @typeParam Cache - The interaction cache state, `'cached'` by default.
- *
- * @example
- * ```ts
- * \@StringMenuRoute(TopicsId)
- * class Topics extends StringMenuHandler<[typeof TopicsId]> {
- *     async execute() {
- *         const { userId } = this.params;
- *         await this.update(`<@${userId}> now follows ${this.values.join(', ')}`);
- *     }
- * }
- * ```
- */
-declare abstract class StringMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<StringSelectMenuInteraction<Cache>, Defs> {
-  /** @internal */
-  readonly [ComponentKindBrand]?: InteractionKind.StringMenu;
-}
-/**
- * Base class for a user select menu handler.
- *
- * Beside `this.values` this handler declares `this.users` and `this.members`. Register the customId
- * definitions with `@UserMenuRoute` and list the same ones in the generic.
- *
- * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
- * @typeParam Cache - The interaction cache state, `'cached'` by default.
- *
- * @example
- * ```ts
- * \@UserMenuRoute(AssignId)
- * class Assign extends UserMenuHandler<[typeof AssignId]> {
- *     async execute() {
- *         const { roleId } = this.params;
- *         await this.reply(`assigning ${this.users.size} member(s) to <@&${roleId}>`);
- *     }
- * }
- * ```
- */
-declare abstract class UserMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<UserSelectMenuInteraction<Cache>, Defs> {
-  /** @internal */
-  readonly [ComponentKindBrand]?: InteractionKind.UserMenu;
-  /** The users this select picked. */
-  protected get users(): UserSelectMenuInteraction<Cache>['users'];
-  /** The guild members behind the picked users. Discord resolves these only inside a guild. */
-  protected get members(): UserSelectMenuInteraction<Cache>['members'];
-}
-/**
- * Base class for a role select menu handler.
- *
- * Beside `this.values` this handler declares `this.roles`. Register the customId definitions with
- * `@RoleMenuRoute` and list the same ones in the generic.
- *
- * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof GrantId]`.
- * @typeParam Cache - The interaction cache state, `'cached'` by default.
- *
- * @example
- * ```ts
- * \@RoleMenuRoute(GrantId)
- * class Grant extends RoleMenuHandler<[typeof GrantId]> {
- *     async execute() {
- *         await this.update(`granting ${this.roles.size} role(s)`);
- *     }
- * }
- * ```
- */
-declare abstract class RoleMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<RoleSelectMenuInteraction<Cache>, Defs> {
-  /** @internal */
-  readonly [ComponentKindBrand]?: InteractionKind.RoleMenu;
-  /** The roles this select picked. */
-  protected get roles(): RoleSelectMenuInteraction<Cache>['roles'];
-}
-/**
- * Base class for a channel select menu handler.
- *
- * Beside `this.values` this handler declares `this.channels`. Register the customId definitions with
- * `@ChannelMenuRoute` and list the same ones in the generic.
- *
- * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof LogTargetId]`.
- * @typeParam Cache - The interaction cache state, `'cached'` by default.
- *
- * @example
- * ```ts
- * \@ChannelMenuRoute(LogTargetId)
- * class LogTarget extends ChannelMenuHandler<[typeof LogTargetId]> {
- *     async execute() {
- *         await this.update(`logging to ${this.channels.size} channel(s)`);
- *     }
- * }
- * ```
- */
-declare abstract class ChannelMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<ChannelSelectMenuInteraction<Cache>, Defs> {
-  /** @internal */
-  readonly [ComponentKindBrand]?: InteractionKind.ChannelMenu;
-  /** The channels this select picked. */
-  protected get channels(): ChannelSelectMenuInteraction<Cache>['channels'];
-}
-/**
- * Base class for a mentionable select menu handler.
- *
- * A mentionable menu accepts users and roles together. `this.users`, `this.members`, and `this.roles`
- * can each come back empty.
- *
- * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof InviteId]`.
- * @typeParam Cache - The interaction cache state, `'cached'` by default.
- *
- * @example
- * ```ts
- * \@MentionableMenuRoute(InviteId)
- * class Invite extends MentionableMenuHandler<[typeof InviteId]> {
- *     async execute() {
- *         await this.update(`inviting ${this.users.size} user(s) and ${this.roles.size} role(s)`);
- *     }
- * }
- * ```
- */
-declare abstract class MentionableMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<MentionableSelectMenuInteraction<Cache>, Defs> {
-  /** @internal */
-  readonly [ComponentKindBrand]?: InteractionKind.MentionableMenu;
-  /** The users this select picked. */
-  protected get users(): MentionableSelectMenuInteraction<Cache>['users'];
-  /** The guild members behind the picked users. Discord resolves these only inside a guild. */
-  protected get members(): MentionableSelectMenuInteraction<Cache>['members'];
-  /** The roles this select picked. */
-  protected get roles(): MentionableSelectMenuInteraction<Cache>['roles'];
-}
-//#endregion
-//#region src/bot/decorators/Middlewares.d.ts
-/**
- * Middleware types supported by Seedcord
- */
-declare enum MiddlewareType {
-  Interaction = "interaction",
-  Event = "event"
-}
-/**
- * Additional middleware registration options
- *
- * @typeParam MType - The type of middleware being registered
- */
-interface MiddlewareOptions<MType extends MiddlewareType, Events extends readonly ValidNonInteractionKeys[] = readonly ValidNonInteractionKeys[]> {
-  /**
-   * Restrict event middleware execution to specific Discord client events. The middleware's `EventMiddleware`
-   * generic must list the same events, or applying the decorator is a compile error.
-   */
-  readonly events?: MType extends MiddlewareType.Event ? Events : never;
-}
-/**
- * Decorator used to register middleware with priority ordering. The lower the priority number, the earlier it runs.
- *
- * Interaction middleware cannot specify event filters.
- *
- * @param type - Middleware kind from {@link MiddlewareType}
- * @param priority - Ordering value where lower runs earlier. {@default `0` }
- * @param options - Additional registration options
- *
- * @decorator
- *
- * @example
- * ```ts
- * \@Middleware(MiddlewareType.Event, 10, { events: [Events.MessageCreate, Events.MessageUpdate] })
- * class MyEventMiddleware extends EventMiddleware {}
- * ```
- * @throws A **SeedcordTypeError** If priority is not a finite number
- * @throws A **SeedcordError** If interaction middleware specifies event filters
- */
-declare function Middleware<MType extends MiddlewareType, const Events extends readonly ValidNonInteractionKeys[] = []>(type: MType, priority?: number, options?: MiddlewareOptions<MType, Events>): (ctor: MType extends MiddlewareType.Interaction ? Constructor<InteractionMiddleware<Repliables>> : Events extends readonly [] ? Constructor<EventMiddleware<ValidNonInteractionKeys>> : Constructor<EventMiddleware<Events[number]>>) => void;
-//#endregion
-//#region src/bot/gates/catalog/IgnoreBots.d.ts
-/**
- * Drops a client event whose actor is a bot, with a {@link Silence} so nothing is replied. Event-only, because a
- * Silence on an interaction would leave Discord's failed-interaction state. It rejects an interaction handler at
- * the decorator line. Takes no options, so attach it directly without calling it.
- *
- * @see {@link Gated}
- *
- * @example
- * ```ts
- * import { Events } from 'discord.js';
- *
- * \@Gated(IgnoreBots)
- * class OnMessage extends EventHandler<Events.MessageCreate> {
- *     async execute() {
- *         // ...
- *     }
- * }
- * ```
- */
-declare const IgnoreBots: import("@seedcord/core").Gate<EventGateContext<ValidNonInteractionKeys>, "IgnoreBots">;
-//#endregion
-//#region src/bot/gates/catalog/Nsfw.d.ts
-/**
- * Requires an age-restricted channel, else refuses. Pass {@link GateNoticeOptions} to reword or replace the refusal.
- *
- * A thread inherits its parent channel's nsfw flag. ModalSubmit has no reliable channel, so it is excluded.
- *
- * @param options - Reword the default refusal with `message`, or replace it with `notice`.
- *
- * @see {@link Gated}
- *
- * @example
- * ```ts
- * \@Gated(Nsfw())
- * \@SlashRoute('nsfwcmd')
- * class NsfwHandler extends SlashHandler<'nsfwcmd'> {
- *     async execute() {
- *         // ...
- *     }
- * }
- * ```
- */
-declare function Nsfw(options?: GateNoticeOptions): Gate<InteractionGateContext<NonModalInteraction>, 'Nsfw'>;
-//#endregion
-//#region src/bot/injectors/EmojiInjector.d.ts
-type SavedEmojiType = GuildEmoji | ApplicationEmoji;
-/** A resolved emoji, plus the discord.js emoji it came from on {@link GatewayEmoji.source}. */
-declare class GatewayEmoji<Source extends SavedEmojiType = SavedEmojiType> extends ResolvedEmoji {
-  #private;
-  constructor(source: Source);
-  /** What discord.js resolved, for `.url` and the management calls. */
-  get source(): Source;
-}
-/**
- * The global {@link Emojis} accessor type. Each key's `source` resolves to its precise class, `GuildEmoji`
- * for a `'guild'` tag and `ApplicationEmoji` for an `'application'` tag, the tags `seedcord codegen`
- * writes into {@link EmojiMap}.
- */
-type InjectedEmojiMap = { [K in keyof EmojiMap]: EmojiMap[K] extends 'guild' ? GatewayEmoji<GuildEmoji> : GatewayEmoji<ApplicationEmoji>; };
-/**
- * The bot's resolved emojis, keyed by {@link EmojiMap}. Filled by {@link EmojiInjector} during startup.
- * Throws if you read a key the injector did not fill.
- */
-declare const Emojis: InjectedEmojiMap;
-//#endregion
-//#region src/bot/utilities/permissions/checkBotPermissions.d.ts
-/**
- * Checks the bot's own permissions in a {@link Guild} or {@link TextChannel}. Refuses when a permission in
- * `scope` is missing, or with `inverse` when one is present. When the bot member is uncached, the refusal
- * reports every permission in `scope` as missing.
- *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord.js';
- * import { checkBotPermissions } from '@seedcord/gateway';
- *
- * checkBotPermissions(textChannel, [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]);
- * ```
- */
-declare function checkBotPermissions(target: Guild | TextChannel, scope: PermissionScope, inverse?: boolean, errors?: PermissionNoticeOverrides): void;
-//#endregion
-//#region src/bot/utilities/permissions/checkPermissions.d.ts
-/** Options for {@link checkPermissions}. */
-interface CheckPermissionOptions extends PermissionNoticeOverrides {
-  /** The role or member to check. */
-  for: Role | GuildMember;
-  /** A guild reads the base bits from roles, a text channel reads the overwrite-resolved set. */
-  in: Guild | TextChannel;
-  /** The permission flag bits to check. */
-  scope: PermissionScope;
-  /** Refuse when the target holds a scope bit. */
-  inverse?: boolean;
-}
-/**
- * Checks a {@link Role} or a {@link GuildMember} against the base permission bits in a {@link Guild},
- * before channel overwrites. Refuses when a permission in `scope` is missing, or with `inverse` when one
- * is present.
- *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord.js';
- * import { checkPermissions } from '@seedcord/gateway';
+ * several. Reply through the handler members, or rewrite the source message with `this.update`.
  *
- * checkPermissions(role, guild, [PermissionFlagsBits.ManageMessages, PermissionFlagsBits.KickMembers]);
- * ```
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof TopicsId]`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
  *
  * @example
  * ```ts
- * // refuse when the member holds Administrator, and replace the refusal
- * checkPermissions(member, guild, [PermissionFlagsBits.Administrator], true, {
- *   dangerousNotice: CustomDangerousNotice
- * });
+ * \@StringMenuRoute(TopicsId)
+ * class Topics extends StringMenuHandler<[typeof TopicsId]> {
+ *     async execute() {
+ *         const { userId } = this.params;
+ *         await this.update(`<@${userId}> now follows ${this.values.join(', ')}`);
+ *     }
+ * }
  * ```
  */
-declare function checkPermissions(target: Role | GuildMember, ctx: Guild, scope: PermissionScope, inverse?: boolean, errors?: PermissionNoticeOverrides): void;
+declare abstract class StringMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<StringSelectMenuInteraction<Cache>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.StringMenu;
+}
 /**
- * Checks a {@link Role} or a {@link GuildMember} against the overwrite-resolved set in a
- * {@link TextChannel}. Refuses when a permission in `scope` is missing, or with `inverse` when one is
- * present.
+ * Base class for a user select menu handler.
  *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord.js';
- * import { checkPermissions } from '@seedcord/gateway';
+ * Beside `this.values` this handler declares `this.users` and `this.members`. Register the customId
+ * definitions with `@UserMenuRoute` and list the same ones in the generic.
  *
- * checkPermissions(role, textChannel, [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]);
- * ```
- */
-declare function checkPermissions(target: Role | GuildMember, ctx: TextChannel, scope: PermissionScope, inverse?: boolean, errors?: PermissionNoticeOverrides): void;
-/**
- * Checks permissions with an options object. Refuses when a permission in
- * {@link CheckPermissionOptions.scope} is missing, or with `options.inverse` when one is present.
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
  *
  * @example
  * ```ts
- * import { PermissionFlagsBits } from 'discord.js';
- * import { checkPermissions } from '@seedcord/gateway';
- *
- * checkPermissions({
- *   for: member,
- *   in: textChannel,
- *   scope: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]
- * });
+ * \@UserMenuRoute(AssignId)
+ * class Assign extends UserMenuHandler<[typeof AssignId]> {
+ *     async execute() {
+ *         const { roleId } = this.params;
+ *         await this.reply(`assigning ${this.users.size} member(s) to <@&${roleId}>`);
+ *     }
+ * }
  * ```
  */
-declare function checkPermissions(options: CheckPermissionOptions): void;
-//#endregion
-//#region src/bot/utilities/permissions/hasPermsToAssign.d.ts
-/**
- * Optional custom error constructors for {@link HasPermsToAssignOptions}.
- */
-interface AssignRoleNoticeOverrides {
-  higherNotice?: new (message: string, role: Role, botRole: Role) => Notice;
-  managedNotice?: new (message: string) => Notice;
-  missingNotice?: new (message: string | undefined, subject: string, missingPerms: readonly string[]) => Notice;
-}
-/**
- * Options for {@link hasPermsToAssign}.
- */
-interface HasPermsToAssignOptions {
-  targetRole: Role;
-  noticeOverrides?: AssignRoleNoticeOverrides;
+declare abstract class UserMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<UserSelectMenuInteraction<Cache>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.UserMenu;
+  /** The users this select picked. */
+  protected get users(): UserSelectMenuInteraction<Cache>['users'];
+  /** The guild members behind the picked users. Discord resolves these only inside a guild. */
+  protected get members(): UserSelectMenuInteraction<Cache>['members'];
 }
 /**
- * Validates that the bot can assign a target role. Refuses when the target role is above the bot's, is managed, or the bot lacks Manage Roles.
+ * Base class for a role select menu handler.
  *
- * @param roleOrOptions - Target role or complete options for the check
- * @throws A `Notice` on refusal, or a `SeedcordError` when the bot has no role in the guild's role cache.
+ * Beside `this.values` this handler declares `this.roles`. Register the customId definitions with
+ * `@RoleMenuRoute` and list the same ones in the generic.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof GrantId]`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
  *
  * @example
  * ```ts
- * import { hasPermsToAssign } from '@seedcord/gateway';
- *
- * // Check if the bot can assign a specific role
- * hasPermsToAssign(role);
- *
- * // Check with custom error handling
- * hasPermsToAssign({
- *   targetRole: role,
- *   noticeOverrides: {
- *     higherNotice: CustomHigherNotice,
- *     managedNotice: CustomManagedNotice,
- *     missingNotice: CustomMissingPermissionsNotice
- *   }
- * });
+ * \@RoleMenuRoute(GrantId)
+ * class Grant extends RoleMenuHandler<[typeof GrantId]> {
+ *     async execute() {
+ *         await this.update(`granting ${this.roles.size} role(s)`);
+ *     }
+ * }
  * ```
  */
-declare function hasPermsToAssign(roleOrOptions: Role | HasPermsToAssignOptions): void;
-//#endregion
-//#region src/bot/confirm/getConfirmation.d.ts
-type Outcome = ReplyResponse | (() => Promisable<ReplyResponse>);
-/** Options shared by both confirmation forms. */
-interface ConfirmOptions {
-  /**
-   * Whether the prompt is ephemeral. Only the invoking user can act on it either way, a non-invoker's
-   * click is ignored.
-   *
-   * @defaultValue `true`
-   */
-  ephemeral?: boolean;
-  /**
-   * Milliseconds to wait for a click before the prompt is settled and the result resolves to `false`.
-   *
-   * @defaultValue `30_000`
-   */
-  timeoutMs?: number;
-  /** Shown in place of the prompt when the user confirms. Absent removes the prompt. */
-  onConfirm?: Outcome;
-  /** Shown in place of the prompt when the user cancels. Absent removes the prompt. */
-  onCancel?: Outcome;
-  /** Shown in place of the prompt when the prompt times out. Absent removes the prompt. */
-  onTimeout?: Outcome;
-}
-/** Options for the string-prompt form, adding the built-in Confirm/Cancel buttons' labels and style. */
-interface DefaultConfirmOptions extends ConfirmOptions {
-  /**
-   * Confirm-button label.
-   *
-   * @defaultValue `'Confirm'`
-   */
-  confirmLabel?: string;
-  /**
-   * Cancel-button label.
-   *
-   * @defaultValue `'Cancel'`
-   */
-  cancelLabel?: string;
-  /**
-   * Confirm-button style.
-   *
-   * @defaultValue {@link ButtonStyle.Danger}
-   */
-  confirmStyle?: ButtonStyle;
+declare abstract class RoleMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<RoleSelectMenuInteraction<Cache>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.RoleMenu;
+  /** The roles this select picked. */
+  protected get roles(): RoleSelectMenuInteraction<Cache>['roles'];
 }
 /**
- * Shows a confirm/cancel prompt with built-in Confirm and Cancel buttons and resolves to `true` only if the
- * invoking user clicks confirm. A cancel click or a timeout resolves to `false`. Gate the action behind it
- * with an early return. A failed prompt send throws into the fault boundary. A {@link ModalHandler} is
- * excluded at compile time.
+ * Base class for a channel select menu handler.
  *
- * @param handler - The handler to prompt from, `this` inside a non-modal handler.
- * @param prompt - The message shown above the Confirm and Cancel buttons.
- * @param options - Ephemeral flag, timeout, the built-in buttons' labels and style, and the optional
- *   `onConfirm`/`onCancel`/`onTimeout` outcome replies that edit the prompt in place.
- * @returns `true` if confirmed, `false` on cancel or timeout.
+ * Beside `this.values` this handler declares `this.channels`. Register the customId definitions with
+ * `@ChannelMenuRoute` and list the same ones in the generic.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof LogTargetId]`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
  *
  * @example
  * ```ts
- * import { getConfirmation } from '@seedcord/gateway';
- *
- * \@SlashRoute('ban')
- * class BanHandler extends SlashHandler<'ban'> {
+ * \@ChannelMenuRoute(LogTargetId)
+ * class LogTarget extends ChannelMenuHandler<[typeof LogTargetId]> {
  *     async execute() {
- *         const target = this.options.getUser('target');
- *         if (!(await getConfirmation(this, `Ban ${target.tag}? This cannot be undone.`))) return;
- *         await this.event.guild?.members.ban(target.id);
+ *         await this.update(`logging to ${this.channels.size} channel(s)`);
  *     }
  * }
  * ```
  */
-declare function getConfirmation(handler: RepliableHandler<NonModalInteraction>, prompt: string, options?: DefaultConfirmOptions): Promise<boolean>;
+declare abstract class ChannelMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<ChannelSelectMenuInteraction<Cache>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.ChannelMenu;
+  /** The channels this select picked. */
+  protected get channels(): ChannelSelectMenuInteraction<Cache>['channels'];
+}
 /**
- * Shows a confirm/cancel prompt you build yourself and resolves to `true` only if the invoking user clicks
- * confirm. The factory receives the two minted button ids. Set them on your own buttons. A cancel click or a
- * timeout resolves to `false`. A failed prompt send throws into the fault boundary. A {@link ModalHandler} is
- * excluded at compile time.
+ * Base class for a mentionable select menu handler.
  *
- * @param handler - The handler to prompt from, `this` inside a non-modal handler.
- * @param prompt - A factory given the minted `{ confirm, cancel }` ids that returns the reply to show. Build
- *   it with the `BuilderComponent` and `RowComponent` wrappers.
- * @param options - Ephemeral flag, timeout, and the optional `onConfirm`/`onCancel`/`onTimeout` outcome
- *   replies that edit the prompt in place.
- * @returns `true` if confirmed, `false` on cancel or timeout.
+ * A mentionable menu accepts users and roles together. `this.users`, `this.members`, and `this.roles`
+ * can each come back empty.
  *
- * @remarks
- * The prompt is collected in-process, so it does not survive a bot restart. Without an outcome hook the
- * prompt is gone once the user confirms, so deliver the result with a fresh `this.followUp(...)`.
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof InviteId]`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
  *
  * @example
  * ```ts
- * import { ButtonBuilder, TextDisplayBuilder } from '@discordjs/builders';
- * import { ButtonStyle } from 'discord.js';
- * import { BuilderComponent, RowComponent, getConfirmation } from '@seedcord/gateway';
- *
- * class BanPrompt extends BuilderComponent<'container'> {
- *     constructor(text: string) {
- *         super('container');
- *         this.instance.addTextDisplayComponents(new TextDisplayBuilder().setContent(text));
- *     }
- * }
- *
- * class ConfirmRow extends RowComponent<'button'> {
- *     constructor(ids: { confirm: string; cancel: string }) {
- *         super('button');
- *         const buttons = [
- *             [ids.confirm, 'Ban', ButtonStyle.Danger],
- *             [ids.cancel, 'Cancel', ButtonStyle.Secondary]
- *         ] as const;
- *         this.instance.addComponents(
- *             ...buttons.map(([id, label, style]) => new ButtonBuilder().setCustomId(id).setLabel(label).setStyle(style))
- *         );
+ * \@MentionableMenuRoute(InviteId)
+ * class Invite extends MentionableMenuHandler<[typeof InviteId]> {
+ *     async execute() {
+ *         await this.update(`inviting ${this.users.size} user(s) and ${this.roles.size} role(s)`);
  *     }
  * }
- *
- * const target = this.options.getUser('target');
- * const confirmed = await getConfirmation(
- *     this,
- *     (ids) => ({ components: [new BanPrompt(`Ban ${target.tag}?`).component, new ConfirmRow(ids).component] }),
- *     { onConfirm: { components: [new BanPrompt(`Banned ${target.tag}.`).component] } }
- * );
- * if (!confirmed) return;
  * ```
  */
-declare function getConfirmation(handler: RepliableHandler<NonModalInteraction>, prompt: (ids: {
-  confirm: string;
-  cancel: string;
-}) => Promisable<ReplyResponse>, options?: ConfirmOptions): Promise<boolean>;
+declare abstract class MentionableMenuHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends SelectMenuHandler<MentionableSelectMenuInteraction<Cache>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.MentionableMenu;
+  /** The users this select picked. */
+  protected get users(): MentionableSelectMenuInteraction<Cache>['users'];
+  /** The guild members behind the picked users. Discord resolves these only inside a guild. */
+  protected get members(): MentionableSelectMenuInteraction<Cache>['members'];
+  /** The roles this select picked. */
+  protected get roles(): MentionableSelectMenuInteraction<Cache>['roles'];
+}
 //#endregion
 //#region src/pagination/PageContext.d.ts
 /**
@@ -1703,7 +1779,7 @@ interface PageContext {
 }
 //#endregion
 //#region src/pagination/Paginator.d.ts
-type PaginatorHandlerCtor<Prefix extends string> = new (event: ButtonInteraction<CacheType>, core: Core) => ButtonHandler<[PageCursor<Prefix>], CacheType> & {
+type PaginatorHandlerCtor<Prefix extends string> = new (...args: ConstructorParameters<typeof ButtonHandler>) => ButtonHandler<[PageCursor<Prefix>], CacheType> & {
   execute(): Promise<void>;
 };
 /**
@@ -1856,5 +1932,5 @@ declare class Seedcord extends Pluggable<'gateway', 'server'> implements Core, S
 /** Package version */
 declare const version: string;
 //#endregion
-export { ArraySource, AssignRoleNoticeOverrides, AutocompleteHandler, BaseHandler, ButtonHandler, ChannelMenuHandler, type CheckPermissionOptions, ComponentHandler, type ConfirmOptions, type Core, CursorSource, type DefaultConfirmOptions, Emojis, type EventGateContext, EventHandler, EventMiddleware, type EventSpec, type EventsConfig, type GateContext, Gated, type GatewayBotConfig, type GatewayConfig, GatewayEmoji, type GatewayFile, type GatewayPluginOptions, type GatewayReplyResponse, HasPermsToAssignOptions, IgnoreBots, type InjectedEmojiMap, type InteractionGateContext, InteractionHandler, InteractionMiddleware, MentionableMenuHandler, MessageContextMenuHandler, Middleware, type MiddlewareOptions, MiddlewareType, ModalHandler, Nsfw, type PageContext, type PageSource, Paginator, Plugin, type PluginLifecycleSpec, type PluginOptions, RegisterEvent, type RegisterEventOptions, RepliableHandler, type Repliables, ReplySender, RoleMenuHandler, Seedcord, SelectMenuHandler, type SentMessage, SlashHandler, type SlashOptions, StringMenuHandler, Subscriber, UserContextMenuHandler, UserMenuHandler, type ValidEventTypes, type ValidInteractionTypes, type ValidNonInteractionKeys, WebhookLog, WinstonConsoleSink, WinstonFileSink, checkBotPermissions, checkPermissions, getConfirmation, hasPermsToAssign, version };
+export { ArraySource, AssignRoleNoticeOverrides, AutocompleteHandler, BaseHandler, ButtonHandler, ChannelMenuHandler, type CheckPermissionOptions, ComponentHandler, type ConfirmOptions, type Core, CursorSource, type DefaultConfirmOptions, Emojis, type EventGateContext, EventHandler, EventMiddleware, type EventMiddlewareOptions, type EventSpec, type EventsConfig, type GateContext, Gated, type GatewayBotConfig, type GatewayConfig, GatewayEmoji, type GatewayFile, type GatewayPluginOptions, type GatewayReplyResponse, HasPermsToAssignOptions, IgnoreBots, type InjectedEmojiMap, type InteractionGateContext, InteractionHandler, InteractionMiddleware, MentionableMenuHandler, MessageContextMenuHandler, ModalHandler, Nsfw, type PageContext, type PageSource, Paginator, Plugin, type PluginLifecycleSpec, type PluginOptions, RegisterEvent, RegisterEventMiddleware, type RegisterEventOptions, RepliableHandler, type Repliables, ReplySender, RoleMenuHandler, Seedcord, SelectMenuHandler, type SentMessage, SlashHandler, type SlashOptions, StringMenuHandler, Subscriber, UserContextMenuHandler, UserMenuHandler, type ValidEventTypes, type ValidInteractionTypes, type ValidNonInteractionKeys, WebhookLog, WinstonConsoleSink, WinstonFileSink, checkBotPermissions, checkPermissions, getConfirmation, hasPermsToAssign, version };
 //# sourceMappingURL=index.d.mts.map