@seedcord/gateway 0.0.1 → 0.1.0-next.0

package/dist/index.d.mts

@@ -1,6 +1,2532 @@
-//#region src/index.d.ts
+import { BuilderComponent, CoreBase, Gate, GateContextBase, GateNoticeOptions, MessageContextMenuRegistry, Notice, OptionKind, PageView, RegisterCommand, RequiredOf, SlashOptionRegistry, UserContextMenuRegistry } from "@seedcord/core";
+import { AnyCustomId, DecodedParams, GateFitsWith, HasComponentDefs, PageCursor } from "@seedcord/core/internal";
+import { APIInteractionGuildMember, APIMessageComponentEmoji, AnySelectMenuInteraction, ApplicationCommand, ApplicationCommandOptionChoiceData, ApplicationCommandType, ApplicationEmoji, AutocompleteInteraction, BooleanCache, ButtonInteraction, ButtonStyle, CacheType, CacheTypeReducer, ChannelSelectMenuInteraction, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Collection, CommandInteractionOption, ContextMenuCommandInteraction, Events, Guild, GuildEmoji, GuildMember, Interaction, MentionableSelectMenuInteraction, Message, MessageContextMenuCommandInteraction, ModalSubmitInteraction, Role, RoleSelectMenuInteraction, Snowflake, StringSelectMenuInteraction, TextChannel, TextChannelResolvable, User, UserContextMenuCommandInteraction, UserSelectMenuInteraction, WebhookClient } from "discord.js";
+import { CoordinatedShutdown, CoordinatedStartup, Logger, SEEventMapLike, SENoEvents, StartupPhase, StrictEventEmitter } from "@seedcord/services";
+import { ActionRowBuilder, ButtonBuilder, ContextMenuCommandBuilder, SlashCommandBuilder } from "@discordjs/builders";
+import { HmrAware, HmrUpdateEvent, SeedcordBrand, SeedcordInstance } from "@seedcord/types/internal";
+import { UUID } from "node:crypto";
+import { BotConfig, Config, EmojiMap, IRateLimiter, Nullable, ReplyResponse, Tail, V2Component } from "@seedcord/types";
+export * from "@seedcord/core";
+export * from "@seedcord/errors";
+export * from "@seedcord/utils";
+export * from "@seedcord/services";
+export * from "@seedcord/rate-limiter";
+export type * from "@seedcord/types";
+
+//#region src/bot/utilities/miscellaneous/contextMenuLeaves.d.ts
+/** The registered context-menu command names, split by kind, deduplicated. @internal */
+interface ContextMenuLeaves {
+  readonly user: Set<string>;
+  readonly message: Set<string>;
+}
+//#endregion
+//#region src/interfaces/Config.d.ts
+/**
+ * Djs Events handlers
+ */
+type EventsConfig = {
+  /**
+   * Path to dir containing event handlers.
+   */
+  path: string;
+  /**
+   * Optional path to event middleware directory
+   */
+  middlewares?: string;
+} | {
+  /** No events configured */path: null;
+};
+/**
+ * The gateway transport's bot configuration, the shared {@link BotConfig} plus the pieces only a
+ * gateway bot has, the discord.js client options and the gateway event handlers.
+ */
+interface GatewayBotConfig extends BotConfig {
+  /**
+   * Passed directly to the discord.js `Client` constructor.
+   */
+  clientOptions: ClientOptions;
+  events: EventsConfig;
+}
+/**
+ * The gateway transport's configuration, what the {@link Seedcord} constructor takes.
+ */
+interface GatewayConfig extends Config {
+  bot: GatewayBotConfig;
+}
+//#endregion
+//#region src/interfaces/Plugin.d.ts
+/** Interface for objects that can be initialized asynchronously */
+interface Initializeable {
+  init(): Promise<void>;
+}
+/**
+ * Base class for Seedcord plugins
+ *
+ * Extend this class to create plugins that integrate with the Seedcord lifecycle.
+ * Plugins have access to the core instance and must implement initialization logic.
+ */
+declare abstract class Plugin<TPluginEvents extends SEEventMapLike<TPluginEvents> = SENoEvents> extends StrictEventEmitter<TPluginEvents> implements Initializeable, HmrAware {
+  protected pluggable: Core;
+  /** Logger instance for this plugin. */
+  abstract logger: Logger;
+  name: string;
+  constructor(pluggable: Core);
+  /**
+   * Initialize the plugin.
+   * @virtual
+   */
+  abstract init(): Promise<void>;
+  /**
+   * Reloads plugin state on an HMR update. The base implementation is a no-op, override it in your plugin.
+   * @virtual
+   */
+  onHmr(_event: HmrUpdateEvent): Promise<void>;
+  /**
+   * Registers critical file patterns that should trigger a full restart when changed in Dev HMR.
+   * @param patterns - Glob patterns relative to the project root
+   */
+  protected registerCriticalFiles(patterns: string[]): void;
+  /** @internal */
+  setMaxListeners(n: number): this;
+  /** @internal */
+  removeListener<TEventKey extends Extract<keyof TPluginEvents, string | symbol>>(event: TEventKey, listener: (...args: TPluginEvents[TEventKey]) => void): this;
+  /** @internal */
+  removeAllListeners(eventName?: string | symbol): this;
+}
+/**
+ * Constructor type for plugins that can accept additional arguments after Core
+ * @typeParam TPlugin - The plugin type being constructed
+ *
+ * @internal
+ */
+type PluginCtor<TPlugin extends Plugin = Plugin> = new (core: Core, ...args: any[]) => TPlugin;
+/**
+ * Extracts the argument types for a plugin constructor (excluding the Core parameter)
+ * @typeParam Ctor - The plugin constructor to extract arguments from
+ *
+ * @internal
+ */
+type PluginArgs<Ctor extends PluginCtor> = Tail<ConstructorParameters<Ctor>>;
+/**
+ * Base class for objects that can have plugins attached.
+ *
+ * Provides plugin attachment capabilities and lifecycle management. Plugins are attached during
+ * configuration and initialized during startup. Not constructed directly, the host is a {@link Seedcord}.
+ */
+declare class Pluggable<TPluggableEvents extends SEEventMapLike<TPluggableEvents> = SENoEvents> extends StrictEventEmitter<TPluggableEvents> {
+  protected isInitialized: boolean;
+  protected readonly shutdown: CoordinatedShutdown;
+  protected readonly startup: CoordinatedStartup;
+  protected readonly plugins: Plugin[];
+  private static readonly PLUGIN_INIT_TIMEOUT_MS;
+  constructor(shutdown: CoordinatedShutdown, startup: CoordinatedStartup);
+  /** @internal */
+  protected init(): Promise<this>;
+  /**
+   * Attaches a plugin to this instance
+   *
+   * Plugins provide external functionality and are initialized during the specified startup phase.
+   * The plugin instance becomes available as a property in `core` wherever it's available.
+   *
+   * Make sure to augment the {@link Core} interface with the plugin type to ensure TypeScript recognizes it and provides intellisense.
+   *
+   * @typeParam Key - The property name for accessing the plugin
+   * @typeParam Ctor - The plugin constructor type
+   * @param key - Property name to access the plugin instance
+   * @param Plugin - Plugin constructor class
+   * @param startupPhase - When during startup to initialize this plugin ({@link StartupPhase})
+   * @param args - Additional arguments to pass to the plugin constructor
+   * @returns This instance with the plugin attached as a typed property
+   * @throws A **SeedcordError** When called after initialization or if key already exists
+   * @example
+   * ```typescript
+   * seedcord.attach('db', Mongo, StartupPhase.Configuration, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
+   * ```
+   */
+  attach<Key extends string, Ctor extends PluginCtor>(this: this, key: Key, Plugin: Ctor, startupPhase: StartupPhase, ...args: PluginArgs<Ctor>): this & Record<Key, InstanceType<Ctor>>;
+  /** @internal */
+  setMaxListeners(n: number): this;
+  /** @internal */
+  removeListener<TEventKey extends Extract<keyof TPluggableEvents, string | symbol>>(event: TEventKey, listener: (...args: TPluggableEvents[TEventKey]) => void): this;
+  /** @internal */
+  removeAllListeners(eventName?: string | symbol): this;
+}
+//#endregion
+//#region src/subscribers/types/Subscriptions.d.ts
+/**
+ * Where a reported fault came from. A union over `kind`.
+ */
+type FaultSource = InteractionFaultSource | EventFaultSource;
+/**
+ * A fault that came from a discord interaction, JSON-safe for a webhook payload.
+ */
+interface InteractionFaultSource {
+  kind: 'interaction';
+  /** Which interaction kind produced the fault. */
+  interactionKind: 'slash' | 'context-menu' | 'button' | 'select' | 'modal';
+  /** Slash or context-menu command name, null for component and modal interactions. */
+  command: string | null;
+  /** Component or modal customId, null for slash and context-menu interactions. */
+  customId: string | null;
+  /** User who triggered the interaction. */
+  userId: string;
+  /** Guild the interaction came from, null in DMs. */
+  guildId: string | null;
+  /** Channel the interaction came from, null when unavailable. */
+  channelId: string | null;
+  /** The interaction's own id. */
+  interactionId: string;
+  /** The raw interaction, made JSON-safe at serialization with filterCirculars. */
+  raw: unknown;
+}
+/**
+ * A fault that came from a client event, JSON-safe for a webhook payload. The actor, guild, and channel
+ * are best-effort, derived from the event args, so each is nullable. The raw args carry the full detail.
+ */
+interface EventFaultSource {
+  kind: 'event';
+  eventName: string;
+  handler: string;
+  /** Actor derived from the event args, null when none is present. */
+  userId: string | null;
+  /** Guild derived from the event args, null outside a guild. */
+  guildId: string | null;
+  /** Channel derived from the event args, null when none is present. */
+  channelId: string | null;
+  /** The raw event args, made JSON-safe at serialization with filterCirculars. */
+  raw: unknown;
+}
+/**
+ * Default subscribers that are always available in the framework.
+ */
+interface DefaultSubscriptions {
+  /** Triggered when an unhandled exception (a raw non-Notice throw) occurs */
+  unknownException: {
+    uuid: UUID;
+    error: Error;
+    guild: Nullable<Guild>;
+    user: Nullable<User>;
+    metadata?: unknown;
+  };
+  /** Triggered when a reported Notice (`report: true`) is caught */
+  handledException: {
+    denial: Notice;
+    uuid: UUID;
+    source: FaultSource;
+  };
+}
+/**
+ * Custom subscribers defined by the application.
+ *
+ * This interface can be augmented via declaration merging to add
+ * type-safe custom subscriber definitions for emitting custom subscribers anywhere in the application.
+ *
+ * @example
+ * ```typescript
+ * declare module '@seedcord/gateway' {
+ *   interface Subscriptions {
+ *     'userJoin': { user: User; guild: Guild };
+ *     'levelUp': { user: User; level: number; guild: Guild };
+ *   }
+ * }
+ * ```
+ */
+interface Subscriptions {}
+/**
+ * Combined subscribers interface containing both default and custom subscribers.
+ */
+interface AllSubscriptions extends DefaultSubscriptions, Subscriptions {}
+/**
+ * Helper type to extract all available subscriber event names.
+ */
+type SubscriptionKey = keyof AllSubscriptions;
+/**
+ * Helper type to get parameters for a specific subscriber event.
+ *
+ * @typeParam KeyOfSubscribers - The subscriber event name
+ */
+type SubscriptionData<KeyOfSubscribers extends SubscriptionKey> = AllSubscriptions[KeyOfSubscribers];
+/**
+ * Event map for Bus, compatible with StrictEventEmitter.
+ *
+ * @internal
+ */
+type SubscriptionTuples = { [K in SubscriptionKey]: [AllSubscriptions[K]] };
+//#endregion
+//#region src/subscribers/Bus.d.ts
+/**
+ * Manages application subscribers and event handling
+ *
+ * Provides a centralized system for registering and executing custom subscribers
+ * throughout the application lifecycle. Bus subscribers are loaded from configured directories
+ * and can be triggered programmatically or by framework events. Accessed via `core.bus`. Do not
+ * construct it directly.
+ */
+declare class Bus extends Plugin<SubscriptionTuples> {
+  protected core: Core;
+  readonly logger: Logger;
+  /** @internal */
+  readonly name = "Subscribers";
+  private isInitialized;
+  private readonly subscribersMap;
+  private readonly executedOnceHandlers;
+  private readonly hmrHandler?;
+  constructor(core: Core);
+  private getArtifacts;
+  /** @internal */
+  init(): Promise<void>;
+  /** @internal For use in dev mode */
+  onHmr(event: HmrUpdateEvent): Promise<void>;
+  private loadSubscribers;
+  private registerSubscriber;
+  private unregisterSubscriber;
+  private isSubscriber;
+  /**
+   * Publishes an event to its subscribers and native listeners.
+   *
+   * Fire-and-forget, so subscriber handlers run asynchronously and this returns before they
+   * complete, and callers must not assume side effects have landed. Errors thrown by a subscriber
+   * are caught and logged, never surfaced here. A `'once'` subscriber is marked as executed when
+   * it starts (even if it throws), so it never runs twice.
+   *
+   * @param event - The subscription key to publish
+   * @param data - Payload passed to each subscriber
+   * @returns Whether the underlying emitter had native listeners for the event
+   */
+  publish<KeyOfSubscribers extends SubscriptionKey>(event: KeyOfSubscribers, data: AllSubscriptions[KeyOfSubscribers]): boolean;
+  private processSubscriber;
+}
+//#endregion
+//#region src/interfaces/Core.d.ts
+/**
+ * Main interface for Seedcord core functionality
+ *
+ * This interface can be augmented via declaration merging to add
+ * type-safe plugin definitions when using `this.core#` in handlers.
+ *
+ * Only add classes that extend {@link Plugin} to this
+ *
+ * @example
+ * ```typescript
+ * declare module '@seedcord/gateway' {
+ *   interface Core {
+ *     db: Mongo;
+ *   }
+ * }
+ * ```
+ * */
+interface Core extends CoreBase, SeedcordInstance {
+  readonly shutdown: CoordinatedShutdown;
+  readonly startup: CoordinatedStartup;
+  readonly bot: Bot;
+  readonly bus: Bus;
+  readonly config: GatewayConfig;
+  start(): Promise<this>;
+}
+//#endregion
+//#region src/bot/controllers/CommandRegistry.d.ts
+/** The command collections Discord returns from each scope's deploy, keyed by command id. */
+interface DeployResult {
+  global: Collection<Snowflake, ApplicationCommand>;
+  guilds: Collection<Snowflake, Collection<Snowflake, ApplicationCommand>>;
+}
+/**
+ * Manages Discord application command registration and deployment.
+ *
+ * Scans command directories, builds command structures, and registers both global and guild-scoped commands
+ * to Discord's API. Accessed via `core.bot.commands`. Do not construct it directly.
+ */
+declare class CommandRegistry implements Initializeable, HmrAware {
+  private readonly core;
+  private readonly onDeployed?;
+  readonly name = "Commands";
+  private readonly logger;
+  private isInitialised;
+  readonly globalCommands: (SlashCommandBuilder | ContextMenuCommandBuilder)[];
+  readonly guildCommands: Collection<string, (SlashCommandBuilder | ContextMenuCommandBuilder)[]>;
+  private readonly ctorToCommand;
+  private readonly hmrHandler?;
+  private readonly pendingEvents;
+  constructor(core: Core, onDeployed?: ((result: DeployResult) => void) | undefined);
+  private getArtifacts;
+  /** @internal */
+  init(): Promise<void>;
+  /** @internal */
+  refresh(shouldRefresh?: boolean): Promise<void>;
+  /** @internal */
+  onHmr(event: HmrUpdateEvent): Promise<void>;
+  private loadCommands;
+  private isCommandClass;
+  private registerCommand;
+  private unregisterCommand;
+  /** @internal */
+  setCommands(): Promise<DeployResult>;
+  /** The deduplicated slash route keys across every global and guild command. @internal */
+  routeLeaves(): Set<string>;
+  /** The registered context-menu command names, split by kind, across every global and guild command. @internal */
+  contextMenuLeaves(): ContextMenuLeaves;
+}
+//#endregion
+//#region src/bot/injectors/CommandMentionInjector.d.ts
+/** Each registered slash route mapped to its mention string. */
+type InjectedMentionMap = { [K in keyof SlashOptionRegistry]: string };
+/**
+ * Ready-to-send command mention strings, keyed by {@link SlashOptionRegistry}.
+ *
+ * A value is a clickable `</name:id>` when the command's id resolved from the deploy, otherwise the plain
+ * `/name` text. Populated by {@link CommandMentionInjector} after each deploy.
+ */
+declare const CommandMentions: InjectedMentionMap;
+//#endregion
+//#region src/bot/injectors/EmojiInjector.d.ts
+/**
+ * The global {@link Emojis} accessor type. Each key 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' ? GuildEmoji : ApplicationEmoji };
+/**
+ * Global emoji mappings object
+ *
+ * @see {@link EmojiMap}
+ */
+declare const Emojis: InjectedEmojiMap;
+//#endregion
+//#region src/bot/Bot.d.ts
+/**
+ * Types of events emitted by the {@link Core.bot} instance.
+ */
+interface BotEvents {
+  /** Emitted when an unhandled interaction error occurs */
+  'error:unhandled:interaction': [error: Error];
+  /** Emitted when an unhandled event error occurs */
+  'error:unhandled:event': [error: Error];
+  /** Emitted for any event */
+  'any:event': { [K in keyof ClientEvents]: [K, ...ClientEvents[K]] }[keyof ClientEvents];
+  /** Emitted for any interaction */
+  'any:interaction': [interaction: Interaction];
+}
+/**
+ * Discord bot implementation that manages client and controllers
+ *
+ * Don't instantiate this class directly. Use `core.bot` instead.
+ */
+declare class Bot extends Plugin<BotEvents> {
+  readonly botToken: string;
+  /** @internal */
+  readonly logger: Logger;
+  private isInitialized;
+  private readonly _client;
+  private readonly interactions?;
+  private readonly events?;
+  readonly commands?: CommandRegistry;
+  private readonly emojiInjector;
+  readonly emojis: InjectedEmojiMap;
+  readonly mentions: InjectedMentionMap;
+  /** @internal For use in dev mode */
+  onHmr(event: HmrUpdateEvent): Promise<void>;
+  /** @internal */
+  constructor(core: Core);
+  /**
+   * Initializes Discord client and all controllers
+   * @internal
+   */
+  init(): Promise<void>;
+  /**
+   * Stops the bot and cleans up connections
+   * @internal
+   */
+  stop(): Promise<void>;
+  /**
+   * Logs the bot into Discord using the configured token
+   */
+  private login;
+  /**
+   * Logs out and destroys the Discord client connection
+   */
+  private logout;
+  get client(): Client;
+  /**
+   * Emits a Discord event with its argument tuple. The overloads enforce the key/args correlation
+   * at compile time only; at runtime this forwards straight to the underlying EventEmitter.
+   *
+   * @internal
+   */
+  emit<TKey extends keyof ClientEvents>(event: 'any:event', name: TKey, ...args: ClientEvents[TKey]): boolean;
+  /** @internal */
+  emit<TEventKey extends keyof BotEvents>(event: TEventKey, ...args: BotEvents[TEventKey]): boolean;
+}
+//#endregion
+//#region src/handlers/BaseHandler.d.ts
+type ValidInteractionTypes = ChatInputCommandInteraction | ButtonInteraction | ModalSubmitInteraction | AutocompleteInteraction | AnySelectMenuInteraction | ContextMenuCommandInteraction;
+type ValidNonInteractionKeys = Exclude<keyof ClientEvents, Events.InteractionCreate>;
+type ValidEventTypes = ValidInteractionTypes | ClientEvents[ValidNonInteractionKeys];
+type Repliables = Exclude<ValidInteractionTypes, AutocompleteInteraction>;
+type NonModalInteraction = Exclude<Repliables, ModalSubmitInteraction>;
+/** @internal */
+interface Handler {
+  execute(): Promise<void>;
+}
+/**
+ * Base class for a Discord event or interaction handler. Don't register handlers directly, use the more specific handler subclasses.
+ */
+declare abstract class BaseHandler<ValidEvent extends ValidEventTypes> implements Handler {
+  readonly core: Core;
+  protected readonly event: ValidEvent;
+  protected readonly logger: Logger;
+  protected constructor(event: ValidEvent, core: Core);
+  /**
+   * Holds the main logic of your handler. The dispatcher calls it after the handler's gates pass, so a
+   * gate that refuses stops `execute()` from running.
+   */
+  abstract execute(): Promise<void>;
+  /** @internal */
+  getEvent(): ValidEvent;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/basic.d.ts
+/**
+Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Class
+*/
+type Constructor<T, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-never.d.ts
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-equal.d.ts
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/non-empty-tuple.d.ts
+/**
+Matches any non-empty tuple.
+
+@example
+```
+import type {NonEmptyTuple} from 'type-fest';
+
+const sum = (...numbers: NonEmptyTuple<number>) => numbers.reduce((total, value) => total + value, 0);
+
+sum(1, 2, 3);
+// Ok
+
+// @ts-expect-error
+sum();
+// Error: Expected at least 1 arguments, but got 0.
+```
+
+@see {@link RequireAtLeastOne} for objects
+
+@category Array
+*/
+type NonEmptyTuple<T = unknown> = readonly [T, ...T[]];
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-union.d.ts
+/**
+Returns a boolean for whether the given type is a union.
+
+@example
+```
+import type {IsUnion} from 'type-fest';
+
+type A = IsUnion<string | number>;
+//=> true
+
+type B = IsUnion<string>;
+//=> false
+```
+*/
+type IsUnion<T> = InternalIsUnion<T>;
+/**
+The actual implementation of `IsUnion`.
+*/
+type InternalIsUnion<T, U = T> = (IsNever<T> extends true ? false : T extends any ? IsEqual<U, T> extends true ? false : true : never) extends infer Result // In some cases `Result` will return `false | true` which is `boolean`,
+// that means `T` has at least two types and it's a union type,
+// so we will return `true` instead of `boolean`.
+? boolean extends Result ? true : Result : never; // Should never happen
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/promisable.d.ts
+/**
+Create a type that represents either the value or the value wrapped in `PromiseLike`.
+
+Use-cases:
+- A function accepts a callback that may either return a value synchronously or may return a promised value.
+- This type could be the return type of `Promise#then()`, `Promise#catch()`, and `Promise#finally()` callbacks.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31394) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+import type {Promisable} from 'type-fest';
+
+async function logger(getLogEntry: () => Promisable<string>): Promise<void> {
+	const entry = await getLogEntry();
+	console.log(entry);
+}
+
+await logger(() => 'foo');
+await logger(() => Promise.resolve('bar'));
+```
+
+@category Async
+*/
+type Promisable<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/handlers/event/payload.d.ts
+/** @internal */
+type SingleEventPayload<Names extends ValidNonInteractionKeys> = IsUnion<Names> extends true ? never : ClientEvents[Names];
+//#endregion
+//#region src/handlers/event/EventHandler.d.ts
+type EventMatchArms<Names extends ValidNonInteractionKeys, Ret> = { [Name in Names]: (...args: ClientEvents[Name]) => Promisable<Ret> };
+/**
+ * Base class for a Discord client event handler.
+ *
+ * Pass the event name(s) as the generic, the same one(s) as `@RegisterEvent`. A single-event handler reads
+ * `this.event` (the payload tuple) directly. A handler registered for several events branches with `this.match`,
+ * keyed by event name, since the union of payload tuples is not directly readable.
+ *
+ * @typeParam Names - One or more `ClientEvents` keys, e.g. `Events.MessageCreate` or `Events.MessageCreate | Events.MessageUpdate`.
+ *
+ * @example
+ * ```ts
+ * \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
+ * class PingPong extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+ *     async execute() {
+ *         await this.match({
+ *             [Events.MessageCreate]: (message) => message.reply('pong'),
+ *             [Events.MessageUpdate]: (_oldMessage, edited) => edited.reply('pong')
+ *         });
+ *     }
+ * }
+ * ```
+ */
+declare abstract class EventHandler<Names extends ValidNonInteractionKeys> extends BaseHandler<ClientEvents[Names]> implements Handler {
+  private readonly firedEvent;
+  constructor(event: ClientEvents[Names], core: Core, eventName?: Names);
+  protected readonly event: SingleEventPayload<Names>;
+  /**
+   * Run the arm for whichever event fired. Use this only when the handler is registered for several
+   * events. A single-event handler reads `this.event` directly. On a multi-event handler `this.event` is
+   * `never`, so match is the only way to read the payload.
+   *
+   * Provide one arm per registered event, keyed by its name, and each arm receives that event's own
+   * payload tuple. The arms must cover every event in the generic, a missing event or an unknown key is a
+   * compile error.
+   *
+   * @param arms - One handler per registered event, keyed by event name.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
+   * class MessageWatcher extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+   *     async execute() {
+   *         await this.match({
+   *             [Events.MessageCreate]: (message) => this.scan(message),
+   *             [Events.MessageUpdate]: (_old, updated) => this.scan(updated)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: EventMatchArms<Names, Ret>): Promise<Ret>;
+}
+//#endregion
+//#region src/handlers/event/EventMiddleware.d.ts
+/**
+ * Base class for Discord event middleware.
+ *
+ * Middleware runs before event handlers and can stop the event by throwing a `Silence`. Unlike `EventHandler`, it
+ * runs the SAME for every event it is registered for, so it has no `match`. Specify a single event in the
+ * generic and `{ events }` to read `this.event` fully typed. Span several events (or omit `{ events }` for a
+ * catchall) and `this.event` narrows to `never`, read `this.eventName` and do work that does not depend on the
+ * payload shape. A middleware that needs each event's payload is written one event per class.
+ *
+ * @typeParam EventName - One or more `ClientEvents` keys. Defaults to every event (catchall).
+ */
+declare abstract class EventMiddleware<in out EventName extends ValidNonInteractionKeys = ValidNonInteractionKeys> extends BaseHandler<ClientEvents[EventName]> implements Handler {
+  private readonly firedEvent;
+  constructor(event: ClientEvents[EventName], core: Core, 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`
+   * is `never`, to do work that does not depend on the payload shape. A single-event middleware reads
+   * `this.event` directly and does not need this.
+   */
+  protected get eventName(): EventName;
+}
+//#endregion
+//#region src/miscellaneous/types.d.ts
+/**
+ * The frequency at which the event handler should be executed.
+ */
+type EventFrequency = 'once' | 'on';
+//#endregion
+//#region src/bot/decorators/Events.d.ts
+/** Options accepted by the event registration decorator. */
+interface RegisterEventOptions {
+  /**
+   * Frequency: 'once' or 'on'.
+   *
+   * @defaultValue `'on'`
+   */
+  readonly frequency?: EventFrequency | undefined;
+}
+/** Tuple describing a single event and optional options. */
+type EventSpec<EventKey extends ValidNonInteractionKeys> = readonly [event: EventKey, options?: RegisterEventOptions];
+/**
+ * Registers an event handler class with one or more Discord.js events.
+ *
+ * Associates the decorated class with the provided Discord client events for automatic registration and execution when those events are emitted.
+ *
+ * Supply any number of event tuples. Each tuple can include per event options.
+ *
+ * @typeParam EventKey - Union of Discord.js ClientEvents keys to register for
+ * @param defs - One or more tuples of [event, options]
+ * @decorator
+ * @example
+ * ```ts
+ * \@RegisterEvent([Events.MessageCreate])
+ * class MessageHandler extends EventHandler<Events.MessageCreate> {
+ *   async execute() {
+ *     // Handle message creation
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
+ * class MessageHandler extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+ *   async execute() {
+ *     // Handle message creation or update
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * \@RegisterEvent([Events.MessageCreate, { frequency: 'once' }], [Events.MessageUpdate])
+ * class OneTimeMessageHandler extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+ *   async execute() {
+ *     // Handle only the first message creation, and message update normally
+ *   }
+ * }
+ * ```
+ */
+declare function RegisterEvent<const Defs extends readonly EventSpec<ValidNonInteractionKeys>[]>(...defs: Defs): <HandlerCtor extends Constructor<EventHandler<Defs[number][0]>>>(constructor: HandlerCtor) => void;
+//#endregion
+//#region src/bot/gates/Gate.d.ts
+/**
+ * The interaction arm. It extends the scalar {@link GateContextBase} with the live interaction and
+ * the rich djs objects the gateway cache provides. `Repliable` is the interaction type the gate
+ * supports, inferred from the `ctx` annotation, so a gate reading button-specific fields is rejected
+ * on a slash handler. `interaction` is the reply target, so `user` is always present. Use
+ * {@link NonModalInteraction} to exclude ModalSubmit when the gate needs a reliable caller member or
+ * channel.
+ *
+ * @typeParam Repliable - The interaction type the gate reads, narrowing which handlers accept it.
+ *
+ * @example
+ * ```ts
+ * import type { ButtonInteraction } from 'discord.js';
+ *
+ * // a button-only gate: the Repliable generic narrows which handlers accept it
+ * const ButtonGate = defineGate('btn', (ctx: InteractionGateContext<ButtonInteraction>) => {
+ *     void ctx.interaction; // ButtonInteraction
+ * });
+ * ```
+ */
+interface InteractionGateContext<Repliable extends Repliables = Repliables> extends GateContextBase {
+  /** Marks the interaction arm, narrow on it before reading `interaction`. */
+  readonly kind: 'interaction';
+  /** The running framework, with the gateway's bot and bus. */
+  readonly core: Core;
+  /** The interaction being handled, which is the reply target. */
+  readonly interaction: Repliable;
+  /** The invoking user, always present on an interaction. */
+  readonly user: User;
+  /** The guild the interaction happened in, or null in a DM. */
+  readonly guild: Guild | null;
+  /** The invoking member from the cache, or null outside a guild or when uncached. */
+  readonly member: GuildMember | null;
+}
+/**
+ * The event arm. It extends the scalar {@link GateContextBase} with the event payload and the djs
+ * objects derived from it. `Names` is the event(s) the gate supports, inferred from the `ctx`
+ * annotation, so a gate that reads one event's `payload` is rejected on a handler for a different
+ * event. The default supports every event.
+ *
+ * @typeParam Names - The event name or names the gate reads, typing `payload` to that event's args tuple.
+ *
+ * @example
+ * ```ts
+ * import { Events } from 'discord.js';
+ *
+ * // gate keyed to one event, so payload is typed to that event's args tuple
+ * const OnMessage = defineGate('msg', (ctx: EventGateContext<Events.MessageCreate>) => {
+ *     void ctx.payload; // [Message]
+ * });
+ * ```
+ */
+interface EventGateContext<Names extends ValidNonInteractionKeys = ValidNonInteractionKeys> extends GateContextBase {
+  /** Marks the event arm, narrow on it before reading `payload`. */
+  readonly kind: 'event';
+  /** The running framework, with the gateway's bot and bus. */
+  readonly core: Core;
+  /** The event being handled. */
+  readonly eventName: Names;
+  /** The event's arguments, typed to that event's args tuple. */
+  readonly payload: ClientEvents[Names];
+  /** The acting user derived from the payload, or null when the event carries none. */
+  readonly user: User | null;
+  /** The guild derived from the payload, or null. */
+  readonly guild: Guild | null;
+  /** The acting member derived from the payload, or null. */
+  readonly member: GuildMember | null;
+}
+/**
+ * What a gateway gate's check receives, tagged by `ctx.kind`. Narrow on `kind` before reading
+ * `interaction` or `payload`.
+ *
+ * @see {@link InteractionGateContext}
+ * @see {@link EventGateContext}
+ *
+ * @example
+ * ```ts
+ * // a gate that handles either arm narrows on ctx.kind
+ * const Either = defineGate('either', (ctx: GateContext) => {
+ *     if (ctx.kind === 'interaction') void ctx.interaction;
+ *     else void ctx.payload;
+ * });
+ * ```
+ */
+type GateContext = InteractionGateContext | EventGateContext;
+//#endregion
+//#region src/handlers/interaction/InteractionHandler.d.ts
+/**
+ * Shared base the typed interaction handlers extend.
+ *
+ * Not a public entry point. You should be using {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
+ * or {@link SelectMenuHandler} instead. This class only carries the repliable-event plumbing those bases share,
+ * so DO NOT use it directly.
+ *
+ * @typeParam Repliable - The interaction type this handler processes
+ */
+declare abstract class InteractionHandler<Repliable extends Repliables> extends BaseHandler<Repliable> implements Handler {
+  constructor(event: Repliable, core: Core);
+}
+//#endregion
+//#region src/bot/gates/matching.d.ts
+type AnyHandlerCtor = abstract new (...args: never[]) => {
+  execute(): Promise<void>;
+  getEvent(): ValidEventTypes;
+};
+declare const UngateableBrand: unique symbol;
+interface Ungateable {
+  readonly [UngateableBrand]: true;
+}
+type ProvidedContext<TCtor extends AnyHandlerCtor> = InstanceType<TCtor> extends InteractionHandler<infer Repliable> ? InteractionGateContext<Repliable> : InstanceType<TCtor> extends EventHandler<infer Names> ? EventGateContext<Names> : Ungateable;
+type KindName<Ctx> = Ctx extends Ungateable ? 'autocomplete' : Ctx extends InteractionGateContext<infer R> ? R extends ChatInputCommandInteraction ? 'Slash' : R extends MessageContextMenuCommandInteraction ? 'MessageMenu' : R extends UserContextMenuCommandInteraction ? 'UserMenu' : R extends StringSelectMenuInteraction ? 'StringSelect' : R extends UserSelectMenuInteraction ? 'UserSelect' : R extends RoleSelectMenuInteraction ? 'RoleSelect' : R extends ChannelSelectMenuInteraction ? 'ChannelSelect' : R extends MentionableSelectMenuInteraction ? 'MentionableSelect' : R extends ButtonInteraction ? 'Button' : R extends ModalSubmitInteraction ? 'Modal' : 'an interaction' : Ctx extends EventGateContext<infer N> ? `${N & string} event` : 'an agnostic';
+type FitAll<TCtor extends AnyHandlerCtor, Gates extends readonly Gate<GateContextBase>[]> = { [Index in keyof Gates]: GateFitsWith<ProvidedContext<TCtor>, KindName<ProvidedContext<TCtor>>, Gates[Index], KindName<RequiredOf<Gates[Index]>>> };
+//#endregion
+//#region src/bot/decorators/Gated.d.ts
+/**
+ * Attaches gates to a handler. The gates run before `execute`, and a gate refusing stops the handler with
+ * the reply or drop the gate threw. Multiple gates are ANDed, so each must pass. A gate that requires a
+ * context the handler does not provide (a button gate on a slash handler, an interaction gate on an event
+ * handler) is a compile error at this line, and the error names the gate and the handler kind. Place it
+ * above the route decorator.
+ *
+ * Combine gates with {@link and} or {@link or} to build a single gate from multiple arms.
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ *
+ * \@Gated(GuildOnly(), RequirePermissions([PermissionFlagsBits.Administrator]))
+ * \@SlashRoute('maintenance')
+ * class Maintenance extends SlashHandler<'maintenance'> {
+ *     async execute() {
+ *         // both gates passed, so this runs in a guild with an admin caller
+ *     }
+ * }
+ * ```
+ *
+ * @typeParam Gates - The non-empty tuple of gates to run, in order, against the handler's context.
+ * @typeParam TCtor - The decorated handler's constructor, checked against every gate's required context.
+ * @param gates - One or more gates to attach, each ANDed so the handler runs only when all pass.
+ * @param ctor - The handler class being decorated, rejected at compile time when a gate needs a context it lacks.
+ *
+ * @see {@link defineGate}
+ * @see {@link defineEffectGate}
+ * @decorator
+ */
+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/inputs/AutocompleteOptions.d.ts
+type Row$2<Route extends keyof SlashOptionRegistry> = SlashOptionRegistry[Route];
+type EntryFor$1<Route extends keyof SlashOptionRegistry, Name extends PropertyKey> = Route extends unknown ? Name extends keyof Row$2<Route> ? Row$2<Route>[Name] : never : never;
+type NamesOfKind$1<Route extends keyof SlashOptionRegistry, Kind extends OptionKind> = Route extends unknown ? { [Name in keyof Row$2<Route>]: Row$2<Route>[Name] extends {
+  kind: Kind;
+} ? Name : never }[keyof Row$2<Route>] : never;
+type ResolvedValue$1<Entry> = Entry extends {
+  choices: readonly (infer Choice)[];
+} ? Choice : Entry extends {
+  kind: 'string';
+} ? string : Entry extends {
+  kind: 'integer' | 'number';
+} ? number : Entry extends {
+  kind: 'boolean';
+} ? boolean : never;
+type Getter$1<Route extends keyof SlashOptionRegistry, Kind extends OptionKind, Method extends string> = IsNever<NamesOfKind$1<Route, Kind>> extends true ? unknown : Record<Method, <Name extends NamesOfKind$1<Route, Kind>>(name: Name) => ResolvedValue$1<EntryFor$1<Route, Name>> | null>;
+/**
+ * The sibling-option view for an autocomplete handler. Only the four kinds Discord resolves during autocomplete
+ * appear (string, integer, number, boolean), every read is `T | null` because a sibling is partial while the
+ * user types the focused field, and a getter appears only when a registered command has an option of that kind.
+ * Across several registered commands the view is the union of their options, so a getter for an option absent on
+ * the firing command returns null. Read the focused field from `this.focused`.
+ *
+ * @typeParam Route - One or more route keys from {@link SlashOptionRegistry}.
+ */
+type AutocompleteOptions<Route extends keyof SlashOptionRegistry> = Getter$1<Route, 'string', 'getString'> & Getter$1<Route, 'integer', 'getInteger'> & Getter$1<Route, 'number', 'getNumber'> & Getter$1<Route, 'boolean', 'getBoolean'>;
+//#endregion
+//#region src/handlers/interaction/AutocompleteHandler.d.ts
+type Row$1<Route extends keyof SlashOptionRegistry> = SlashOptionRegistry[Route];
+type AutocompletableNames<Route extends keyof SlashOptionRegistry> = Route extends unknown ? { [Name in keyof Row$1<Route>]: Row$1<Route>[Name] extends {
+  autocomplete: true;
+} ? Name : never }[keyof Row$1<Route>] : never;
+type EntryFor<Route extends keyof SlashOptionRegistry, Name extends PropertyKey> = Route extends unknown ? Name extends keyof Row$1<Route> ? Row$1<Route>[Name] : never : never;
+type ChoiceValueOf<Entry> = Entry extends {
+  kind: 'string';
+} ? string : Entry extends {
+  kind: 'integer' | 'number';
+} ? number : never;
+/** The focused option. `value` is the raw partial Discord delivers mid-type, always a string regardless of kind. */
+interface FocusedField<Route extends keyof SlashOptionRegistry> {
+  name: AutocompletableNames<Route>;
+  value: string;
+}
+/** One arm per autocompletable field, `value` is the focused partial, `respond` is pinned to the field's choice type. */
+type FocusedArms<Route extends keyof SlashOptionRegistry, 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 SlashOptionRegistry}, e.g. `'search'` or `'search' | 'find'`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
+ *
+ * @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 SlashOptionRegistry, Cache extends CacheType = 'cached'> extends BaseHandler<AutocompleteInteraction<Cache>> implements Handler {
+  constructor(event: AutocompleteInteraction<Cache>, core: Core);
+  /**
+   * The focused option for this interaction. `value` is always the raw partial string the user is typing,
+   * even for an integer or number option, so coerce it yourself when you need a number.
+   */
+  private decodedFocused?;
+  protected get focused(): FocusedField<Route>;
+  /**
+   * Run the arm for the focused field. An autocomplete always dispatches by which field is focused, so
+   * match is how you read it. There is no single-field shortcut the way slash/component handlers have one.
+   *
+   * Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
+   * arm receives the focused partial value and a `respond` pinned to that field's choice value type. The
+   * arms must cover every autocompletable field, a missing field or an unknown key is a compile error. A
+   * focused field with no arm, only reachable from a stale-deployed command, throws at runtime.
+   *
+   * @param arms - One handler per autocompletable field, keyed by field name.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@AutocompleteRoute('search')
+   * class SearchAutocomplete extends AutocompleteHandler<'search'> {
+   *     async execute() {
+   *         await this.match({
+   *             query: (value, respond) => respond(titles(value).map((s) => ({ name: s, value: s }))),
+   *             tag: (value, respond) => respond(tags(value).map((s) => ({ name: s, value: s })))
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: FocusedArms<Route, Ret>): Promise<Ret>;
+  /** The firing command route, for a field whose completion differs per registered command. */
+  protected get route(): Route;
+  /**
+   * The already-entered options on this command, restricted to the kinds Discord resolves during autocomplete
+   * (string, integer, number, boolean) with every read nullable, since a sibling is partial while the user
+   * types the focused field. Read the focused field from `this.focused`, not here.
+   */
+  protected get options(): AutocompleteOptions<Route>;
+}
+//#endregion
+//#region src/handlers/interaction/ContextMenuHandler.d.ts
+type ContextMenuKind = ApplicationCommandType.User | ApplicationCommandType.Message;
+type InteractionFor<Kind extends ContextMenuKind, Cache extends CacheType> = Kind extends ApplicationCommandType.User ? UserContextMenuCommandInteraction<Cache> : MessageContextMenuCommandInteraction<Cache>;
+type TargetFor<Kind extends ContextMenuKind, Cache extends CacheType> = Kind extends ApplicationCommandType.User ? User : Message<BooleanCache<Cache>>;
+type TargetMemberFor<Kind extends ContextMenuKind, Cache extends CacheType> = Kind extends ApplicationCommandType.User ? CacheTypeReducer<Cache, GuildMember, APIInteractionGuildMember> | null : never;
+/**
+ * Base class for a context-menu command handler (right-click a user or a message).
+ *
+ * Pass the kind from `discord.js`'s {@link ApplicationCommandType} as the generic, the same value as
+ * `@ContextMenuRoute`. Read the right-clicked entity from `this.target`, a `User` for a user menu and a
+ * `Message` for a message menu. Context menus carry no options, so a handler registered for several names
+ * reads `this.target` uniformly with no per-name branch.
+ *
+ * @typeParam Kind - `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
+ *
+ * @example
+ * ```ts
+ * \@ContextMenuRoute(ApplicationCommandType.Message, 'Report Message')
+ * class ReportMessage extends ContextMenuHandler<ApplicationCommandType.Message> {
+ *     async execute() {
+ *         const message = this.target;
+ *     }
+ * }
+ * ```
+ */
+declare abstract class ContextMenuHandler<Kind extends ContextMenuKind, Cache extends CacheType = 'cached'> extends InteractionHandler<InteractionFor<Kind, Cache>> {
+  protected get target(): TargetFor<Kind, Cache>;
+  /**
+   * The invoking guild member, resolved only on user menus. Reading it on a message menu is a compile
+   * error since the type is `never` there.
+   */
+  protected get targetMember(): TargetMemberFor<Kind, Cache>;
+}
+//#endregion
+//#region src/inputs/SlashOptions.d.ts
+type Row<Route extends keyof SlashOptionRegistry> = SlashOptionRegistry[Route];
+type NamesOfKind<Route extends keyof SlashOptionRegistry, Kind extends OptionKind> = { [Name in keyof Row<Route>]: Row<Route>[Name] extends {
+  kind: Kind;
+} ? Name : never }[keyof Row<Route>];
+type ResolvedValue<Cache extends CacheType, Entry> = Entry extends {
+  choices: readonly (infer Choice)[];
+} ? Choice : Entry extends {
+  kind: 'string';
+} ? string : Entry extends {
+  kind: 'integer' | 'number';
+} ? number : Entry extends {
+  kind: 'boolean';
+} ? boolean : Entry extends {
+  kind: 'user';
+} ? NonNullable<CommandInteractionOption<Cache>['user']> : Entry extends {
+  kind: 'channel';
+} ? NonNullable<CommandInteractionOption<Cache>['channel']> : Entry extends {
+  kind: 'role';
+} ? NonNullable<CommandInteractionOption<Cache>['role']> : Entry extends {
+  kind: 'mentionable';
+} ? NonNullable<CommandInteractionOption<Cache>['member' | 'role' | 'user']> : Entry extends {
+  kind: 'attachment';
+} ? NonNullable<CommandInteractionOption<Cache>['attachment']> : never;
+type Returned<Cache extends CacheType, Entry> = Entry extends {
+  required: true;
+} ? ResolvedValue<Cache, Entry> : ResolvedValue<Cache, Entry> | null;
+type Getter<Route extends keyof SlashOptionRegistry, Cache extends CacheType, Kind extends OptionKind, Method extends string> = IsNever<NamesOfKind<Route, Kind>> extends true ? unknown : Record<Method, <Name extends NamesOfKind<Route, Kind>>(name: Name) => Returned<Cache, Row<Route>[Name]>>;
+type MemberGetter<Route extends keyof SlashOptionRegistry, Cache extends CacheType> = IsNever<NamesOfKind<Route, 'user'>> extends true ? unknown : {
+  getMember: <Name extends NamesOfKind<Route, 'user'>>(name: Name) => NonNullable<CommandInteractionOption<Cache>['member']> | null;
+};
+/**
+ * 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.
+ *
+ * Pass the raw `this.event.options` resolver for anything this view does not cover, such as narrowing a
+ * channel option with `getChannel(name, channelTypes)`.
+ *
+ * @typeParam Route - A route key from the generated {@link SlashOptionRegistry}.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
+ */
+type SlashOptions<Route extends keyof SlashOptionRegistry, Cache extends CacheType = 'cached'> = Getter<Route, Cache, 'string', 'getString'> & Getter<Route, Cache, 'integer', 'getInteger'> & Getter<Route, Cache, 'number', 'getNumber'> & Getter<Route, Cache, 'boolean', 'getBoolean'> & Getter<Route, Cache, 'user', 'getUser'> & Getter<Route, Cache, 'channel', 'getChannel'> & Getter<Route, Cache, 'role', 'getRole'> & Getter<Route, Cache, 'mentionable', 'getMentionable'> & Getter<Route, Cache, 'attachment', 'getAttachment'> & MemberGetter<Route, Cache>;
+//#endregion
+//#region src/handlers/interaction/SlashHandler.d.ts
+type SlashMatchArms<Route extends keyof SlashOptionRegistry, 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 SlashOptionRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
+ *
+ * @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 SlashOptionRegistry, Cache extends CacheType = 'cached'> extends InteractionHandler<ChatInputCommandInteraction<Cache>> {
+  /**
+   * The typed options for this command's route. Required options drop the null, choices narrow to their
+   * literal union, and only the getters for kinds this command actually uses appear. Use `this.event.options`
+   * directly for anything outside this view, such as narrowing a channel option by type.
+   */
+  protected get options(): SlashOptions<Route, Cache>;
+  /**
+   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * routes. A single-route handler reads `this.options` directly instead, match buys nothing there.
+   *
+   * 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', true).id),
+   *             kick: (options) => this.event.guild?.members.kick(options.getUser('member', true).id)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: SlashMatchArms<Route, Cache, Ret>): Promise<Ret>;
+}
+//#endregion
+//#region src/bot/decorators/Interactions.d.ts
+/**
+ * Types of select menus supported for routing
+ */
+declare enum SelectMenuKind {
+  String = "string",
+  User = "user",
+  Role = "role",
+  Channel = "channel",
+  Mentionable = "mentionable"
+}
+/** @internal */
+type HandlerEventType<TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = InstanceType<TCtor> extends InteractionHandler<infer TEvent> ? TEvent : never;
+/**
+ * Compile-time assertion that the required event type(s) `TRequired` are included in the handler event union.
+ *
+ * @internal
+ */
+type AssertHandles<TRequired, TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = Extract<HandlerEventType<TCtor>, TRequired> extends never ? Constructor<['Handler event generic must include', TRequired]> : TCtor;
+/**
+ * The slash route(s) a handler serves, read off its `SlashHandler` generic.
+ *
+ * @internal
+ */
+type SlashRouteOf<TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = InstanceType<TCtor> extends SlashHandler<infer Route, CacheType> ? Route : never;
+/**
+ * On a route/generic mismatch, resolves to a non-constructor type so applying the decorator is a TS1238.
+ *
+ * @internal
+ */
+type AssertSlashRoute<Route extends string, TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = [Route] extends [SlashRouteOf<TCtor>] ? [SlashRouteOf<TCtor>] extends [Route] ? TCtor : Constructor<['SlashHandler declares a route the SlashRoute decorator does not list', SlashRouteOf<TCtor>]> : Constructor<['SlashRoute does not match the SlashHandler generic', Route]>;
+/**
+ * Routes one or more slash commands to a {@link SlashHandler}.
+ *
+ * Pass the same route string(s) as the handler's generic. A single command reads `this.options`, several
+ * commands branch with `this.match`. The decorator routes and the generic must match exactly, so listing
+ * fewer or more than the handler declares is a compile error. Subcommands use a slash path.
+ *
+ * @param routes - The route string(s) this handler serves, e.g. `'ban'`, `'ban', 'kick'`, or `'demo/setup'`.
+ * @decorator
+ * @example
+ * ```ts
+ * \@SlashRoute('ban')
+ * class BanHandler extends SlashHandler<'ban'> {
+ *     async execute() {
+ *         const target = this.options.getUser('target');
+ *     }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * \@SlashRoute('ban', 'kick')
+ * class ModerationHandler extends SlashHandler<'ban' | 'kick'> {
+ *     async execute() {
+ *         await this.match({ ban: (o) => o.getUser('target'), kick: (o) => o.getUser('member') });
+ *     }
+ * }
+ * ```
+ */
+declare function SlashRoute<const Route extends keyof SlashOptionRegistry>(...routes: Route[]): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables>>(constructor: AssertSlashRoute<Route, TCtor>) => void;
+/**
+ * Routes button interactions to handler classes.
+ *
+ * Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
+ * generic. Passing different definitions to the decorator and the generic is a compile error. Routing
+ * matches the stable prefix, so a wire minted from an older shape still reaches the handler, where
+ * reading this.params throws StaleCustomId and the controller boundary turns it into a reply.
+ *
+ * @param defs - The customId definition(s) this handler decodes, one per route.
+ * @decorator
+ */
+declare function ButtonRoute<const Defs extends readonly AnyCustomId[]>(...defs: Defs): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables> & HasComponentDefs<Defs>>(constructor: AssertHandles<ButtonInteraction, TCtor>) => void;
+/**
+ * Routes modal submissions to handler classes.
+ *
+ * Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
+ * generic. Passing different definitions to the decorator and the generic is a compile error. Routing
+ * matches the stable prefix, so an older-shape wire still reaches the handler and throws StaleCustomId
+ * on read, the same as a button route.
+ *
+ * @param defs - The customId definition(s) this handler decodes, one per route.
+ * @decorator
+ */
+declare function ModalRoute<const Defs extends readonly AnyCustomId[]>(...defs: Defs): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables> & HasComponentDefs<Defs>>(constructor: AssertHandles<ModalSubmitInteraction, TCtor>) => void;
+/** The context-menu command names valid for a kind, read off the matching registry. @internal */
+type NamesFor<Kind extends ApplicationCommandType.User | ApplicationCommandType.Message> = Kind extends ApplicationCommandType.User ? keyof UserContextMenuRegistry : keyof MessageContextMenuRegistry;
+/**
+ * The context-menu kind a handler serves, read off its event's `commandType` discriminant. Direct
+ * inference from the `ContextMenuHandler` generic widens the kind to the whole union because the handler's
+ * conditional members blur it, so this uses the event literal to keep it narrow.
+ *
+ * @internal
+ */
+type ContextMenuKindOf<TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = InstanceType<TCtor> extends ContextMenuHandler<infer Kind, CacheType> ? [Kind] extends [ApplicationCommandType.User | ApplicationCommandType.Message] ? HandlerEventType<TCtor> extends {
+  commandType: infer K;
+} ? Extract<K, ApplicationCommandType.User | ApplicationCommandType.Message> : never : never : never;
+/**
+ * On a kind mismatch between the decorator and the handler generic, resolves to a non-constructor type so
+ * applying the decorator is a TS1238. Cross-checks both directions, mirroring {@link AssertSlashRoute}.
+ *
+ * @internal
+ */
+type AssertContextMenuRoute<Kind extends ApplicationCommandType.User | ApplicationCommandType.Message, TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = [Kind] extends [ContextMenuKindOf<TCtor>] ? [ContextMenuKindOf<TCtor>] extends [Kind] ? TCtor : Constructor<['ContextMenuHandler declares a kind the ContextMenuRoute decorator does not match', ContextMenuKindOf<TCtor>]> : Constructor<['ContextMenuRoute does not match the ContextMenuHandler generic', Kind]>;
+/**
+ * Routes one or more context-menu commands to a {@link ContextMenuHandler}.
+ *
+ * Pass the kind (`ApplicationCommandType.User` or `ApplicationCommandType.Message`) and the command name(s),
+ * each checked against that kind's registry, so a typo is a compile error. The same kind must sit on the
+ * handler's generic, cross-checked both directions. Context menus carry no options, so a multi-name handler
+ * reads `this.target` uniformly with no branch.
+ *
+ * @param kind - The context-menu kind, `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
+ * @param names - The command name(s) this handler serves, keyed off the matching registry.
+ * @decorator
+ * @example
+ * ```ts
+ * \@ContextMenuRoute(ApplicationCommandType.User, 'View Profile')
+ * class ViewProfile extends ContextMenuHandler<ApplicationCommandType.User> {
+ *     async execute() {
+ *         const user = this.target;
+ *     }
+ * }
+ * ```
+ */
+declare function ContextMenuRoute<const Kind extends ApplicationCommandType.User | ApplicationCommandType.Message>(kind: Kind, ...names: NamesFor<Kind>[]): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables>>(constructor: AssertContextMenuRoute<Kind, TCtor>) => void;
+/**
+ * The command route(s) an autocomplete handler serves, read off its `AutocompleteHandler` generic.
+ *
+ * @internal
+ */
+type AutocompleteRouteOf<TCtor extends new (...args: any[]) => BaseHandler<AutocompleteInteraction<CacheType>>> = InstanceType<TCtor> extends AutocompleteHandler<infer Route, CacheType> ? Route : never;
+/**
+ * On a route/generic mismatch, resolves to a non-constructor type so applying the decorator is a TS1238.
+ *
+ * @internal
+ */
+type AssertAutocompleteRoute<Route extends keyof SlashOptionRegistry, TCtor extends new (...args: any[]) => BaseHandler<AutocompleteInteraction<CacheType>>> = [Route] extends [AutocompleteRouteOf<TCtor>] ? [AutocompleteRouteOf<TCtor>] extends [Route] ? TCtor : Constructor<['AutocompleteHandler declares a command the AutocompleteRoute decorator does not list', AutocompleteRouteOf<TCtor>]> : Constructor<['AutocompleteRoute does not match the AutocompleteHandler generic', Route]>;
+/**
+ * Routes one or more commands' autocomplete to an {@link AutocompleteHandler}.
+ *
+ * Pass the same command route string(s) as the handler's generic. One command branches with `this.match`
+ * over its autocompletable fields, several commands share one handler whose arms span every command's
+ * fields. The decorator routes and the generic must match exactly, so listing fewer or more than the
+ * handler declares is a compile error.
+ *
+ * @param routes - The command route string(s) this handler serves, e.g. `'search'` or `'search', 'find'`.
+ * @decorator
+ * @example
+ * ```ts
+ * \@AutocompleteRoute('search')
+ * class SearchAutocomplete extends AutocompleteHandler<'search'> {
+ *     async execute() {
+ *         await this.match({ query: (value, respond) => respond([{ name: value, value }]) });
+ *     }
+ * }
+ * ```
+ */
+declare function AutocompleteRoute<const Route extends keyof SlashOptionRegistry>(...routes: Route[]): <TCtor extends new (...args: any[]) => BaseHandler<AutocompleteInteraction<CacheType>>>(constructor: AssertAutocompleteRoute<Route, TCtor>) => void;
+/** @internal */
+type SelectMenuInteractionFor<SelectMenu extends SelectMenuKind, Cache extends CacheType = CacheType> = SelectMenu extends SelectMenuKind.String ? StringSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.User ? UserSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.Role ? RoleSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.Channel ? ChannelSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.Mentionable ? MentionableSelectMenuInteraction<Cache> : never;
+/**
+ * Routes select menu interactions to handler classes.
+ *
+ * Pass the select kind and the {@link CustomId} definition(s) this handler decodes. The handler's
+ * generic must list the same definitions, and its second generic argument must be the matching select
+ * interaction type, or it is a compile error.
+ *
+ * @param type - Select menu kind from {@link SelectMenuKind}.
+ * @param defs - The customId definition(s) this handler decodes, one per route.
+ * @decorator
+ *
+ * @example
+ * ```typescript
+ * \@SelectMenuRoute(SelectMenuKind.User, AssignId)
+ * class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
+ *   // handles user select menus minted from AssignId
+ * }
+ * ```
+ */
+declare function SelectMenuRoute<SelectMenu extends SelectMenuKind, const Defs extends readonly AnyCustomId[]>(type: SelectMenu, ...defs: Defs): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables> & HasComponentDefs<Defs>>(constructor: AssertHandles<SelectMenuInteractionFor<SelectMenu>, TCtor>) => 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> implements Handler {
+  constructor(event: Repliable, core: Core);
+}
+//#endregion
+//#region src/handlers/interaction/components/ComponentHandler.d.ts
+type ComponentInteraction = ButtonInteraction | ModalSubmitInteraction | AnySelectMenuInteraction;
+type SingleParams<Defs extends readonly AnyCustomId[]> = Defs extends readonly [infer One extends AnyCustomId] ? DecodedParams<One['shape']> : never;
+type MatchArms<Defs extends readonly AnyCustomId[], Ret> = { [Def in Defs[number] as Def['prefix']]: (params: DecodedParams<Def['shape']>) => Promisable<Ret> };
+/**
+ * Shared base the customId-routed component handlers extend.
+ *
+ * Not a public entry point. You should be using {@link ButtonHandler}, {@link SelectMenuHandler}, or
+ * {@link ModalHandler} instead. This class only carries the customId decode and route-matching plumbing
+ * those bases share, so DO NOT use it directly.
+ *
+ * @typeParam Event - The component interaction type this handler processes
+ * @typeParam Defs - The customId route definitions registered on the concrete handler
+ */
+declare abstract class ComponentHandler<Event extends ComponentInteraction, Defs extends readonly AnyCustomId[]> extends InteractionHandler<Event> implements HasComponentDefs<Defs> {
+  /** @internal */
+  readonly __componentDefs?: Defs;
+  private get registeredDefs();
+  private decoded?;
+  private get route();
+  /**
+   * The decoded params of the single route this handler is registered for.
+   *
+   * Reading this decodes `this.event.customId` once (cached after the first read) and throws
+   * `StaleCustomId` or `InvalidCustomId` when the wire no longer matches the current shape, which the
+   * controller boundary turns into a reply. On a handler registered for several routes this is
+   * `never`, so use {@link match} instead.
+   */
+  protected get params(): SingleParams<Defs>;
+  /**
+   * Run the arm for whichever route the component was minted from. Use this only when the handler is
+   * registered for several routes. A single-route handler reads `this.params` directly. On a multi-route
+   * handler `this.params` is `never`, so match is the only way to read the decoded params.
+   *
+   * Provide one arm per registered route, keyed by its prefix, and each arm receives that route's own
+   * decoded params. The arms must cover every registered def, a missing prefix or an unknown key is a
+   * compile error. Decoding runs before any arm, so a stale or corrupt wire throws before an arm body executes.
+   *
+   * @param arms - One handler per registered route, keyed by prefix.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@ButtonRoute(Approve, Reject)
+   * class ReviewButtons extends ButtonHandler<[typeof Approve, typeof Reject]> {
+   *     async execute() {
+   *         await this.match({
+   *             approve: ({ userId }) => this.event.reply(`approved <@${userId}>`),
+   *             reject: ({ userId }) => this.event.reply(`rejected <@${userId}>`)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: MatchArms<Defs, Ret>): Promise<Ret>;
+}
+//#endregion
+//#region src/handlers/interaction/components/ButtonHandler.d.ts
+/**
+ * Base class for a button interaction handler.
+ *
+ * Register the customId definitions this handler decodes with `@ButtonRoute`, list the same ones in the
+ * generic, then read `this.params` for a single route or `this.match` for several. Passing different
+ * definitions to the decorator and the generic is a compile error.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ApproveId]`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
+ *
+ * @example
+ * ```ts
+ * \@ButtonRoute(ApproveId)
+ * class ApproveButton extends ButtonHandler<[typeof ApproveId]> {
+ *     async execute() {
+ *         const { userId } = this.params;
+ *         await this.event.reply(`approved <@${userId}>`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class ButtonHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends ComponentHandler<ButtonInteraction<Cache>, Defs> {}
+//#endregion
+//#region src/handlers/interaction/components/ModalHandler.d.ts
+/**
+ * Base class for a modal submit handler.
+ *
+ * Register the customId definitions this handler decodes with `@ModalRoute`, list the same ones in the
+ * generic, then read `this.params` for a single route or `this.match` for several. Read the submitted
+ * inputs from `this.event.fields`.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
+ *
+ * @example
+ * ```ts
+ * \@ModalRoute(ConfigId)
+ * class ConfigModal extends ModalHandler<[typeof ConfigId]> {
+ *     async execute() {
+ *         const { guildId } = this.params;
+ *         const name = this.event.fields.getTextInputValue('name');
+ *         await this.event.reply(`saved ${name} for ${guildId}`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class ModalHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends ComponentHandler<ModalSubmitInteraction<Cache>, Defs> {}
+//#endregion
+//#region src/handlers/interaction/components/SelectMenuHandler.d.ts
+/**
+ * Base class for a select menu handler.
+ *
+ * Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`,
+ * so `this.event` and `this.event.values` are narrowed to that kind. Read `this.params` for a single
+ * route or `this.match` for several.
+ *
+ * @typeParam Kind - The select kind from {@link SelectMenuKind}, e.g. `SelectMenuKind.User`.
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
+ *
+ * @example
+ * ```ts
+ * \@SelectMenuRoute(SelectMenuKind.User, AssignId)
+ * class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
+ *     async execute() {
+ *         const { roleId } = this.params;
+ *         await this.event.reply(`assigning ${this.event.values.length} member(s) to <@&${roleId}>`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class SelectMenuHandler<Kind extends SelectMenuKind, Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends ComponentHandler<SelectMenuInteractionFor<Kind, Cache>, Defs> {}
+//#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/notices/utils.d.ts
+/** Whose permissions a check ran against, used to mention and label the subject in a refusal. */
+type PermSubject = Role | TextChannel | Guild | GuildMember;
+//#endregion
+//#region src/bot/utilities/permissions/checkPermissions.d.ts
+/**
+ * Array of permission bits for permission validation.
+ * Import any of the predefined sets or pass a custom bigint[].
+ */
+type BotPermissionScope = readonly bigint[];
+/**
+ * Optional custom error constructors for {@link CheckPermissionOptions}.
+ */
+interface PermissionErrorCtors {
+  missing?: new (message: string, where: PermSubject, missingPerms: string[]) => Notice;
+  dangerous?: new (message: string, target: PermSubject, dangerousPerms: string[]) => Notice;
+}
+/**
+ * Options for {@link checkPermissions}.
+ *
+ * @see {@link PermissionErrorCtors}
+ */
+interface CheckPermissionOptions extends PermissionErrorCtors {
+  /** Role or member whose permissions will be checked */
+  for: Role | GuildMember;
+  /** Context where permissions apply, guild or channel */
+  in: Guild | TextChannel;
+  /** Permission bits to validate */
+  scope: BotPermissionScope;
+  /** When true, ensure target does not have the given permissions */
+  inverse?: boolean;
+}
+/**
+ * Checks permissions for a {@link Role} or a {@link GuildMember} in a {@link Guild}. Refuses when a
+ * permission in `scope` is missing, or with `inverse` when one is present.
+ *
+ * @param target - Role or member to check
+ * @param ctx - Guild context
+ * @param scope - Permission bits to validate
+ * @param inverse - Whether to ensure absence of the given permissions
+ * @param errors - Optional custom error constructors
+ *
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkPermissions } from '@seedcord/gateway';
+ *
+ * // Check if a role has ManageMessages and KickMembers permissions in a guild
+ * checkPermissions(role, guild, [
+ *   PermissionFlagsBits.ManageMessages,
+ *   PermissionFlagsBits.KickMembers
+ * ]);
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkPermissions } from '@seedcord/gateway';
+ *
+ * // Ensure a member does NOT have Administrator permission in a guild and show custom errors
+ * checkPermissions(member, guild, [
+ *   PermissionFlagsBits.Administrator
+ * ], true, {
+ *   missing: CustomMissingPermissionsError,
+ *   dangerous: CustomDangerousPermissionsError
+ * });
+ * ```
+ */
+declare function checkPermissions(target: Role | GuildMember, ctx: Guild, scope: BotPermissionScope, inverse?: boolean, errors?: PermissionErrorCtors): void;
+/**
+ * Checks permissions for a {@link Role} or a {@link GuildMember} in a {@link TextChannel}. Refuses when a
+ * permission in `scope` is missing, or with `inverse` when one is present.
+ *
+ * @param target - Role or member to check
+ * @param ctx - Channel context
+ * @param scope - Permission bits to validate
+ * @param inverse - Whether to ensure absence of the given permissions
+ * @param errors - Optional custom error constructors
+ *
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkPermissions } from '@seedcord/gateway';
+ *
+ * // Check if a role has SendMessages and ViewChannel permissions in a text channel
+ * checkPermissions(role, textChannel, [
+ *   PermissionFlagsBits.SendMessages,
+ *   PermissionFlagsBits.ViewChannel
+ * ]);
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkPermissions } from '@seedcord/gateway';
+ *
+ * // Ensure a member does NOT have ManageChannels permission in a text channel and show custom errors
+ * checkPermissions(member, textChannel, [
+ *   PermissionFlagsBits.ManageChannels
+ * ], true, {
+ *   missing: CustomMissingPermissionsError,
+ *   dangerous: CustomDangerousPermissionsError
+ * });
+ * ```
+ */
+declare function checkPermissions(target: Role | GuildMember, ctx: TextChannel, scope: BotPermissionScope, inverse?: boolean, errors?: PermissionErrorCtors): void;
+/**
+ * Checks permissions using an options object. Refuses when a permission in {@link CheckPermissionOptions.scope} is missing,
+ * or with `options.inverse` when one is present.
+ *
+ * @param options - Complete options for the check
+ *
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkPermissions } from '@seedcord/gateway';
+ *
+ * // Check permissions using an options object
+ * checkPermissions({
+ *   for: member,
+ *   in: textChannel,
+ *   scope: [
+ *     PermissionFlagsBits.SendMessages,
+ *     PermissionFlagsBits.ViewChannel
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkPermissions } from '@seedcord/gateway';
+ *
+ * // Ensure a role does NOT have BanMembers permission in a guild using an options object
+ * checkPermissions({
+ *   for: role,
+ *   in: guild,
+ *   scope: [
+ *     PermissionFlagsBits.BanMembers
+ *   ],
+ *   inverse: true,
+ *   missing: CustomMissingPermissionsError,
+ *   dangerous: CustomDangerousPermissionsError
+ * });
+ * ```
+ */
+declare function checkPermissions(options: CheckPermissionOptions): void;
+//#endregion
+//#region src/bot/gates/catalog/permissions.d.ts
+/**
+ * Options for {@link RequirePermissions} and {@link RequireBotPermissions}, one override per refusal the gate
+ * can show.
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import type { Guild, GuildMember, Role, TextChannel } from 'discord.js';
+ *
+ * // `missing` is a Notice ctor: (message, where, missingPerms)
+ * class MissingPermsNotice extends Notice {
+ *     public constructor(message: string, where: Role | TextChannel | Guild | GuildMember, missing: string[]) {
+ *         super(`${message} (${missing.join(', ')})`);
+ *     }
+ * }
+ *
+ * RequirePermissions([PermissionFlagsBits.BanMembers], { missing: MissingPermsNotice });
+ * ```
+ */
+interface RequirePermissionsOptions {
+  /** Reword or replace the refusal shown outside a guild. */
+  notInGuild?: GateNoticeOptions;
+  /** Replace the missing-permissions refusal with a ctor that receives the where and the missing perm names. */
+  missing?: PermissionErrorCtors['missing'];
+}
+/**
+ * Options for {@link RequireRole}, one override per refusal the gate can show.
+ */
+interface RequireRoleOptions {
+  /** Reword or replace the refusal shown outside a guild. */
+  notInGuild?: GateNoticeOptions;
+  /** Reword or replace the refusal shown when the caller lacks the role. */
+  missingRole?: GateNoticeOptions;
+}
+/**
+ * Requires the caller to hold every permission in `scope`, via `checkPermissions`. Refuses outside a guild.
+ *
+ * Interaction-only and excludes ModalSubmit, since a modal lacks a reliable cached caller member.
+ *
+ * @param scope - The permission flag bits the caller must all hold.
+ * @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-permissions one with `missing`.
+ *
+ * @see {@link Gated}
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ *
+ * \@Gated(RequirePermissions([PermissionFlagsBits.BanMembers]))
+ * \@SlashRoute('ban')
+ * class BanHandler extends SlashHandler<'ban'> {
+ *     async execute() {
+ *         const target = this.options.getUser('target');
+ *     }
+ * }
+ * ```
+ */
+declare function RequirePermissions(scope: BotPermissionScope, options?: RequirePermissionsOptions): Gate<InteractionGateContext<NonModalInteraction>, 'RequirePermissions'>;
+/**
+ * Requires the bot to hold every permission in `scope`, via `checkPermissions`. Refuses outside a guild.
+ *
+ * It reads the bot's own member, so it attaches to modal handlers as well.
+ *
+ * @param scope - The permission flag bits the bot must all hold.
+ * @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-permissions one with `missing`.
+ *
+ * @see {@link Gated}
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ *
+ * \@Gated(RequireBotPermissions([PermissionFlagsBits.BanMembers]))
+ * \@ModalRoute(MyModalId)
+ * class MyModalHandler extends ModalHandler<[typeof MyModalId]> {
+ *     async execute() {
+ *         // ...
+ *     }
+ * }
+ * ```
+ */
+declare function RequireBotPermissions(scope: BotPermissionScope, options?: RequirePermissionsOptions): Gate<InteractionGateContext, 'RequireBotPermissions'>;
+/**
+ * Requires the caller to have `roleId`, read from the member's role cache. Refuses outside a guild first, then
+ * when the role is missing.
+ *
+ * Interaction-only and excludes ModalSubmit.
+ *
+ * @param roleId - The role snowflake the caller must hold, read from the member's role cache.
+ * @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-role one with `missingRole`.
+ *
+ * @see {@link Gated}
+ *
+ * @example
+ * ```ts
+ * \@Gated(RequireRole('123456789012345678'))
+ * \@SlashRoute('vip')
+ * class VipHandler extends SlashHandler<'vip'> {
+ *     async execute() {
+ *         // ...
+ *     }
+ * }
+ * ```
+ */
+declare function RequireRole(roleId: string, options?: RequireRoleOptions): Gate<InteractionGateContext<NonModalInteraction>, 'RequireRole'>;
+//#endregion
+//#region src/bot/utilities/channels/fetchText.d.ts
+/**
+ * Fetches and validates a text channel. Refuses when the channel doesn't exist or isn't a text channel.
+ *
+ * @param client - The Discord client instance
+ * @param channelId - Channel ID or TextChannel instance
+ * @returns Promise resolving to the text channel
+ */
+declare function fetchText(client: Client, channelId: TextChannelResolvable): Promise<TextChannel>;
+//#endregion
+//#region src/bot/utilities/permissions/checkBotPermissions.d.ts
+/**
+ * Checks if the bot has required permissions in a {@link Guild} or {@link TextChannel}. Refuses when a
+ * required permission is missing.
+ *
+ * @param target - Guild or text channel to check in
+ * @param scope - Permission bits to validate
+ * @param inverse - Whether to check for absence of the given permissions
+ * @param errors - Optional custom error constructors
+ *
+ * @example
+ * ```ts
+ * import { PermissionFlagsBits } from 'discord.js';
+ * import { checkBotPermissions } from '@seedcord/gateway';
+ *
+ * // Check if the bot has SendMessages and ViewChannel permissions in a text channel
+ * checkBotPermissions(textChannel, [
+ *   PermissionFlagsBits.SendMessages,
+ *   PermissionFlagsBits.ViewChannel
+ * ]);
+ * ```
+ */
+declare function checkBotPermissions(target: Guild | TextChannel, scope: BotPermissionScope, inverse?: boolean, errors?: PermissionErrorCtors): void;
+//#endregion
+//#region src/bot/utilities/permissions/hasPermsToAssign.d.ts
+/**
+ * Optional custom error constructors for {@link HasPermsToAssignOptions}.
+ */
+interface AssignRoleErrorCtors {
+  /** Custom error for role higher than bot */
+  higher?: new (message: string, role: Role, botRole: Role) => Notice;
+  /** Custom error for managed role assignment */
+  managed?: new (message: string) => Notice;
+  /** Custom error for missing Manage Roles permission */
+  missing?: new (message: string, where: Role | TextChannel | Guild | GuildMember, missingPerms: string[]) => Notice;
+}
+/**
+ * Options for {@link hasPermsToAssign}.
+ */
+interface HasPermsToAssignOptions {
+  /** Target role to validate for assignment */
+  targetRole: Role;
+  /** Optional custom error constructors */
+  errors?: AssignRoleErrorCtors;
+}
+/**
+ * Validates if 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
+ *
+ * @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,
+ *   errors: {
+ *     higher: CustomHigherError,
+ *     managed: CustomManagedError,
+ *     missing: CustomMissingPermissionsError
+ *   }
+ * });
+ * ```
+ */
+declare function hasPermsToAssign(roleOrOptions: Role | HasPermsToAssignOptions): void;
+//#endregion
+//#region src/bot/utilities/roles/fetchRole.d.ts
+/**
+ * Fetches a role by ID from a client or guild. Refuses when the role doesn't exist.
+ *
+ * @param clientOrGuild - Discord client or guild instance
+ * @param roleId - The role ID to fetch
+ * @returns Promise resolving to the role
+ */
+declare function fetchRole(clientOrGuild: Client | Guild, roleId: string): Promise<Role>;
+//#endregion
+//#region src/bot/utilities/roles/getBotRole.d.ts
+/**
+ * Gets the bot's managed role in a guild.
+ *
+ * @param guild - The guild to get the bot role from
+ * @returns The bot's managed role in the guild
+ * @throws A **SeedcordError** if the client user is unavailable or if the bot role is missing
+ */
+declare function getBotRole(guild: Guild): Role;
+//#endregion
+//#region src/bot/utilities/users/fetchGuildMember.d.ts
+/**
+ * Fetches a guild member by user ID. Refuses when the user is not in the guild.
+ *
+ * @param guild - The guild to fetch the member from
+ * @param userId - The Discord user ID
+ * @returns Promise resolving to the guild member
+ */
+declare function fetchGuildMember(guild: Guild, userId: string): Promise<GuildMember>;
+//#endregion
+//#region src/bot/utilities/users/fetchManyGuildMembers.d.ts
+/**
+ * Fetches multiple guild members by user IDs.
+ *
+ * @param guild - The guild to fetch members from
+ * @param userIds - Array of Discord user IDs
+ * @returns Promise resolving to array of successfully fetched members
+ */
+declare function fetchManyGuildMembers(guild: Guild, userIds: string[]): Promise<GuildMember[]>;
+//#endregion
+//#region src/bot/utilities/users/fetchUser.d.ts
+/**
+ * Options for {@link fetchUser}.
+ */
+interface FetchUserOptions {
+  /** Notice shown when the user does not exist, defaulting to the standard user-not-found notice. */
+  throwAs?: new (userArg: string) => Notice;
+}
+/**
+ * Fetches a Discord user by ID. Refuses when the user doesn't exist, with `options.throwAs` or the default.
+ *
+ * @param client - The Discord client instance
+ * @param userId - The Discord user ID
+ * @param options - Optional overrides, including the {@link FetchUserOptions.throwAs} notice
+ * @returns Promise resolving to the user
+ */
+declare function fetchUser(client: Client, userId: string, options?: FetchUserOptions): Promise<User>;
+//#endregion
+//#region src/bot/utilities/users/fetchManyUsers.d.ts
+/**
+ * Fetches multiple Discord users by IDs.
+ *
+ * @param client - The Discord client instance
+ * @param userIds - Array of Discord user IDs
+ * @param options - Optional overrides threaded to each {@link fetchUser} call
+ * @returns Promise resolving to array of successfully fetched users
+ */
+declare function fetchManyUsers(client: Client, userIds: string[], options?: FetchUserOptions): Promise<User[]>;
+//#endregion
+//#region src/bot/utilities/users/updateMemberRoles.d.ts
+/**
+ * Updates a guild member's roles by adding and removing specified roles.
+ *
+ * @param rolesToAdd - Array of role IDs to add to the member
+ * @param rolesToRemove - Array of role IDs to remove from the member
+ * @param member - The guild member to update
+ * @returns Promise that resolves when roles are updated
+ */
+declare function updateMemberRoles(rolesToAdd: Snowflake[], rolesToRemove: Snowflake[], member: GuildMember): Promise<void>;
+//#endregion
+//#region src/bot/ReplySender.d.ts
+/**
+ * Sends a {@link ReplyResponse} to an interaction, picking reply, editReply, or followUp from the live
+ * acknowledgement state. Logs and drops its own send failures so a dead token never escapes into the
+ * controller.
+ */
+declare class ReplySender {
+  private readonly interaction;
+  private readonly logger;
+  constructor(interaction: Repliables);
+  /**
+   * Sends the reply and returns the sent message so a caller can attach a collector to it. Never throws,
+   * a failed send is logged and dropped and resolves to `undefined`.
+   *
+   * @param response - The ComponentsV2 reply to show.
+   * @param ephemeral - Whether the reply is ephemeral. {@default `true`}
+   * @returns The sent {@link Message}, or `undefined` when the send was swallowed.
+   */
+  send(response: ReplyResponse, ephemeral?: boolean): Promise<Message | undefined>;
+  /**
+   * Edits an already-sent message to a new {@link ReplyResponse}. Used to swap a confirmation prompt for
+   * its outcome. Never throws, a failed edit is logged and dropped.
+   *
+   * @param message - The message to edit (the handle a prior {@link send} returned).
+   * @param response - The reply to replace it with.
+   */
+  edit(message: Message, response: ReplyResponse): Promise<void>;
+  private dispatch;
+  private replyOptions;
+  private editBody;
+  private logSwallowed;
+}
+//#endregion
+//#region src/bot/confirm/getConfirmation.d.ts
+/** A confirm outcome to show, the reply itself or a factory for it. */
+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. Never throws, a swallowed send resolves to `false`. Not usable from a
+ * {@link ModalHandler}, the `interaction` parameter excludes a modal submit at compile time.
+ *
+ * @param interaction - The repliable interaction to prompt on, `this.event` 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', true);
+ *         if (!(await getConfirmation(this.event, `Ban ${target.tag}? This cannot be undone.`))) return;
+ *         await this.event.guild?.members.ban(target.id);
+ *     }
+ * }
+ * ```
+ */
+declare function getConfirmation(interaction: 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`. Never throws. Not usable from a {@link ModalHandler}.
+ *
+ * @param interaction - The repliable interaction to prompt on, `this.event` 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 kit `BuilderComponent`/`RowComponent` wrappers, not raw discord.js builders.
+ * @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, deliver
+ * a result after confirming with a fresh `interaction.followUp(...)`, the prompt is already gone.
+ *
+ * @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', true);
+ * const confirmed = await getConfirmation(
+ *     this.event,
+ *     (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(interaction: NonModalInteraction, prompt: (ids: {
+  confirm: string;
+  cancel: string;
+}) => Promisable<ReplyResponse>, options?: ConfirmOptions): Promise<boolean>;
+//#endregion
+//#region src/pagination/PageContext.d.ts
+/**
+ * The context passed to a source loader. In a DM `guild` is `null` and `user` is still present.
+ */
+interface PageContext {
+  /** The interaction that triggered this load (a command or a nav click). */
+  interaction: Repliables;
+  /** The acting user, always present. */
+  user: User;
+  /** The guild, or `null` in a DM. */
+  guild: Guild | null;
+  /** The framework core, passed only when a source requires framework services. */
+  core?: Core;
+}
+//#endregion
+//#region src/pagination/controls.d.ts
+/** The five built-in nav controls. */
+type ControlKey = 'first' | 'prev' | 'indicator' | 'next' | 'last';
+type CustomIdStyle = ButtonStyle.Primary | ButtonStyle.Secondary | ButtonStyle.Success | ButtonStyle.Danger;
+/** Cosmetic overrides for a control button. `style` excludes Link and Premium, which would un-route it. */
+interface ControlCosmetics {
+  label?: string;
+  style?: CustomIdStyle;
+  emoji?: APIMessageComponentEmoji;
+}
+/** The controls passed to `render`. Each accessor returns a fresh builder stamped with its target page. */
+interface PaginatorControls {
+  /**
+   * A fresh `ButtonBuilder` for one control, already stamped with its target page and disabled-at-bounds
+   * state. Call only cosmetic setters on it, a `setCustomId` or `setStyle(Link)` un-routes it.
+   */
+  button(key: ControlKey, cosmetics?: ControlCosmetics): ButtonBuilder;
+  /**
+   * Assemble an action row of the chosen controls, in order. Throws on an empty set, more than five
+   * controls, or a duplicate.
+   */
+  row(...keys: ControlKey[]): ActionRowBuilder<ButtonBuilder>;
+}
+//#endregion
+//#region src/pagination/render.d.ts
+/** What `renderItem` returns for one item, a text line or a section. */
+type ItemRender<Item> = (item: Item, index: number) => string | BuilderComponent<'section'>;
+/** What the V2 reply can be built from. Each arm is normalized into a {@link ReplyResponse}. */
+type Renderable = string | V2Component[] | ReplyResponse;
+/** A full-page render override, handed the page data and the controls factory. */
+type PageRender<Item> = (view: PageView<Item>, controls: PaginatorControls) => Renderable;
+//#endregion
+//#region src/pagination/sources.d.ts
+/**
+ * The one method a paginator calls on a source, once per click. Implement it to supply a custom source.
+ *
+ * @typeParam Item - The item type the source pages over.
+ */
+interface PageSource<Item> {
+  page(ctx: PageContext, n: number): Promise<PageView<Item>>;
+}
+/**
+ * A source for a bounded list you can load whole. It loads the full list on every click, then slices the
+ * page via {@link paginate}, so the real total is known (a real last button, "Page X of Y"). Cache inside
+ * your loader if the load is expensive.
+ *
+ * @typeParam Item - The item type, inferred from the loader's return.
+ */
+declare class ArraySource<Item> implements PageSource<Item> {
+  private readonly load;
+  private readonly perPage;
+  constructor(load: (ctx: PageContext) => Promisable<readonly Item[]>, opts?: {
+    perPage?: number;
+  });
+  page(ctx: PageContext, n: number): Promise<PageView<Item>>;
+}
+/**
+ * A source for a large or unknown-length set you fetch one page at a time (SQL LIMIT/OFFSET, a paged API).
+ * The fetcher receives the page index and the page size and reports whether a next page exists. A cursor
+ * source has no cheap total, so `totalPages` is undefined, the last button is omitted, and the indicator
+ * reads "Page X".
+ *
+ * @typeParam Item - The item type, inferred from the fetcher's slice.
+ */
+declare class CursorSource<Item> implements PageSource<Item> {
+  private readonly fetch;
+  private readonly perPage;
+  constructor(fetch: (ctx: PageContext, page: number, perPage: number) => Promisable<{
+    items: readonly Item[];
+    hasNext: boolean;
+  }>, opts?: {
+    perPage?: number;
+  });
+  page(ctx: PageContext, n: number): Promise<PageView<Item>>;
+}
+//#endregion
+//#region src/pagination/Paginator.d.ts
+interface PaginatorConfig<Item, Prefix extends string> {
+  /** The route prefix used to build the page cursor on the nav buttons. */
+  prefix: Prefix;
+  /** Where the page data comes from. */
+  source: PageSource<Item>;
+  /** Render one item, `index` is its absolute position across pages. Ignored when `render` is set. */
+  renderItem?: ItemRender<Item>;
+  /** Take over the whole page tree. Receives the page data and the controls factory. */
+  render?: PageRender<Item>;
+  /** Whether the first page is ephemeral. {@default false} */
+  ephemeral?: boolean;
+}
+type PaginatorHandlerCtor<Prefix extends string> = new (event: ButtonInteraction<'cached'>, core: Core) => ButtonHandler<[PageCursor<Prefix>]> & {
+  execute(): Promise<void>;
+};
+/**
+ * A restart-proof paginator. Each nav button's customId encodes its full target page, so clicks are
+ * idempotent and survive a restart. A persistent `@ButtonRoute` on `Handler` dispatches the clicks.
+ *
+ * @typeParam Item - The item type, inferred from the source.
+ * @typeParam Prefix - The route prefix, inferred from `config.prefix`.
+ *
+ * @example
+ * ```ts
+ * export const Bans = new Paginator({
+ *     prefix: 'bans',
+ *     source: new ArraySource((ctx) => ctx.guild.bans.fetch().then((b) => [...b.values()]), { perPage: 10 }),
+ *     renderItem: (ban) => ban.user.tag
+ * });
+ *
+ * \@ButtonRoute(Bans.cursor)
+ * export class BansNav extends Bans.Handler {}
+ * ```
+ */
+declare class Paginator<Item, const Prefix extends string> {
+  /** The page cursor, pass it to your `@ButtonRoute`. */
+  readonly cursor: PageCursor<Prefix>;
+  /** The nav handler base. Extend it with an empty body and decorate it, `@ButtonRoute(p.cursor)`. */
+  readonly Handler: PaginatorHandlerCtor<Prefix>;
+  private readonly config;
+  constructor(config: PaginatorConfig<Item, Prefix>);
+  /** Render page 0 and send it, picking reply or followUp from the interaction's state. */
+  start(interaction: Repliables, core?: Core): Promise<Message | undefined>;
+  /** Render a page as a {@link ReplyResponse}. To post it elsewhere, add `flags: MessageFlags.IsComponentsV2`. */
+  page(ctx: PageContext, n: number): Promise<ReplyResponse>;
+}
+//#endregion
+//#region src/subscribers/Subscriber.d.ts
+/**
+ * Abstract base class for handling application subscribers.
+ *
+ * Provides type-safe access to subscribers data and the core framework instance.
+ * Extend this class to create custom subscriber handlers.
+ *
+ * @typeParam KeyOfSubscribers - The specific subscriber type this handler processes
+ */
+declare abstract class Subscriber<KeyOfSubscribers extends SubscriptionKey> {
+  protected readonly data: AllSubscriptions[KeyOfSubscribers];
+  protected readonly core: Core;
+  protected readonly logger: Logger;
+  /**
+   * Instantiates the subscriber with event data and core.
+   *
+   * @param data - The subscriber event data
+   * @param core - The core framework instance
+   */
+  constructor(data: AllSubscriptions[KeyOfSubscribers], core: Core);
+  /**
+   * Executes the subscriber handler logic.
+   */
+  abstract execute(): Promise<void>;
+}
+//#endregion
+//#region src/subscribers/decorators/Subscribe.d.ts
+/**
+ * Options accepted by the `@Subscribe` decorator.
+ */
+interface SubscribeOptions {
+  /**
+   * Frequency: `'once'` or `'on'`.
+   *
+   * @defaultValue `'on'`
+   */
+  readonly frequency?: EventFrequency | undefined;
+}
+/**
+ * Registers a subscriber handler class with a specific subscriber event.
+ *
+ * Associates the decorated class with a subscriber event type for automatic
+ * registration and execution when the subscriber is emitted.
+ *
+ * @typeParam TSubscriber - The subscriber event name to register for
+ * @param subscriber - The subscriber event name to register for
+ * @param options - Options to configure the subscriber handler registration.
+ * @decorator
+ * @example
+ * ```typescript
+ * \@Subscribe('userJoin')
+ * class WelcomeHandler extends Subscriber<'userJoin'> {
+ *   async execute() {
+ *     // Handle user join event
+ *   }
+ * }
+ * ```
+ * @example
+ * ```ts
+ * \@Subscribe('userJoin', { frequency: 'once' })
+ * // or
+ * \@Subscribe('userJoin')
+ * ```
+ */
+declare function Subscribe<TSubscriber extends SubscriptionKey>(subscriber: TSubscriber, options?: SubscribeOptions): <HandlerCtor extends Constructor<Subscriber<TSubscriber>>>(constructor: HandlerCtor) => void;
+//#endregion
+//#region src/subscribers/bases/WebhookLog.d.ts
+/**
+ * Abstract webhook logging handler for subscriber events.
+ *
+ * Extends Subscriber to provide webhook-based logging capabilities.
+ * Implementations must define the webhook client to send messages to by implementing the webhook property.
+ *
+ * @typeParam KeyOfSubscribers - The specific subscriber type this handler processes
+ */
+declare abstract class WebhookLog<KeyOfSubscribers extends SubscriptionKey> extends Subscriber<KeyOfSubscribers> {
+  /** The Discord webhook client for sending log messages */
+  abstract webhook: WebhookClient;
+  constructor(data: AllSubscriptions[KeyOfSubscribers], core: Core);
+}
+//#endregion
+//#region src/hmr/HmrModuleHandler.d.ts
+/**
+ * Options for configuring the HmrModuleHandler.
+ *
+ * This is only useful during development.
+ */
+interface HmrModuleHandlerOptions<THandler, TMiddleware = void, TArtifacts = unknown> {
+  /** Directory containing handler modules. */
+  handlersDir: string;
+  /** Directory containing middleware modules. Optional because not all setups use middleware. */
+  middlewaresDir?: string;
+  /** Function to determine if a value is a handler module of type THandler. */
+  isHandler: (val: unknown) => val is THandler;
+  /** Function to determine if a value is a middleware module of type TMiddleware. Optional because not all setups use middleware. */
+  isMiddleware?: (val: unknown) => val is TMiddleware;
+  /** Function to register a handler module. */
+  registerHandler: (handler: THandler, file: string) => void;
+  /** Function to register a middleware module. Optional because not all setups use middleware. */
+  registerMiddleware?: (middleware: TMiddleware, file: string) => void;
+  /** Function to unregister a handler module. */
+  unregisterHandler: (handler: THandler, artifacts?: TArtifacts) => void;
+  /** Function to unregister a middleware module. Optional because not all setups use middleware. */
+  unregisterMiddleware?: (middleware: TMiddleware) => void;
+  /** Function to extract artifacts from a handler to be stored across hmr cache invalidations. */
+  getArtifacts?: (handler: THandler) => TArtifacts;
+  /** Logger instance for logging HMR activities.*/
+  logger: Logger;
+}
+/**
+ * Reloads THandler and optional TMiddleware modules on HMR updates.
+ *
+ * You can either implement a custom `onHmr()` method in your class by extending `HmrAware`, or if it's a plugin, override the existing `onHmr()` with fully custom logic. Or, use this class's `handle()` method inside your `onHmr()` to get standard HMR handling for your modules based on the provided options you give to the constructor.
+ *
+ * This is only useful during development.
+ */
+declare class HmrModuleHandler<THandler, TMiddleware = void, TArtifacts = unknown> {
+  private readonly store;
+  private readonly options;
+  constructor(options: HmrModuleHandlerOptions<THandler, TMiddleware, TArtifacts>);
+  /**
+   * Handles an HMR update event by reloading affected modules based on the event details and config. It receives an {@link HmrUpdateEvent}, then checks the type of update.
+   *
+   * - If it's a deletion, it unloads the module.
+   * - If it's an update/creation, it checks if the file is tracked, unloads it if so, then reloads the file if it is in the handlers or middlewares directory and is a valid handler/middleware.
+   */
+  handle(event: HmrUpdateEvent): Promise<void>;
+  private reloadWithRollback;
+  /**
+   * Tracks a handler module as being loaded from a specific file.
+   * @param file - The file path the handler was loaded from.
+   * @param handler - The handler module instance.
+   */
+  trackHandler(file: string, handler: THandler): void;
+  /**
+   * Tracks a middleware module as being loaded from a specific file.
+   * @param file - The file path the middleware was loaded from.
+   * @param middleware - The middleware module instance.
+   */
+  trackMiddleware(file: string, middleware: TMiddleware): void;
+  private isTracked;
+  private unload;
+  private reloadFile;
+  private snapshotUnits;
+  private restoreUnits;
+}
+//#endregion
+//#region src/Seedcord.d.ts
+/**
+ * Main Seedcord bot framework class
+ *
+ * Primary entry point for creating Discord bots with Seedcord.
+ * Manages component lifecycle and provides plugin support.
+ */
+declare class Seedcord extends Pluggable implements Core {
+  readonly config: GatewayConfig;
+  /** @internal */
+  readonly [SeedcordBrand] = true;
+  /** @internal */
+  readonly augmentTarget = "@seedcord/gateway";
+  /** @internal */
+  readonly version: string;
+  private static isInstantiated;
+  /** @see {@link CoordinatedShutdown} */
+  readonly shutdown: CoordinatedShutdown;
+  /** @see {@link CoordinatedStartup} */
+  readonly startup: CoordinatedStartup;
+  /** @see {@link Bus} */
+  readonly bus: Bus;
+  /** @see {@link Bot} */
+  readonly bot: Bot;
+  /** @see {@link IRateLimiter} */
+  readonly rateLimiter: IRateLimiter;
+  /** @see {@link HealthCheck} */
+  private readonly healthCheck;
+  /** @see {@link HmrManager} */
+  private readonly hmrManager;
+  /**
+   * Creates a new Seedcord instance
+   *
+   * @param config - Bot configuration including paths and Discord client options
+   * @throws A **SeedcordError** When attempting to create multiple instances (singleton)
+   */
+  constructor(config: GatewayConfig);
+  /** @internal */
+  private static reset;
+  /**
+   * Registers default startup tasks
+   * @internal
+   */
+  private registerStartupTasks;
+  /**
+   * Starts the bot and runs all initialization tasks
+   *
+   * @returns This Seedcord instance when fully initialized
+   */
+  start(): Promise<this>;
+  private registerHmrAwareModules;
+}
+//#endregion
+//#region src/version.d.ts
 /** Package version */
 declare const version: string;
 //#endregion
-export { version };
+export { type AllSubscriptions, ArraySource, AssignRoleErrorCtors, AutocompleteHandler, type AutocompleteOptions, AutocompleteRoute, type BotEvents, type BotPermissionScope, ButtonHandler, ButtonRoute, type CheckPermissionOptions, CommandMentions, type ConfirmOptions, ContextMenuHandler, ContextMenuRoute, type Core, CursorSource, type DefaultConfirmOptions, Emojis, type EventGateContext, EventHandler, EventMiddleware, type EventSpec, type EventsConfig, type FaultSource, FetchUserOptions, type GateContext, Gated, type GatewayBotConfig, type GatewayConfig, HasPermsToAssignOptions, HmrModuleHandler, IgnoreBots, type Initializeable, type InjectedEmojiMap, type InjectedMentionMap, type InteractionGateContext, InteractionHandler, InteractionMiddleware, Middleware, type MiddlewareOptions, MiddlewareType, ModalHandler, ModalRoute, Nsfw, Paginator, type PaginatorControls, type PermissionErrorCtors, Pluggable, Plugin, type PluginArgs, type PluginCtor, RegisterCommand, RegisterEvent, type RegisterEventOptions, type Repliables, ReplySender, RequireBotPermissions, RequirePermissions, type RequirePermissionsOptions, RequireRole, type RequireRoleOptions, Seedcord, SelectMenuHandler, SelectMenuKind, SelectMenuRoute, SlashHandler, type SlashOptions, SlashRoute, Subscribe, type SubscribeOptions, Subscriber, type SubscriptionData, type SubscriptionKey, type Subscriptions, type ValidEventTypes, type ValidInteractionTypes, type ValidNonInteractionKeys, WebhookLog, checkBotPermissions, checkPermissions, fetchGuildMember, fetchManyGuildMembers, fetchManyUsers, fetchRole, fetchText, fetchUser, getBotRole, getConfirmation, hasPermsToAssign, updateMemberRoles, version };
 //# sourceMappingURL=index.d.mts.map