@seedcord/http 0.0.1 → 0.1.0-next.1

package/dist/edge.index-CTOyjsO4.d.mts

@@ -0,0 +1,501 @@
+import { t as RouteManifest } from "./RouteManifest-BHdAeyLG.mjs";
+import { REST } from "@discordjs/rest";
+import { AutocompleteOptions, BaseHandler, CoreBase, DispatchContext, Gate, GateContextBase, GuildPermissionsContext, RepliableHandler, RequiredOf, SelectMenuKind, SlashOptionRegistry } from "@seedcord/core";
+import { AnyCustomId, AutocompletableNames, BaseReplySender, ChoiceValueOf, EntryFor, FocusedField, GateFitsWith, HasComponentDefs, InteractionRoutes, MatchArms, ModalLike, SingleParams, SlashOptions } from "@seedcord/core/internal";
+import { APIApplicationCommandAutocompleteInteraction, APIApplicationCommandOptionChoice, APIAttachment, APIChatInputApplicationCommandInteraction, APIContextMenuInteraction, APIInteractionDataResolvedChannelBase, APIInteractionDataResolvedGuildMember, APIInteractionGuildMember, APIMessage, APIMessageApplicationCommandInteraction, APIMessageChannelSelectInteractionData, APIMessageComponentButtonInteraction, APIMessageComponentInteraction, APIMessageComponentSelectMenuInteraction, APIMessageMentionableSelectInteractionData, APIMessageRoleSelectInteractionData, APIMessageStringSelectInteractionData, APIMessageUserSelectInteractionData, APIModalInteractionResponseCallbackData, APIModalSubmitInteraction, APIRole, APIThreadChannel, APIUser, APIUserApplicationCommandInteraction, ApplicationCommandType, ChannelType, ThreadChannelType } from "discord-api-types/v10";
+import { API } from "@discordjs/core/http-only";
+import { SeedcordInstance } from "@seedcord/types/internal";
+import { Config, DeferOpts, HealthCheckOption, ReplyResponse, SendOpts } from "@seedcord/types";
+import { NonEmptyTuple, Promisable } from "type-fest";
+
+//#region src/plugin-capabilities.d.ts
+declare module '@seedcord/core' {
+  interface PluginCapabilityTypes {
+    rest: REST;
+  }
+}
+//#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: Mongo;
+ *   }
+ * }
+ * ```
+ */
+interface Core extends CoreBase, SeedcordInstance {
+  /** Workerd-compatible Discord REST client. */
+  readonly rest: REST;
+  readonly config: Config;
+}
+//#endregion
+//#region src/engine.d.ts
+/** Structural match for the Workers `ExecutionContext`. Pass it from the edge entry so post-202 work runs under `waitUntil`. */
+interface EngineContext {
+  waitUntil(promise: Promise<unknown>): void;
+}
+//#endregion
+//#region src/createSeedcord.d.ts
+/**
+ * Builds the HTTP-interactions engine, a `(request, ctx?) => Promise<Response>` handler.
+ *
+ * The handler verifies the Ed25519 signature over the raw request bytes, rejects stale or replayed
+ * requests, answers a PING with an in-body PONG, and acks every other interaction with an empty 202.
+ * The engine dispatches a matched interaction through the manifest before the 202 goes out. Gates run
+ * first and the sender posts any refusal over the REST callback. `execute()` continues past the 202 under
+ * `ctx.waitUntil` when the caller passes one (the edge entry), and an engine-held in-flight set tracks
+ * it otherwise (node paths). It reads only the method, headers, and body. Mount it at any path.
+ *
+ * Reads `DISCORD_PUBLIC_KEY` and `DISCORD_BOT_TOKEN` from the environment through envapt and throws a
+ * `SeedcordError` when either is missing or malformed.
+ */
+declare function createSeedcord(config: Config, manifest: RouteManifest): (request: Request, ctx?: EngineContext) => Promise<Response>;
+//#endregion
+//#region src/interfaces/Config.d.ts
+/**
+ * Config for a long-running node server. Pass to `new Seedcord(config).start(port)`.
+ */
+interface HttpServerConfig extends Config {
+  runtime?: 'server';
+  /**
+   * The health-check server. `false` disables it, `true` or omit for the defaults, an object
+   * configures it.
+   */
+  healthCheck?: HealthCheckOption;
+}
+/**
+ * Config for a bundled isolate deployment. `seedcord build` generates a worker entry that calls
+ * `createSeedcord`.
+ */
+interface HttpEdgeConfig extends Config {
+  runtime: 'edge';
+  healthCheck?: never;
+}
+/**
+ * The http transport's configuration, discriminated on `runtime`.
+ */
+type HttpConfig = HttpServerConfig | HttpEdgeConfig;
+//#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 SlashOptionRegistry}.
+ */
+type SlashOptions$1<Route extends keyof SlashOptionRegistry> = SlashOptions<Route, HttpLens>;
+//#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, routeId: string);
+  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 SelectMenuHandler}, or {@link ContextMenuHandler} 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, ReplySender> {
+  protected buildSender(event: Event, core: Core, routeId: string): 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 SelectMenuHandler}, or {@link ModalHandler} 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/SlashHandler.d.ts
+type SlashMatchArms<Route extends keyof SlashOptionRegistry, 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 SlashOptionRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
+ */
+declare abstract class SlashHandler<Route extends keyof SlashOptionRegistry> extends InteractionHandler<APIChatInputApplicationCommandInteraction> {
+  /** @internal */
+  readonly __slashRoute?: Route;
+  private resolver?;
+  /**
+   * 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. 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 ContextMenuKind = ApplicationCommandType.User | ApplicationCommandType.Message;
+type InteractionFor<Kind extends ContextMenuKind> = Kind extends ApplicationCommandType.User ? APIUserApplicationCommandInteraction : APIMessageApplicationCommandInteraction;
+type TargetFor<Kind extends ContextMenuKind> = Kind extends ApplicationCommandType.User ? APIUser : APIMessage;
+type TargetMemberFor<Kind extends ContextMenuKind> = Kind extends ApplicationCommandType.User ? APIInteractionDataResolvedGuildMember | null : never;
+/**
+ * Base class for a context-menu command handler on the HTTP transport (right-click a user or a message).
+ *
+ * Pass the kind from {@link ApplicationCommandType} as the generic. Read the right-clicked entity from
+ * `this.target`, an `APIUser` for a user menu and an `APIMessage` 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`.
+ */
+declare abstract class ContextMenuHandler<Kind extends ContextMenuKind> extends InteractionHandler<InteractionFor<Kind>> {
+  /** @internal */
+  readonly __ctxKind?: Kind;
+  protected get target(): TargetFor<Kind>;
+  /**
+   * The right-clicked user's guild member, resolved only on user menus fired in a guild. Reading it on a
+   * message menu is a compile error.
+   */
+  protected get targetMember(): TargetMemberFor<Kind>;
+}
+//#endregion
+//#region src/handlers/interaction/AutocompleteHandler.d.ts
+type FocusedArms<Route extends keyof SlashOptionRegistry, 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 SlashOptionRegistry}, e.g. `'search'`.
+ */
+declare abstract class AutocompleteHandler<Route extends keyof SlashOptionRegistry> extends BaseHandler<APIApplicationCommandAutocompleteInteraction, Core> {
+  constructor(event: APIApplicationCommandAutocompleteInteraction, core: Core, dispatch?: DispatchContext);
+  /** @internal */
+  readonly __autocompleteRoute?: 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, so
+   * 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. 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.
+   */
+  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/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 SelectMenuHandler}, or {@link ModalHandler}
+ * 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 __componentDefs?: 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 (cached after the first read) and throws
+   * `StaleCustomId` or `InvalidCustomId` when the wire no longer matches the current shape, which the
+   * dispatcher 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 cover every registered route prefix, checked at compile time, and a prefix
+   * unmatched at runtime throws `CustomIdMatchArmMissing`. Decoding runs before any arm, so a stale or
+   * corrupt wire throws before an arm body executes.
+   *
+   * @param arms - One callback 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.reply(`approved <@${userId}>`),
+   *             reject: ({ userId }) => this.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 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 __component?: 'button';
+}
+//#endregion
+//#region src/handlers/interaction/components/SelectMenuHandler.d.ts
+type SelectMenuInteractionFor<Kind extends SelectMenuKind> = APIMessageComponentSelectMenuInteraction & {
+  data: Kind extends SelectMenuKind.String ? APIMessageStringSelectInteractionData : Kind extends SelectMenuKind.User ? APIMessageUserSelectInteractionData : Kind extends SelectMenuKind.Role ? APIMessageRoleSelectInteractionData : Kind extends SelectMenuKind.Channel ? APIMessageChannelSelectInteractionData : Kind extends SelectMenuKind.Mentionable ? APIMessageMentionableSelectInteractionData : never;
+};
+/**
+ * Base class for a select menu handler on the HTTP transport.
+ *
+ * Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`,
+ * so `this.event.data` and its `values`/`resolved` are narrowed to that kind. Read `this.params` for a
+ * single route or `this.match` for several, and reply through the handler members or rewrite the source
+ * message with `this.update`.
+ *
+ * @typeParam Kind - The select kind from {@link SelectMenuKind}, e.g. `SelectMenuKind.User`.
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
+ */
+declare abstract class SelectMenuHandler<Kind extends SelectMenuKind, Defs extends readonly AnyCustomId[]> extends ComponentHandler<SelectMenuInteractionFor<Kind>, Defs> {
+  /** @internal */
+  readonly __component?: Kind;
+}
+//#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 off `this.event.data.components`. Reply through the handler members.
+ * Discord forbids opening a modal in response to a modal, so `showModal` fails compilation on this kind.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
+ */
+declare abstract class ModalHandler<Defs extends readonly AnyCustomId[]> extends ComponentHandler<APIModalSubmitInteraction, Defs> {
+  /** @internal */
+  readonly __component?: 'modal';
+  /** Rewrite the message this modal was opened from (only when a component opened it). */
+  protected update(response: ReplyResponse | string): Promise<SentMessage>;
+  /** Silently acknowledge, leaving the source message untouched. */
+  protected deferUpdate(): Promise<void>;
+  private ensureSourceMessage;
+}
+//#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. `Repliable` narrows which handlers a
+ * gate attaches to, inferred from the `ctx` annotation, so a gate reading button fields 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, so this is never null. */
+  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 KindName<Ctx> = Ctx extends Ungateable ? 'autocomplete' : Ctx extends GuildPermissionsContext ? 'gateway (guild permissions)' : Ctx extends InteractionGateContext<infer Repliable> ? Repliable extends APIChatInputApplicationCommandInteraction ? 'Slash' : Repliable extends APIMessageApplicationCommandInteraction ? 'MessageMenu' : Repliable extends APIUserApplicationCommandInteraction ? 'UserMenu' : SelectData<Repliable> extends APIMessageStringSelectInteractionData ? 'StringSelect' : SelectData<Repliable> extends APIMessageUserSelectInteractionData ? 'UserSelect' : SelectData<Repliable> extends APIMessageRoleSelectInteractionData ? 'RoleSelect' : SelectData<Repliable> extends APIMessageChannelSelectInteractionData ? 'ChannelSelect' : SelectData<Repliable> extends APIMessageMentionableSelectInteractionData ? 'MentionableSelect' : 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, so each must pass. 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
+/** Package version */
+declare const version: string;
+//#endregion
+export { createSeedcord as _, SelectMenuHandler as a, AutocompleteHandler as c, InteractionHandler as d, RepliableHandler$1 as f, HttpServerConfig as g, HttpEdgeConfig as h, ModalHandler as i, ContextMenuHandler as l, HttpConfig as m, Gated as n, ButtonHandler as o, SlashOptions$1 as p, InteractionGateContext as r, ComponentHandler as s, version as t, SlashHandler as u, EngineContext as v, Core as y };
+//# sourceMappingURL=edge.index-CTOyjsO4.d.mts.map