@seedcord/http 0.10.2 → 0.11.0-next.0

package/dist/shared-vsj1uwIH.d.mts

@@ -0,0 +1,977 @@
+import "reflect-metadata";
+import { AutocompletableNames, AutocompleteRouteBrand, ChoiceValueOf, ComponentDefsBrand, ComponentKindBrand, ContextMenuKindBrand, ContextMenuNamesBrand, EntryFor, FixedScope, FocusedField, GateFitsWith, HasComponentDefs, MatchArms, MiddlewareKindsBrand, MiddlewareRegistry, NamesFor, PageCursor, SingleParams, SlashOptions, SlashRouteBrand } from "@seedcord/core/internal";
+import { Plugin, PluginLifecycleSpec, PluginOptions, PluginOptions as PluginOptions$1 } from "@seedcord/core/plugin";
+import { APIApplicationCommandAutocompleteInteraction, APIApplicationCommandOptionChoice, APIAttachment, APIChatInputApplicationCommandInteraction, APIContextMenuInteraction, APIInteraction, APIInteractionDataResolvedChannel, APIInteractionDataResolvedChannelBase, APIInteractionDataResolvedGuildMember, APIInteractionGuildMember, APIMessage, APIMessageApplicationCommandInteraction, APIMessageChannelSelectInteractionData, APIMessageComponentButtonInteraction, APIMessageComponentInteraction, APIMessageComponentSelectMenuInteraction, APIMessageMentionableSelectInteractionData, APIMessageRoleSelectInteractionData, APIMessageStringSelectInteractionData, APIMessageUserSelectInteractionData, APIModalInteractionResponseCallbackData, APIModalSubmission, APIModalSubmitInteraction, APIRole, APIThreadChannel, APIUser, APIUserApplicationCommandInteraction, ApplicationCommandType, ChannelType, ModalSubmitComponent, ThreadChannelType } from "discord-api-types/v10";
+import { Collection } from "@discordjs/collection";
+import { ArraySourceBase, AutocompleteOptions, BaseHandler, BaseReplySender, Bus, CoreBase, CursorSourceBase, DispatchContext, DispatchResult, Gate, GateContextBase, GuildPermissionsContext, InteractionKind, MiddlewareKind, ModalLike, PageSourceBase, PaginatorBase, PaginatorConfig, RepliableHandler, RequiredOf, ResolvedEmoji, SlashRegistry, Subscriber, SubscriptionKey, WebhookLog } from "@seedcord/core";
+import { HmrModuleHandler as HmrModuleHandler$1 } from "@seedcord/core/hmr";
+import { API } from "@discordjs/core/http-only";
+import { CoordinatedShutdown, CoordinatedStartup as CoordinatedStartup$1 } from "@seedcord/core/node";
+import { REST, RESTOptions } from "@discordjs/rest";
+import { AnyCustomId } from "@seedcord/custom-id";
+import { BotConfig, Config, DeferOpts, EmojiMap, HealthCheckConfig, ReplyResponse, SendOpts, TypedOmit } from "@seedcord/types";
+import { NonEmptyTuple, Promisable } from "type-fest";
+//#region src/subscriptions.d.ts
+declare module '@seedcord/core/internal' {
+  interface DefaultSubscriptions {
+    /** Triggered for every verified interaction, before routing. */
+    anyInteraction: {
+      interaction: APIInteraction;
+    };
+  }
+}
+//#endregion
+//#region src/interfaces/Config.d.ts
+type EdgeSweeperKey = 'hashSweepInterval' | 'handlerSweepInterval';
+interface HttpBotConfig<Options> extends BotConfig {
+  /**
+   * Passed to the `REST` client from `@discordjs/rest`.
+   */
+  restOptions?: Options;
+}
+/**
+ * Config for a long-running node server. Pass to `new Seedcord(config).start()`.
+ */
+interface HttpServerConfig extends Config {
+  bot: HttpBotConfig<Partial<RESTOptions>>;
+  /**
+   * Port the interactions server uses. `false` turns off the built-in server. Mount
+   * `seedcord.fetch()` in your own server to answer requests.
+   *
+   * @defaultValue `3000`
+   */
+  port?: number | false;
+  /**
+   * The health path on the interactions server. It answers 503 until startup finishes, then 200.
+   * `false` turns it off, `true` or omit for `/health`, `{ path }` sets the path.
+   */
+  healthCheck?: boolean | Pick<HealthCheckConfig, 'path'>;
+}
+/**
+ * Config for a bot on Cloudflare Workers. Pass to `new Seedcord(config)`.
+ */
+interface HttpEdgeConfig extends Config {
+  bot: HttpBotConfig<Partial<TypedOmit<RESTOptions, EdgeSweeperKey>>>;
+  port?: never;
+  lifecycle?: never;
+}
+/**
+ * The http transport's configuration on either runtime.
+ */
+type HttpConfig = HttpServerConfig | HttpEdgeConfig;
+//#endregion
+//#region src/interfaces/Core.d.ts
+/**
+ * Main interface for Seedcord core functionality on the HTTP transport.
+ *
+ * This interface can be augmented via declaration merging to add type-safe plugin definitions when
+ * using `this.core` in handlers.
+ *
+ * @example
+ * ```typescript
+ * declare module '@seedcord/http' {
+ *   interface Core {
+ *     db: Mongoose;
+ *   }
+ * }
+ * ```
+ */
+interface Core extends CoreBase {
+  readonly startup: Pick<CoordinatedStartup$1, 'addTask'>;
+  readonly shutdown: Pick<CoordinatedShutdown, 'addTask'>;
+  readonly config: HttpConfig;
+}
+//#endregion
+//#region src/handlers/interaction/AutocompleteHandler.d.ts
+type FocusedArms<Route extends keyof SlashRegistry, Ret> = { [Name in AutocompletableNames<Route>]: (value: string, respond: (choices: readonly APIApplicationCommandOptionChoice<ChoiceValueOf<EntryFor<Route, Name>>>[]) => Promise<void>) => Promisable<Ret>; };
+/**
+ * Base class for an autocomplete handler on the HTTP transport.
+ *
+ * Pass the command route(s) from the generated registry as the generic. Branch on the focused field with
+ * `this.match`, read already-entered sibling options with `this.options`, and find which command fired
+ * with `this.route`.
+ *
+ * @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'search'`.
+ */
+declare abstract class AutocompleteHandler<Route extends keyof SlashRegistry> extends BaseHandler<APIApplicationCommandAutocompleteInteraction, Core> {
+  constructor(event: APIApplicationCommandAutocompleteInteraction, core: Core, dispatch: DispatchContext);
+  /** @internal */
+  readonly [AutocompleteRouteBrand]?: Route;
+  /**
+   * Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core.
+   */
+  protected get api(): API;
+  private resolver?;
+  private get reader();
+  /**
+   * 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.
+   */
+  protected get focused(): FocusedField<Route>;
+  /**
+   * Run the arm for the focused field. An autocomplete always dispatches by which field is focused.
+   * Match is how you read it.
+   *
+   * Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
+   * arm receives the focused partial value and a `respond` typed to that field's choice value. The
+   * arms must cover every autocompletable field. A missing field or an unknown key is a compile error.
+   *
+   * @param arms - One handler per autocompletable field, keyed by field name.
+   * @returns The result of the arm that ran.
+   * @throws A **SeedcordTypeError** with `MatchArmMissing` when the focused field has no arm. Only a stale-deployed command can send one.
+   */
+  protected match<Ret>(arms: FocusedArms<Route, Ret>): Promise<Ret>;
+  /** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
+  protected respond(choices: readonly APIApplicationCommandOptionChoice[]): Promise<void>;
+  /** 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. The focused field is on `this.focused`.
+   */
+  protected get options(): AutocompleteOptions<Route>;
+}
+//#endregion
+//#region src/reply/ReplySender.d.ts
+/** The interaction payload fields the sender writes its wire from. */
+interface InteractionRef {
+  readonly application_id: string;
+  readonly id: string;
+  readonly token: string;
+}
+/** The created message an http reply resolves to (the http `SentMessage` lens). */
+type SentMessage = APIMessage;
+/**
+ * Writes interaction responses over the Discord REST callback and webhook endpoints. Construction is
+ * internal to the repliable handler bases and the dispatcher.
+ */
+declare class ReplySender extends BaseReplySender<SentMessage> {
+  private readonly ref;
+  private readonly rest;
+  constructor(ref: InteractionRef, rest: REST, dispatch: DispatchContext, bus: Bus);
+  protected writeReply(response: ReplyResponse | string, opts?: SendOpts): Promise<SentMessage | undefined>;
+  protected writeDefer(opts?: DeferOpts): Promise<void>;
+  protected writeDeferUpdate(): Promise<void>;
+  protected writeUpdate(response: ReplyResponse | string): Promise<SentMessage | undefined>;
+  protected writeFollowUp(response: ReplyResponse | string, opts?: SendOpts): Promise<SentMessage>;
+  protected writeEditOriginal(response: ReplyResponse | string): Promise<SentMessage>;
+  protected writeEditTarget(targetId: string, response: ReplyResponse | string): Promise<SentMessage>;
+  protected writeDeleteOriginal(): Promise<void>;
+  protected writeDeleteTarget(targetId: string): Promise<void>;
+  protected writeModal(data: APIModalInteractionResponseCallbackData): Promise<void>;
+  private callback;
+  private editMessage;
+  private rawFiles;
+  private createdMessage;
+}
+//#endregion
+//#region src/handlers/interactionTypes.d.ts
+type ValidInteractionTypes = APIChatInputApplicationCommandInteraction | APIContextMenuInteraction | APIMessageComponentInteraction | APIModalSubmitInteraction | APIApplicationCommandAutocompleteInteraction;
+type Repliables = Exclude<ValidInteractionTypes, APIApplicationCommandAutocompleteInteraction>;
+//#endregion
+//#region src/handlers/RepliableHandler.d.ts
+/**
+ * Shared base the repliable HTTP interaction handlers extend.
+ *
+ * Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
+ * {@link ContextMenuHandler}, or one of the select menu bases instead. This class binds the core
+ * reply base to the http sender.
+ *
+ * @typeParam Event - The repliable interaction type this handler processes
+ */
+declare abstract class RepliableHandler$1<Event extends Repliables> extends RepliableHandler<Event, Core, SentMessage, never, ReplySender> {
+  /** @internal */
+  getEvent(): Event;
+  protected buildSender(event: Event, core: Core, dispatch: DispatchContext): ReplySender;
+  /**
+   * Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core.
+   * The interaction callbacks on `api.interactions` bypass the reply surface. The
+   * `no-raw-interaction-acks` rule flags them in handler classes.
+   */
+  protected get api(): API;
+}
+//#endregion
+//#region src/handlers/interaction/InteractionHandler.d.ts
+/**
+ * Shared base the repliable interaction handlers extend.
+ *
+ * Not a public entry point. Extend {@link SlashHandler}, {@link ContextMenuHandler}, {@link ButtonHandler},
+ * {@link ModalHandler}, or one of the select menu bases instead. This class adds `showModal` on top
+ * of the reply members.
+ *
+ * @typeParam Event - The repliable interaction type this handler processes
+ */
+declare abstract class InteractionHandler<Event extends Repliables> extends RepliableHandler$1<Event> {
+  constructor(event: Event, core: Core, dispatch: DispatchContext);
+  /**
+   * Open a modal. Must be the initial response to this interaction. The modal kind rejects this call at
+   * compile time (Discord forbids a modal in response to a modal).
+   */
+  protected showModal(this: InteractionHandler<Exclude<Repliables, APIModalSubmitInteraction>>, modal: ModalLike): Promise<void>;
+}
+//#endregion
+//#region src/handlers/interaction/components/ComponentHandler.d.ts
+/**
+ * Shared base the customId-routed component handlers extend on the HTTP transport.
+ *
+ * Not a public entry point. Extend {@link ButtonHandler}, {@link ModalHandler}, or one of the select menu
+ * bases instead. This class defines the customId decode, the route matching, and the source-message
+ * verbs `update` and `deferUpdate`.
+ *
+ * @typeParam Event - The component or modal interaction type this handler processes
+ * @typeParam Defs - The customId route definitions registered on the concrete handler
+ */
+declare abstract class ComponentHandler<Event extends APIMessageComponentInteraction | APIModalSubmitInteraction, Defs extends readonly AnyCustomId[]> extends InteractionHandler<Event> implements HasComponentDefs<Defs> {
+  /** @internal */
+  readonly [ComponentDefsBrand]?: Defs;
+  /** Rewrite the source message this component interaction came from. */
+  protected update(response: ReplyResponse | string): Promise<SentMessage>;
+  /** Acknowledge the component without changing the source message. */
+  protected deferUpdate(): Promise<void>;
+  private decoded?;
+  private get route();
+  /**
+   * The decoded params of the single route this handler is registered for.
+   *
+   * Reading this decodes `this.event.data.custom_id` once and caches the result. On a handler
+   * registered for several routes this is `never`. Use {@link match} instead.
+   *
+   * @throws A **StaleCustomId** when the wire was encoded under an older shape. The dispatcher boundary turns it into a reply.
+   * @throws An **InvalidCustomId** when the wire is corrupt. The dispatcher boundary turns it into a reply.
+   */
+  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 compiler checks that the arms cover every registered route prefix. `match`
+   * decodes the wire before it runs an arm.
+   *
+   * @param arms - One callback per registered route, keyed by prefix.
+   * @returns The result of the arm that ran.
+   * @throws A **SeedcordTypeError** with `MatchArmMissing` when the wire's prefix has no arm.
+   * @throws A **StaleCustomId** when the wire was encoded under an older shape.
+   * @throws An **InvalidCustomId** when the wire is corrupt.
+   *
+   * @example
+   * ```ts
+   * \@ButtonRoute(Approve, Reject)
+   * class ReviewButtons extends ButtonHandler<[typeof Approve, typeof Reject]> {
+   *     async execute() {
+   *         await this.match({
+   *             approve: ({ userId }) => this.reply(`approved <@${userId}>`),
+   *             reject: ({ userId }) => this.reply(`rejected <@${userId}>`)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: MatchArms<Defs, Ret>): Promise<Ret>;
+}
+//#endregion
+//#region src/handlers/interaction/components/SelectMenuHandler.d.ts
+/** @internal */
+type SelectInteraction<Data> = APIMessageComponentSelectMenuInteraction & {
+  data: Data;
+};
+/**
+ * Shared base the select menu handlers extend on the HTTP transport.
+ *
+ * Not a public entry point. Extend {@link StringMenuHandler}, {@link UserMenuHandler},
+ * {@link RoleMenuHandler}, {@link ChannelMenuHandler}, or {@link MentionableMenuHandler} instead. This
+ * class defines the `values` getter those bases share.
+ *
+ * @typeParam Event - The select menu interaction type this handler processes
+ * @typeParam Defs - The customId route definitions registered on the concrete handler
+ */
+declare abstract class SelectMenuHandler<Event extends APIMessageComponentSelectMenuInteraction, Defs extends readonly AnyCustomId[]> extends ComponentHandler<Event, Defs> {
+  /** The values this select picked. On every kind but the string menu they are snowflake ids. */
+  protected get values(): string[];
+}
+/**
+ * Base class for a string select menu handler on the HTTP transport.
+ *
+ * Register the customId definitions with `@StringMenuRoute`, list the same ones in the generic, then read
+ * the chosen option values from `this.values`. Read `this.params` for a single route or `this.match` for
+ * several. Reply through the handler members, or rewrite the source message with `this.update`.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof TopicsId]`.
+ *
+ * @example
+ * ```ts
+ * \@StringMenuRoute(TopicsId)
+ * class Topics extends StringMenuHandler<[typeof TopicsId]> {
+ *     async execute() {
+ *         const { userId } = this.params;
+ *         await this.update(`<@${userId}> now follows ${this.values.join(', ')}`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class StringMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageStringSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.StringMenu;
+}
+/**
+ * Base class for a user select menu handler on the HTTP transport.
+ *
+ * Beside `this.values` this handler declares `this.users` and `this.members`. Register the customId
+ * definitions with `@UserMenuRoute` and list the same ones in the generic.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
+ *
+ * @example
+ * ```ts
+ * \@UserMenuRoute(AssignId)
+ * class Assign extends UserMenuHandler<[typeof AssignId]> {
+ *     async execute() {
+ *         const { roleId } = this.params;
+ *         await this.reply(`assigning ${this.users.size} member(s) to <@&${roleId}>`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class UserMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageUserSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.UserMenu;
+  /** The users this select picked. */
+  protected get users(): Collection<string, APIUser>;
+  /** The guild members behind the picked users. Discord resolves these only inside a guild. */
+  protected get members(): Collection<string, APIInteractionDataResolvedGuildMember>;
+}
+/**
+ * Base class for a role select menu handler on the HTTP transport.
+ *
+ * Beside `this.values` this handler declares `this.roles`. Register the customId definitions with
+ * `@RoleMenuRoute` and list the same ones in the generic.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof GrantId]`.
+ *
+ * @example
+ * ```ts
+ * \@RoleMenuRoute(GrantId)
+ * class Grant extends RoleMenuHandler<[typeof GrantId]> {
+ *     async execute() {
+ *         await this.update(`granting ${this.roles.size} role(s)`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class RoleMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageRoleSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.RoleMenu;
+  /** The roles this select picked. */
+  protected get roles(): Collection<string, APIRole>;
+}
+/**
+ * Base class for a channel select menu handler on the HTTP transport.
+ *
+ * Beside `this.values` this handler declares `this.channels`. Register the customId definitions with
+ * `@ChannelMenuRoute` and list the same ones in the generic.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof LogTargetId]`.
+ *
+ * @example
+ * ```ts
+ * \@ChannelMenuRoute(LogTargetId)
+ * class LogTarget extends ChannelMenuHandler<[typeof LogTargetId]> {
+ *     async execute() {
+ *         await this.update(`logging to ${this.channels.size} channel(s)`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class ChannelMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageChannelSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.ChannelMenu;
+  /** The channels this select picked. */
+  protected get channels(): Collection<string, APIInteractionDataResolvedChannel>;
+}
+/**
+ * Base class for a mentionable select menu handler on the HTTP transport.
+ *
+ * A mentionable menu accepts users and roles together. `this.users`, `this.members`, and `this.roles`
+ * can each come back empty.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof InviteId]`.
+ *
+ * @example
+ * ```ts
+ * \@MentionableMenuRoute(InviteId)
+ * class Invite extends MentionableMenuHandler<[typeof InviteId]> {
+ *     async execute() {
+ *         await this.update(`inviting ${this.users.size} user(s) and ${this.roles.size} role(s)`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class MentionableMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageMentionableSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.MentionableMenu;
+  /** The users this select picked. */
+  protected get users(): Collection<string, APIUser>;
+  /** The guild members behind the picked users. Discord resolves these only inside a guild. */
+  protected get members(): Collection<string, APIInteractionDataResolvedGuildMember>;
+  /** The roles this select picked. */
+  protected get roles(): Collection<string, APIRole>;
+}
+//#endregion
+//#region src/handlers/interaction/middlewareKinds.d.ts
+interface Payloads {
+  [InteractionKind.Slash]: APIChatInputApplicationCommandInteraction;
+  [InteractionKind.Button]: APIMessageComponentButtonInteraction;
+  [InteractionKind.Modal]: APIModalSubmitInteraction;
+  [InteractionKind.StringMenu]: SelectInteraction<APIMessageStringSelectInteractionData>;
+  [InteractionKind.UserMenu]: SelectInteraction<APIMessageUserSelectInteractionData>;
+  [InteractionKind.RoleMenu]: SelectInteraction<APIMessageRoleSelectInteractionData>;
+  [InteractionKind.ChannelMenu]: SelectInteraction<APIMessageChannelSelectInteractionData>;
+  [InteractionKind.MentionableMenu]: SelectInteraction<APIMessageMentionableSelectInteractionData>;
+  [InteractionKind.MessageContextMenu]: APIMessageApplicationCommandInteraction;
+  [InteractionKind.UserContextMenu]: APIUserApplicationCommandInteraction;
+}
+type InteractionForKind = { [Kind in MiddlewareKind]: Payloads[Kind]; };
+/** @internal */
+type InteractionOf<Kind extends MiddlewareKind> = InteractionForKind[Kind];
+//#endregion
+//#region src/handlers/interaction/InteractionMiddleware.d.ts
+/**
+ * Base class for interaction middleware on the HTTP transport.
+ *
+ * Middleware runs after the dispatcher builds the handler and before the gates, over the handler's own
+ * reply surface. Name the kinds in the generic and list the same ones in `{ kinds }`. Several kinds give
+ * `this.event` a union. Narrow it on `type` and `data.component_type`. A catchall reads every repliable
+ * kind.
+ *
+ * @typeParam Kind - One or more {@link InteractionKind} members. Defaults to every repliable kind.
+ *
+ * @example
+ * ```ts
+ * \@RegisterInteractionMiddleware({ kinds: [InteractionKind.Button] })
+ * class Audit extends InteractionMiddleware<InteractionKind.Button> {
+ *     async execute() {
+ *         this.logger.info(this.event.data.custom_id);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class InteractionMiddleware<in out Kind extends MiddlewareKind = MiddlewareKind> extends RepliableHandler$1<InteractionOf<Kind>> {
+  /** @internal */
+  readonly [MiddlewareKindsBrand]?: Kind;
+  constructor(event: InteractionOf<Kind>, core: Core, dispatch: DispatchContext, sender: ReplySender);
+  /**
+   * Runs once the handler settles, newest middleware first. A refusal or a throw still reaches it,
+   * since seedcord calls it on every middleware whose `execute()` started. Implement it to release
+   * something this middleware took in `execute()`, such as a lock or an open span. A throw in here
+   * is logged and goes no further.
+   *
+   * @param result - How the dispatch ended. Either failure state carries the thrown value on `caught`.
+   *
+   * @example
+   * ```ts
+   * // the base declares it. an implementation carries `override`.
+   * override async after(result: DispatchResult) {
+   *     this.lock.release();
+   * }
+   * ```
+   */
+  after?(result: DispatchResult): Promise<void>;
+}
+//#endregion
+//#region src/engine.d.ts
+/** Matches the shape of the Workers `ExecutionContext`. Work that continues after the 202 response runs under its `waitUntil`. */
+interface EngineContext {
+  waitUntil(promise: Promise<unknown>): void;
+}
+//#endregion
+//#region src/Plugin.d.ts
+/** The options an HTTP plugin declares, narrowed to the transports this base serves. */
+type HttpPluginOptions = TypedOmit<PluginOptions, 'transport'> & {
+  transport?: 'http';
+};
+declare const HTTP_SCOPE: {
+  readonly transport: "http";
+};
+/**
+ * Base class for an HTTP plugin, binding `this.core` to the HTTP {@link Core}.
+ *
+ * A plugin that runs on either transport extends the base from `@seedcord/core/plugin`, whose
+ * `this.core` is typed to the shared members only.
+ *
+ * @typeParam Opts - The transport and runtime the plugin declares.
+ */
+declare abstract class Plugin$1<Opts extends HttpPluginOptions = {
+  transport: 'http';
+}> extends Plugin<Opts, Core, keyof typeof HTTP_SCOPE> {
+  /** @internal */
+  protected static readonly [FixedScope]: {
+    readonly transport: "http";
+  };
+}
+//#endregion
+//#region src/inputs/SlashOptions.d.ts
+type ResolvedChannelOf<Type extends ChannelType> = APIInteractionDataResolvedChannelBase<Type> & (Type extends ThreadChannelType ? Pick<APIThreadChannel, 'parent_id' | 'thread_metadata'> : unknown);
+type AnyResolvedChannel = { [Type in ChannelType]: ResolvedChannelOf<Type>; }[ChannelType];
+interface HttpLens {
+  user: APIUser;
+  member: APIInteractionDataResolvedGuildMember;
+  channel: AnyResolvedChannel;
+  role: APIRole;
+  mentionable: APIUser | APIInteractionDataResolvedGuildMember | APIRole;
+  attachment: APIAttachment;
+}
+/**
+ * The typed view over a chat-input command's options for one route on the HTTP transport. Each getter
+ * 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 `discord-api-types` payloads resolved from the interaction's `resolved` data.
+ *
+ * A channel option declared with `addChannelTypes` narrows `getChannel` to the matching resolved-channel
+ * subtype.
+ *
+ * @typeParam Route - A route key from the generated {@link SlashRegistry}.
+ */
+type SlashOptions$1<Route extends keyof SlashRegistry> = SlashOptions<Route, HttpLens>;
+//#endregion
+//#region src/inputs/ModalFields.d.ts
+type FieldKind = ModalSubmitComponent['type'];
+/** The users, members, and roles a mentionable select picked. */
+interface SelectedMentionables {
+  users: Collection<string, APIUser>;
+  members: Collection<string, APIInteractionDataResolvedGuildMember>;
+  roles: Collection<string, APIRole>;
+}
+/**
+ * The fields a modal carries, read by custom id.
+ *
+ * A select getter resolves the ids its field picked against the interaction's `resolved` data and returns a
+ * `Collection` keyed by id. A field that picked nothing returns null.
+ *
+ * @throws A **SeedcordTypeError** from every getter when no field in the modal has that custom id.
+ * @throws A **SeedcordTypeError** from every getter when the field holds a kind that getter does not read. The message gives the getter that does.
+ * @throws A **SeedcordTypeError** from a select getter called with `required` when its field picked nothing.
+ */
+declare class ModalFields {
+  private readonly entries;
+  private readonly resolved;
+  constructor(data: APIModalSubmission);
+  private entry;
+  private field;
+  private selected;
+  /**
+   * Returns the field with this custom id, as Discord sent it. Use it for a component type the typed
+   * getters do not cover.
+   *
+   * Pass a component type to get that exact type back.
+   *
+   * @throws A **SeedcordTypeError** when no field has this custom id.
+   * @throws A **SeedcordTypeError** when you pass a component type and the field holds a different one.
+   */
+  getField<Kind extends FieldKind>(customId: string, kind: Kind): Extract<ModalSubmitComponent, {
+    type: Kind;
+  }>;
+  getField(customId: string): ModalSubmitComponent;
+  getTextInputValue(customId: string): string;
+  getStringSelectValues(customId: string): string[];
+  getSelectedUsers(customId: string, required: true): Collection<string, APIUser>;
+  getSelectedUsers(customId: string, required?: boolean): Collection<string, APIUser> | null;
+  /** The guild members behind the picked users. Discord resolves these only inside a guild. */
+  getSelectedMembers(customId: string): Collection<string, APIInteractionDataResolvedGuildMember> | null;
+  getSelectedRoles(customId: string, required: true): Collection<string, APIRole>;
+  getSelectedRoles(customId: string, required?: boolean): Collection<string, APIRole> | null;
+  /** Pass `channelTypes` to throw when a pick falls outside those types. */
+  getSelectedChannels(customId: string, required: true, channelTypes?: readonly ChannelType[]): Collection<string, APIInteractionDataResolvedChannel>;
+  getSelectedChannels(customId: string, required?: boolean, channelTypes?: readonly ChannelType[]): Collection<string, APIInteractionDataResolvedChannel> | null;
+  getSelectedMentionables(customId: string, required: true): SelectedMentionables;
+  getSelectedMentionables(customId: string, required?: boolean): SelectedMentionables | null;
+  getUploadedFiles(customId: string, required: true): Collection<string, APIAttachment>;
+  getUploadedFiles(customId: string, required?: boolean): Collection<string, APIAttachment> | null;
+  getRadioGroup(customId: string, required: true): string;
+  getRadioGroup(customId: string, required?: boolean): string | null;
+  getCheckboxGroup(customId: string): string[];
+  getCheckbox(customId: string): boolean;
+}
+//#endregion
+//#region src/emojis/EmojiInjector.d.ts
+/** The global {@link Emojis} accessor type. */
+type InjectedEmojiMap = { [K in keyof EmojiMap]: ResolvedEmoji; };
+/**
+ * The bot's resolved emojis, keyed by {@link EmojiMap}. A node bot fills these during startup. An edge
+ * bot fills them on its first request, from the ids `seedcord build` wrote into the worker.
+ *
+ * @throws A **SeedcordError** when you read a key that was not filled.
+ */
+declare const Emojis: InjectedEmojiMap;
+//#endregion
+//#region src/handlers/interaction/SlashHandler.d.ts
+type SlashMatchArms<Route extends keyof SlashRegistry, Ret> = { [Key in Route]: (options: SlashOptions$1<Key>) => Promisable<Ret>; };
+/**
+ * Base class for a chat-input (slash) command handler on the HTTP transport.
+ *
+ * Pass the route from the generated registry as the generic, then read `this.options` for a single
+ * command or `this.match` for several. Command authoring stays plain discord.js, `seedcord codegen`
+ * reads its `toJSON()` to type these options.
+ *
+ * @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
+ */
+declare abstract class SlashHandler<Route extends keyof SlashRegistry> extends InteractionHandler<APIChatInputApplicationCommandInteraction> {
+  /** @internal */
+  readonly [SlashRouteBrand]?: Route;
+  private resolver?;
+  /**
+   * The typed options for this command's route. Only the getters for kinds this command declares appear.
+   * Each getter's name argument is restricted to that command's options of its kind.
+   *
+   * - A required option drops the null.
+   *
+   * - Choices narrow to their literal union.
+   *
+   * - A channel option declared with `addChannelTypes` narrows to those types.
+   *
+   * Rich kinds resolve from the interaction's `resolved` data.
+   */
+  protected get options(): SlashOptions$1<Route>;
+  /**
+   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * routes.
+   *
+   * Provide one arm per registered route, keyed by its route string, and each arm receives that route's
+   * own narrowed options. The arms must cover every route in the generic, a missing route or an unknown
+   * key is a compile error.
+   *
+   * @param arms - One handler per registered route, keyed by route string.
+   * @returns The result of the arm that ran.
+   */
+  protected match<Ret>(arms: SlashMatchArms<Route, Ret>): Promise<Ret>;
+}
+//#endregion
+//#region src/handlers/interaction/ContextMenuHandler.d.ts
+type UserMenuArms<Names extends NamesFor<ApplicationCommandType.User>, Ret> = Record<Names, (target: APIUser, member: APIInteractionDataResolvedGuildMember | null) => Promisable<Ret>>;
+type MessageMenuArms<Names extends NamesFor<ApplicationCommandType.Message>, Ret> = Record<Names, (target: APIMessage) => Promisable<Ret>>;
+/**
+ * Base class for a user context-menu command handler on the HTTP transport (right-click a user).
+ *
+ * Pass the command name(s) as the generic, the same as `@UserContextMenuRoute`. Read the right-clicked user
+ * from `this.target` and that same user's guild member from `this.targetMember`.
+ *
+ * @typeParam Names - One or more command names from the generated user registry.
+ */
+declare abstract class UserContextMenuHandler<Names extends NamesFor<ApplicationCommandType.User>> extends InteractionHandler<APIUserApplicationCommandInteraction> {
+  /** @internal */
+  readonly [ContextMenuKindBrand]?: ApplicationCommandType.User;
+  /** @internal */
+  readonly [ContextMenuNamesBrand]?: Names;
+  protected get target(): APIUser;
+  /** The right-clicked user's guild member, null outside a guild. */
+  protected get targetMember(): APIInteractionDataResolvedGuildMember | null;
+  /** Which of the registered commands fired. */
+  protected get commandName(): Names;
+  /**
+   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * names.
+   *
+   * Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
+   * arm receives the clicked user and that user's guild member. The arms must cover every name in the
+   * generic. A missing name or an unknown key is a compile error.
+   *
+   * @param arms - One handler per registered command name.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@UserContextMenuRoute('View Profile', 'Warn')
+   * class Moderation extends UserContextMenuHandler<'View Profile' | 'Warn'> {
+   *     async execute() {
+   *         await this.match({
+   *             'View Profile': (user) => this.reply(`Profile for ${user.username}.`),
+   *             Warn: (user, member) => this.reply(`Warned ${member?.nick ?? user.username}.`)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: UserMenuArms<Names, Ret>): Promise<Ret>;
+}
+/**
+ * Base class for a message context-menu command handler on the HTTP transport (right-click a message).
+ *
+ * Pass the command name(s) as the generic, the same as `@MessageContextMenuRoute`. Read the right-clicked
+ * message from `this.target`.
+ *
+ * @typeParam Names - One or more command names from the generated message registry.
+ */
+declare abstract class MessageContextMenuHandler<Names extends NamesFor<ApplicationCommandType.Message>> extends InteractionHandler<APIMessageApplicationCommandInteraction> {
+  /** @internal */
+  readonly [ContextMenuKindBrand]?: ApplicationCommandType.Message;
+  /** @internal */
+  readonly [ContextMenuNamesBrand]?: Names;
+  protected get target(): APIMessage;
+  /** Which of the registered commands fired. */
+  protected get commandName(): Names;
+  /**
+   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * names.
+   *
+   * Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
+   * arm receives the clicked message. The arms must cover every name in the generic. A missing name or
+   * an unknown key is a compile error.
+   *
+   * @param arms - One handler per registered command name.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@MessageContextMenuRoute('Report Message', 'Quote Message')
+   * class MessageTools extends MessageContextMenuHandler<'Report Message' | 'Quote Message'> {
+   *     async execute() {
+   *         await this.match({
+   *             'Report Message': (message) => this.report(message),
+   *             'Quote Message': (message) => this.reply(`> ${message.content}`)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: MessageMenuArms<Names, Ret>): Promise<Ret>;
+}
+//#endregion
+//#region src/handlers/interaction/components/ButtonHandler.d.ts
+/**
+ * Base class for a button interaction handler on the HTTP transport.
+ *
+ * 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. Reply through the
+ * handler members, or rewrite the source message with `this.update`. 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]`.
+ */
+declare abstract class ButtonHandler<Defs extends readonly AnyCustomId[]> extends ComponentHandler<APIMessageComponentButtonInteraction, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.Button;
+}
+//#endregion
+//#region src/handlers/interaction/components/ModalHandler.d.ts
+/**
+ * Base class for a modal submit handler on the HTTP transport.
+ *
+ * Register the customId definitions this handler decodes with `@ModalRoute` and list the same ones in the
+ * generic. Read the submitted inputs from `this.fields`. Reply through the handler members. `showModal`
+ * fails compilation on this kind, because Discord forbids opening a modal in response to a modal.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
+ *
+ * @example
+ * ```ts
+ * \@ModalRoute(ConfigId)
+ * class ConfigModal extends ModalHandler<[typeof ConfigId]> {
+ *     async execute() {
+ *         const { guildId } = this.params;
+ *         const name = this.fields.getTextInputValue('name');
+ *         await this.reply(`saved ${name} for ${guildId}`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class ModalHandler<Defs extends readonly AnyCustomId[]> extends ComponentHandler<APIModalSubmitInteraction, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.Modal;
+  private reader?;
+  /** The fields this modal submitted, read by custom id. */
+  protected get fields(): ModalFields;
+  /** Rewrite the message this modal was opened from. Throws when a command opened the modal. */
+  protected update(response: ReplyResponse | string): Promise<SentMessage>;
+  /** Acknowledge the submit without changing the source message. Throws when a command opened the modal. */
+  protected deferUpdate(): Promise<void>;
+  private ensureSourceMessage;
+}
+//#endregion
+//#region src/subscribers/index.d.ts
+/**
+ * Base class for an HTTP subscriber, binding `this.core` to the HTTP {@link Core}.
+ *
+ * @typeParam KeyOfSubscribers - The subscription key this handler receives
+ */
+declare abstract class Subscriber$1<KeyOfSubscribers extends SubscriptionKey> extends Subscriber<KeyOfSubscribers, Core> {}
+/**
+ * Base class for an HTTP subscriber that delivers its event to a Discord webhook, binding
+ * `this.core` to the HTTP {@link Core}.
+ *
+ * @typeParam KeyOfSubscribers - The subscription key this reporter receives
+ */
+declare abstract class WebhookLog$1<KeyOfSubscribers extends SubscriptionKey> extends WebhookLog<KeyOfSubscribers, Core> {}
+//#endregion
+//#region src/pagination/PageContext.d.ts
+/**
+ * The context passed to a source loader. The raw payload carries a guild id with no guild object, so a
+ * loader that requires guild data fetches it through `core.rest`.
+ */
+interface PageContext {
+  /** The interaction that triggered this load (a command or a nav click). */
+  interaction: Repliables;
+  /** The acting user, always present. */
+  user: APIUser;
+  /** The guild id, or `null` in a DM. */
+  guildId: string | null;
+  core: Core;
+}
+//#endregion
+//#region src/pagination/Paginator.d.ts
+type PaginatorHandlerCtor<Prefix extends string> = new (...args: ConstructorParameters<typeof ButtonHandler>) => 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) => loadBans(ctx.guildId), { perPage: 10 }),
+ *     renderItem: (ban) => ban.user.username
+ * });
+ *
+ * \@ButtonRoute(Bans.cursor)
+ * export class BansNav extends Bans.Handler {}
+ * ```
+ */
+declare class Paginator<Item, const Prefix extends string> extends PaginatorBase<Item, Prefix, PageContext> {
+  /** The nav handler base. Extend it with an empty body and decorate it, `@ButtonRoute(p.cursor)`. */
+  readonly Handler: PaginatorHandlerCtor<Prefix>;
+  constructor(config: PaginatorConfig<Item, Prefix, PageContext>);
+  /**
+   * Render a page as a {@link ReplyResponse} without sending anything.
+   *
+   * @param handler - The handler rendering the page, normally `this`.
+   * @param n - The zero-based page.
+   */
+  page(handler: RepliableHandler$1<Repliables>, n: number): Promise<ReplyResponse>;
+  /**
+   * Send a page through the handler's sender. The sender picks reply, edit, or followUp from its ack state.
+   *
+   * @param handler - The handler starting the paginator, normally `this`.
+   * @param n - The zero-based page to open on.
+   */
+  start(handler: RepliableHandler$1<Repliables>, n?: number): Promise<SentMessage>;
+}
+//#endregion
+//#region src/pagination/sources.d.ts
+/**
+ * The one method a paginator calls on a source, once per click. Implement it for a source neither shipped
+ * one covers.
+ *
+ * @typeParam Item - The item type the source pages over.
+ */
+type PageSource<Item> = PageSourceBase<Item, PageContext>;
+/**
+ * A source for a bounded list you can load whole. It loads the full list on every click, then slices the
+ * page, 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> extends ArraySourceBase<Item, PageContext> {}
+/**
+ * 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> extends CursorSourceBase<Item, PageContext> {}
+//#endregion
+//#region src/gates/Gate.d.ts
+/**
+ * The interaction gate context on the HTTP transport. It extends the scalar {@link GateContextBase} with the
+ * raw interaction payload and the user and member the payload carries. A gate reading button fields, inferred
+ * from its `ctx` annotation, is rejected on a slash handler.
+ *
+ * The http transport delivers no role-derived permission sets, so `memberGuildPermissions` and
+ * `appGuildPermissions` are absent. A gate requiring `GuildPermissionsContext` (a permission gate with
+ * `in: 'guild'`) is a compile error on an http handler.
+ *
+ * @typeParam Repliable - The interaction type the gate reads, narrowing which handlers accept it.
+ *
+ * @example
+ * ```ts
+ * import type { APIMessageComponentButtonInteraction } from 'discord-api-types/v10';
+ *
+ * // a button-only gate: the Repliable generic narrows which handlers accept it
+ * const ButtonGate = defineGate('btn', (ctx: InteractionGateContext<APIMessageComponentButtonInteraction>) => {
+ *     void ctx.interaction; // APIMessageComponentButtonInteraction
+ * });
+ * ```
+ */
+interface InteractionGateContext<Repliable extends Repliables = Repliables> extends GateContextBase {
+  /** Narrow on this before reading `interaction`. */
+  readonly kind: 'interaction';
+  readonly core: Core;
+  /** The raw interaction payload, which is the reply target. */
+  readonly interaction: Repliable;
+  /** Every repliable interaction contains a user. */
+  readonly user: APIUser;
+  /** The invoking member, or null in a DM. */
+  readonly member: APIInteractionGuildMember | null;
+}
+//#endregion
+//#region src/gates/matching.d.ts
+type AnyHandlerCtor = abstract new (...args: never[]) => {
+  execute(): Promise<void>;
+};
+declare const UngateableBrand: unique symbol;
+interface Ungateable {
+  readonly [UngateableBrand]: true;
+}
+type ProvidedContext<TCtor extends AnyHandlerCtor> = InstanceType<TCtor> extends RepliableHandler$1<infer Event> ? InteractionGateContext<Event> : Ungateable;
+type SelectData<Repliable> = Repliable extends APIMessageComponentSelectMenuInteraction ? Repliable['data'] : never;
+type SelectKindName<Data> = Data extends APIMessageStringSelectInteractionData ? 'StringMenu' : Data extends APIMessageUserSelectInteractionData ? 'UserMenu' : Data extends APIMessageRoleSelectInteractionData ? 'RoleMenu' : Data extends APIMessageChannelSelectInteractionData ? 'ChannelMenu' : Data extends APIMessageMentionableSelectInteractionData ? 'MentionableMenu' : 'an interaction';
+type KindName<Ctx> = Ctx extends Ungateable ? 'autocomplete' : Ctx extends GuildPermissionsContext ? 'gateway (guild permissions)' : Ctx extends InteractionGateContext<infer Repliable> ? Repliable extends APIChatInputApplicationCommandInteraction ? 'Slash' : Repliable extends APIMessageApplicationCommandInteraction ? 'MessageContextMenu' : Repliable extends APIUserApplicationCommandInteraction ? 'UserContextMenu' : Repliable extends APIMessageComponentSelectMenuInteraction ? SelectKindName<SelectData<Repliable>> : Repliable extends APIMessageComponentButtonInteraction ? 'Button' : Repliable extends APIModalSubmitInteraction ? 'Modal' : 'an interaction' : '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/gates/Gated.d.ts
+/**
+ * Attaches gates to an HTTP interaction 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. A gate
+ * that requires a context the handler does not provide (a button gate on a slash handler, a gate on an
+ * autocomplete handler, or a `RequirePermissions([...], { in: 'guild' })` gate the http transport cannot
+ * satisfy) 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-api-types/v10';
+ *
+ * \@Gated(GuildOnly(), RequirePermissions([PermissionFlagsBits.ManageMessages]))
+ * \@SlashRoute('purge')
+ * class Purge extends SlashHandler<'purge'> {
+ *     async execute() {
+ *         // both gates passed, so this runs in a guild with a caller who can moderate this channel
+ *     }
+ * }
+ * ```
+ *
+ * @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 requires 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/version.d.ts
+declare const version: string;
+//#endregion
+export { RoleMenuHandler as A, AutocompleteHandler as B, Plugin$1 as C, InteractionMiddleware as D, EngineContext as E, InteractionHandler as F, HttpConfig as H, RepliableHandler$1 as I, InteractionRef as L, StringMenuHandler as M, UserMenuHandler as N, ChannelMenuHandler as O, ComponentHandler as P, ReplySender as R, HttpPluginOptions as S, PluginOptions$1 as T, HttpEdgeConfig as U, Core as V, HttpServerConfig as W, Emojis as _, ArraySource as a, SelectedMentionables as b, Paginator as c, WebhookLog$1 as d, ModalHandler as f, SlashHandler as g, UserContextMenuHandler as h, InteractionGateContext as i, SelectMenuHandler as j, MentionableMenuHandler as k, PageContext as l, MessageContextMenuHandler as m, version as n, CursorSource as o, ButtonHandler as p, Gated as r, PageSource as s, HmrModuleHandler$1 as t, Subscriber$1 as u, InjectedEmojiMap as v, PluginLifecycleSpec as w, SlashOptions$1 as x, ModalFields as y, SentMessage as z };
+//# sourceMappingURL=shared-vsj1uwIH.d.mts.map