@seedcord/core 0.12.0-next.0 → 0.12.0-next.2

package/dist/index.mjs

@@ -1,13 +1,13 @@
-import { A as serializeReply, B as contextMenuRouteOf, C as NotAllowed, D as OnCooldown, E as NotOwner, F as AckTrace, H as storeComponentRoute, I as checkAckLegality, L as sendTarget, M as attemptWrite, N as publishResponse, O as defineEffectGate, R as RegisterInteractionMiddleware, S as NeedsAny, T as NotInGuild, U as storeInteractionRoute, X as ContextMenus, Y as Commands, a as RequireBotPermissions, b as MissingPermissions, d as presentNames, f as pickNotice, ft as NoticeCard, g as runCheck, h as rollbackCommits, i as Silence, j as translateSerializationError, k as defineGate, l as hasAll, m as markCommits, n as pageCursor, o as RequirePermissions, pt as Notice, q as RegisterCommand, r as ResolvedEmoji, s as RequireRole, t as PAGE_MAX, u as missingNames, w as NotInDm, y as HasDangerousPermissions } from "./subscribers-D4_HZcgw.mjs";
-import { M as RowComponent, T as InteractionKind, _ as MemoryDriver, d as WebhookLog, f as Subscriber, j as BuilderComponent, l as WebhookUrl, t as Bus, u as Subscribe, v as ShutdownPhase, y as StartupPhase } from "./Bus-W1K-uMeO.mjs";
+import { D as InteractionKind, N as BuilderComponent, P as RowComponent, b as StartupPhase, d as WebhookLog, f as Subscriber, l as WebhookUrl, t as Bus, u as Subscribe, v as MemoryDriver, y as ShutdownPhase } from "./Bus-VJw-QpoY.mjs";
+import { A as RegisterInteractionMiddleware, B as RegisterCommand, C as attemptWrite, D as AckTrace, F as storeComponentRoute, H as Commands, I as storeInteractionRoute, M as contextMenuRouteOf, O as checkAckLegality, S as translateSerializationError, U as ContextMenus, _ as NotInGuild, at as Notice, b as PermissionsUnresolved, c as runCheck, d as HasPresentPermissions, f as MissingPermissions, g as NotInDm, h as NotAllowed, i as Silence, k as sendTarget, m as NeedsAny, n as pageCursor, o as markCommits, ot as NoticeCard, p as MissingRole, r as ResolvedEmoji, s as rollbackCommits, t as PAGE_MAX, u as Fault, v as NotOwner, w as publishResponse, x as serializeReply, y as OnCooldown } from "./subscribers-CGuVjbrg.mjs";
 import "reflect-metadata";
 import { CustomId, decodeFor, prefixOf, setCustomIdErrors, setCustomIdErrors as setCustomIdErrors$1 } from "@seedcord/custom-id";
 import { ActionRowBuilder, ButtonBuilder, TextDisplayBuilder } from "@discordjs/builders";
-import { ApplicationCommandType, ButtonStyle } from "discord-api-types/v10";
+import { ApplicationCommandType, ButtonStyle, PermissionFlagsBits } from "discord-api-types/v10";
 import { SeedcordErrorCode } from "@seedcord/errors";
 import { SeedcordError, SeedcordRangeError, SeedcordTypeError } from "@seedcord/errors/internal";
 import { Logger } from "@seedcord/logger";
-import { parseDuration } from "@seedcord/utils";
+import { parseDuration, prettify } from "@seedcord/utils";
 
 //#region src/customId/Errors.ts
 /**
@@ -47,8 +47,8 @@ setCustomIdErrors$1({
 /**
 * Routes one or more slash commands to a `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. Listing
+* Pass the same route string(s) as the handler's generic. On a handler for one command, read
+* `this.options`. On a handler for several, branch with `this.match`. The decorator routes and the generic must match exactly. 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'`.
@@ -72,7 +72,7 @@ function SlashRoute(...routes) {
 * Routes one or more commands' autocomplete to an `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
+* over its autocompletable fields, several commands share one handler whose cases span every command's
 * fields. Listing fewer or more commands than the handler declares is a compile error, since the
 * decorator routes and the generic must match exactly.
 *
@@ -174,7 +174,7 @@ function ModalRoute(...defs) {
 * Routes string select menu interactions to a `StringMenuHandler`.
 *
 * Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
-* generic. The handler reads the chosen option values from `this.values`.
+* generic. Read the chosen option values from `this.values`.
 *
 * @param defs - The customId definition(s) this handler decodes, one per route.
 * @decorator
@@ -289,38 +289,6 @@ function MentionableMenuRoute(...defs) {
 	};
 }
 
-//#endregion
-//#region src/dispatch/DispatchContext.ts
-/** State shared by middleware and handlers during one dispatch. */
-var DispatchContext = class {
-	state = Object.create(null);
-	id = crypto.randomUUID();
-	/**
-	* The dispatch identifier, such as `slash:search/docs`, `button:approve`, or `event:messageCreate`.
-	* Component identifiers contain the custom-ID prefix without encoded params.
-	*/
-	routeId;
-	constructor(routeId) {
-		this.routeId = routeId;
-	}
-	set(key, value) {
-		this.state[key] = value;
-	}
-	get(key) {
-		return this.state[key];
-	}
-	/**
-	* Read a key that must be present, with `undefined` stripped from the result.
-	*
-	* @throws A **SeedcordError** when nothing set the key on this dispatch.
-	*/
-	require(key) {
-		const value = this.state[key];
-		if (value === void 0) throw new SeedcordError(SeedcordErrorCode.DispatchStateMissing, [String(key)]);
-		return value;
-	}
-};
-
 //#endregion
 //#region src/handlers/BaseHandler.ts
 /**
@@ -336,11 +304,14 @@ var BaseHandler = class {
 	logger;
 	/** The bag for this dispatch. Each interaction gets its own. Every handler for one event shares a single bag. */
 	dispatch;
+	/** The route that started this dispatch. Each handler base narrows it to its own routes. */
+	route;
 	constructor(event, core, dispatch, channel) {
 		this.core = core;
 		this.event = event;
 		this.logger = new Logger(this.constructor.name, { channel });
 		this.dispatch = dispatch;
+		this.route = dispatch.route;
 	}
 };
 
@@ -348,7 +319,7 @@ var BaseHandler = class {
 //#region src/handlers/RepliableHandler.ts
 /**
 * Shared base the repliable handlers on both transports extend. Defines the reply members over one sender.
-* A handler builds its own through `buildSender`. A middleware takes the handler's.
+* The dispatch run builds that sender and passes it to the handler and each middleware.
 *
 * @typeParam Event - The repliable interaction type this handler processes
 * @typeParam TCore - The transport's Core
@@ -361,7 +332,7 @@ var RepliableHandler = class extends BaseHandler {
 	sender;
 	constructor(event, core, dispatch, sender) {
 		super(event, core, dispatch, "interactions");
-		this.sender = sender ?? this.buildSender(event, core, dispatch);
+		this.sender = sender;
 	}
 	/** Send the initial response, exactly once. */
 	reply(response, opts) {
@@ -557,44 +528,88 @@ var BaseReplySender = class {
 };
 
 //#endregion
-//#region src/stops/Fault.ts
+//#region src/gates/Gate.ts
 /**
-* A generic fault you throw after catching an error you do not have a specific message for.
+* Builds a {@link Gate} from a check. The check refuses by throwing a Notice or a Silence and passes
+* by returning. The required context is inferred from `ctx`, so annotate it as narrowly as the fields
+* the check reads. No annotation defaults to {@link GateContextBase}, an agnostic gate that fits every
+* handler.
+*
+* @typeParam Name - The gate's name, captured as a literal for mismatch errors.
+* @typeParam Ctx - The context the check reads, inferred from the `ctx` annotation.
 *
-* The user sees a fixed generic reply with the tracking uuid, never the cause. `report` defaults to
-* `true`, so the framework logs it and publishes it to the `handledException` bus. Pass `report: false`
-* to show the generic reply without the bus publish. The original error is stored as the standard
-* `cause`, so the real stack reaches the webhook. When the user should see a real message for a fault,
-* subclass {@link Notice} and write your own `render` instead.
+* @param name - The gate's name, used in mismatch errors.
+* @param fn - The check, which refuses by throwing a Notice or a Silence and passes by returning.
+*
+* @see {@link defineEffectGate}
+* @see the `@Gated` decorator from your transport package
 *
-* The framework also renders this for an unhandled throw, where it points the user at
-* `ctx.developerUsername`.
+* @example
+* ```ts
+* // a gate factory that takes its own option and closes over it
+* function MinRoles(min: number): Gate<GateContextBase, 'MinRoles'> {
+*     return defineGate('MinRoles', (ctx) => {
+*         if (ctx.memberRoleIds.length < min) throw new NotEnoughRoles(min);
+*     });
+* }
+* ```
 *
 * @example
 * ```ts
-* import { Fault } from '@seedcord/gateway';
+* // agnostic gate (no ctx annotation): fits any handler
+* const Owner = defineGate('owner', (ctx) => {
+*     if (!ctx.userId) throw new NotOwner();
+* });
+* ```
+*/
+function defineGate(name, fn) {
+	return {
+		name,
+		check: async (ctx) => fn(ctx)
+	};
+}
+/**
+* Builds an {@link EffectGate} from a `check` and a `commit`. `check` peeks and refuses by throwing, and
+* `commit` applies the side effect, running only once the whole gate set passes so a later refusal never
+* commits. In an `or`, seedcord rolls back the commit a refusing gate queued. This is how {@link Cooldown} peeks
+* in `check` and charges the slot in `commit`.
+*
+* @typeParam Name - The gate's literal name, used to name a mismatch error.
+* @typeParam Ctx - The context both `check` and `commit` read, inferred from the `ctx` annotation.
+*
+* @param name - The gate's name, used in mismatch errors.
+* @param check - Peeks and refuses by throwing, without applying the side effect.
+* @param commit - Applies the side effect, running only after the whole gate set passes.
 *
-* try {
-*     await db.write(record);
-* } catch (cause) {
-*     // user sees the generic reply with the uuid, and the real error rides along as cause for the webhook
-*     throw new Fault({ cause });
+* @see {@link defineGate}
+* @see the `@Gated` decorator from your transport package
+* @see {@link Cooldown}
 *
-*     // pass report: false to show the same reply without publishing to the handledException bus
-*     // throw new Fault({ cause, report: false });
+* @example
+* ```ts
+* // an effect-gate factory that takes its own limit and closes over it
+* function UsesPerDay(max: number): EffectGate<GateContextBase, 'UsesPerDay'> {
+*     return defineEffectGate(
+*         'UsesPerDay',
+*         (ctx) => {
+*             // peek and refuse by throwing. do not mutate yet
+*             if (usedToday(ctx.userId) >= max) throw new OutOfUsesNotice(max);
+*         },
+*         (ctx) => {
+*             // runs only after the whole gate set passes
+*             recordUse(ctx.userId);
+*         }
+*     );
 * }
 * ```
 */
-var Fault = class extends Notice {
-	constructor(options) {
-		super("A fault occurred", options?.cause === void 0 ? void 0 : { cause: options.cause });
-		this.report = options?.report ?? true;
-	}
-	render(ctx) {
-		const contact = ctx.developerUsername ?? "the developer";
-		return { components: [new NoticeCard(`Something went wrong. Please reach out to ${contact} with a way to reproduce the error and the following:\n### UUID: \`${ctx.uuid}\``, "Error").component] };
-	}
-};
+function defineEffectGate(name, check, commit) {
+	return {
+		name,
+		check: async (ctx) => check(ctx),
+		commit: async (ctx) => commit(ctx)
+	};
+}
 
 //#endregion
 //#region src/gates/combinators.ts
@@ -643,9 +658,9 @@ function or(...args) {
 /**
 * Passes only for a user id listed in `config.ownerIds`, else refuses.
 *
-* Agnostic, so it attaches to interaction and event handlers alike. With no `ownerIds` configured it refuses every caller. Pass {@link GateNoticeOptions} to reword or replace the refusal.
+* Agnostic, so it attaches to interaction and event handlers alike. With no `ownerIds` configured it refuses every caller. Pass a Notice class as `notice` to replace the refusal.
 *
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
+* @param options - Replace the refusal with a Notice class as `notice`.
 *
 * @see the `@Gated` decorator from your transport package
 *
@@ -662,15 +677,15 @@ function or(...args) {
 *
 * @example
 * ```ts
-* // reword the refusal, keeping the embed styling
-* OwnerOnly({ message: 'Owners only.' });
+* // OwnersOnly is your own Notice class
+* OwnerOnly({ notice: OwnersOnly });
 * ```
 */
 function OwnerOnly(options) {
 	return defineGate("OwnerOnly", (ctx) => {
 		const owners = ctx.core.config.ownerIds ?? [];
 		if (ctx.userId !== null && owners.includes(ctx.userId)) return;
-		throw pickNotice(options, (message) => new NotOwner(message));
+		throw new ((options?.notice) ?? NotOwner)();
 	});
 }
 /**
@@ -678,7 +693,7 @@ function OwnerOnly(options) {
 *
 * Agnostic. Attaches to any handler kind. Often paired with `RequirePermissions` in an {@link and}.
 *
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
+* @param options - Replace the refusal with a Notice class as `notice`.
 *
 * @see the `@Gated` decorator from your transport package
 *
@@ -698,7 +713,7 @@ function OwnerOnly(options) {
 function GuildOnly(options) {
 	return defineGate("GuildOnly", (ctx) => {
 		if (ctx.guildId) return;
-		throw pickNotice(options, (message) => new NotInGuild(message));
+		throw new ((options?.notice) ?? NotInGuild)();
 	});
 }
 /**
@@ -706,7 +721,7 @@ function GuildOnly(options) {
 *
 * Agnostic, fitting any handler kind. The inverse of {@link GuildOnly}, so combining the two in an {@link and} can never pass.
 *
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
+* @param options - Replace the refusal with a Notice class as `notice`.
 *
 * @see the `@Gated` decorator from your transport package
 *
@@ -724,7 +739,7 @@ function GuildOnly(options) {
 function DmOnly(options) {
 	return defineGate("DmOnly", (ctx) => {
 		if (!ctx.guildId) return;
-		throw pickNotice(options, (message) => new NotInDm(message));
+		throw new ((options?.notice) ?? NotInDm)();
 	});
 }
 
@@ -742,10 +757,10 @@ function scopeValue(ctx, per) {
 * so a later refusal never burns the cooldown.
 * That split also means two requests racing the same key can both pass before either charges the slot.
 * The key combines the handler's route with the window settings, keeping two different handlers on separate
-* windows. Reword the refusal with {@link CooldownOptions.message} or replace it with {@link CooldownOptions.notice}.
+* windows. Replace the refusal with {@link CooldownOptions.notice}.
 *
 * @param duration - A number is seconds, and a string is a duration like `30m` or `24h`.
-* @param options - Sets the scope with `per`, the uses per window with `limit`, and the refusal text with `message` or `notice`.
+* @param options - Sets the scope with `per`, the uses per window with `limit`, and the refusal with `notice`.
 * @throws A **SeedcordTypeError** when `duration` is a string that doesn't parse.
 * @throws A **SeedcordRangeError** when `duration` is zero or negative.
 *
@@ -797,22 +812,46 @@ function Cooldown(duration, options) {
 		limit: options.limit
 	};
 	const anonId = anonSeq++;
-	const keyOf = (ctx) => `cooldown:${ctx.declaredRoute ?? `anon${anonId}`}:${per}:w${windowMs}:l${options?.limit ?? 1}:${scopeValue(ctx, per)}`;
+	const keyOf = (ctx) => `cooldown:${ctx.dispatch.declaredRoute ?? `anon${anonId}`}:${per}:w${windowMs}:l${options?.limit ?? 1}:${scopeValue(ctx, per)}`;
 	return defineEffectGate("Cooldown", async (ctx) => {
 		const result = await ctx.core.rateLimiter.peek(keyOf(ctx), window);
 		if (!result.limited) return;
-		if (options?.notice) throw options.notice(result.resetAt);
-		throw new OnCooldown(result.resetAt, options?.message?.(result.resetAt));
+		throw new ((options?.notice) ?? OnCooldown)(result.resetAt);
 	}, async (ctx) => {
 		await ctx.core.rateLimiter.charge(keyOf(ctx), window);
 	});
 }
 
+//#endregion
+//#region src/permissions/bits.ts
+const PermissionNames = new Map(Object.entries(PermissionFlagsBits).map(([key, bit]) => [bit, prettify(key)]));
+const ADMINISTRATOR = PermissionFlagsBits.Administrator;
+function nameOf(bit) {
+	return PermissionNames.get(bit) ?? String(bit);
+}
+function holds(held, bit) {
+	return (held & ADMINISTRATOR) === ADMINISTRATOR || (held & bit) === bit;
+}
+function namesWhere(held, scope, isHeld) {
+	return scope.reduce((names, bit) => {
+		if (holds(held, bit) === isHeld) names.push(nameOf(bit));
+		return names;
+	}, []);
+}
+/** @internal */
+function missingNames(held, scope) {
+	return namesWhere(held, scope, false);
+}
+/** @internal */
+function presentNames(held, scope) {
+	return namesWhere(held, scope, true);
+}
+
 //#endregion
 //#region src/permissions/assert.ts
 /**
 * Refuses when the subject is missing a permission in `scope`, or with `inverse` when it holds one.
-* The Administrator bit passes any scope, and on the inverse arm it reports every bit in `scope`.
+* The Administrator bit passes any scope, and with `inverse` it reports every bit in `scope`.
 *
 * The caller computes `permissions`, gateway off a discord.js role, member, or channel, and HTTP off the
 * bitfield the interaction payload carries.
@@ -857,14 +896,12 @@ function Cooldown(duration, options) {
 * ```ts
 * import { Notice } from '@seedcord/core';
 *
-* // a replacement notice takes the same three arguments the default one does
 * class CannotBan extends Notice {
 *     public constructor(
-*         message: string | undefined,
-*         private readonly subject: string,
+*         private readonly subject: string | null,
 *         private readonly missing: readonly string[]
 *     ) {
-*         super(message ?? 'You cannot ban here.');
+*         super('You cannot ban here.');
 *     }
 *
 *     public render(): ReplyResponse {
@@ -876,19 +913,97 @@ function Cooldown(duration, options) {
 *     subject: `<@${member.id}>`,
 *     permissions: member.permissions.bitfield,
 *     scope: [PermissionFlagsBits.BanMembers],
-*     missingNotice: CannotBan
+*     notice: CannotBan
 * });
 * ```
 */
-function assertPermissions(check) {
-	const { subject, permissions, scope, inverse = false, missingNotice, dangerousNotice } = check;
-	if (inverse) {
-		const present = presentNames(permissions, scope);
-		if (present.length === 0) return;
-		throw new (dangerousNotice ?? HasDangerousPermissions)(void 0, subject, present);
-	}
-	if (hasAll(permissions, scope)) return;
-	throw new (missingNotice ?? MissingPermissions)(void 0, subject, missingNames(permissions, scope));
+function assertPermissions({ subject, permissions, scope, inverse = false, notice }) {
+	const [refused, Default] = inverse ? [presentNames(permissions, scope), HasPresentPermissions] : [missingNames(permissions, scope), MissingPermissions];
+	if (refused.length === 0) return;
+	throw new (notice ?? Default)(subject, refused);
+}
+
+//#endregion
+//#region src/gates/catalog/permissions.ts
+const BOT_SUBJECT = "The bot";
+function requireHeld({ guildId, subject, readOrThrow }, scope, options) {
+	if (!guildId) throw new ((options?.notInGuild) ?? NotInGuild)();
+	const permissions = readOrThrow(guildId);
+	assertPermissions({
+		subject,
+		permissions,
+		scope,
+		notice: options?.missing
+	});
+}
+function botMemberMissing(guildId) {
+	throw new SeedcordError(SeedcordErrorCode.CoreBotMemberMissing, [guildId]);
+}
+function RequirePermissions(scope, options) {
+	const resolved = (held) => {
+		if (held === null) throw new ((options?.unresolved) ?? PermissionsUnresolved)();
+		return held;
+	};
+	if (options?.in === "guild") return defineGate("RequirePermissions", (ctx) => {
+		const readOrThrow = () => resolved(ctx.memberGuildPermissions);
+		requireHeld({
+			guildId: ctx.guildId,
+			subject: null,
+			readOrThrow
+		}, scope, options);
+	});
+	return defineGate("RequirePermissions", (ctx) => {
+		const readOrThrow = () => resolved(ctx.memberPermissions);
+		requireHeld({
+			guildId: ctx.guildId,
+			subject: null,
+			readOrThrow
+		}, scope, options);
+	});
+}
+function RequireBotPermissions(scope, options) {
+	if (options?.in === "guild") return defineGate("RequireBotPermissions", (ctx) => {
+		const readOrThrow = (guildId) => ctx.appGuildPermissions ?? botMemberMissing(guildId);
+		requireHeld({
+			guildId: ctx.guildId,
+			subject: BOT_SUBJECT,
+			readOrThrow
+		}, scope, options);
+	});
+	return defineGate("RequireBotPermissions", (ctx) => {
+		requireHeld({
+			guildId: ctx.guildId,
+			subject: BOT_SUBJECT,
+			readOrThrow: () => ctx.appPermissions
+		}, scope, options);
+	});
+}
+/**
+* Requires the caller to hold `roleId`, read from the member's role ids. Refuses outside a guild first,
+* then when the role is missing. Roles are guild-global, so there is no scope dimension.
+*
+* @param roleId - The role snowflake the caller must hold.
+* @param options - Replace a refusal with a Notice class as `notInGuild` or `missingRole`.
+*
+* @see the `@Gated` decorator from your transport package
+*
+* @example
+* ```ts
+* \@Gated(RequireRole('123456789012345678'))
+* \@SlashRoute('vip')
+* class VipHandler extends SlashHandler<'vip'> {
+*     async execute() {
+*         // ...
+*     }
+* }
+* ```
+*/
+function RequireRole(roleId, options) {
+	return defineGate("RequireRole", (ctx) => {
+		if (!ctx.guildId) throw new ((options?.notInGuild) ?? NotInGuild)();
+		if (ctx.memberRoleIds.includes(roleId)) return;
+		throw new ((options?.missingRole) ?? MissingRole)(roleId);
+	});
 }
 
 //#endregion
@@ -1255,8 +1370,8 @@ function buildKey(prefix, ...parts) {
 //#endregion
 //#region src/index.ts
 /** Package version */
-const version = "0.12.0-next.0";
+const version = "0.12.0-next.2";
 
 //#endregion
-export { ArraySourceBase, AutocompleteRoute, BaseHandler, BaseReplySender, BuilderComponent, Bus, ButtonRoute, ChannelMenuRoute, Commands, ContextMenus, Cooldown, CursorSourceBase, CustomId, DispatchContext, DmOnly, Fault, GuildOnly, InteractionKind, KeyvDriver, MemoryDriver, MentionableMenuRoute, MessageContextMenuRoute, ModalRoute, Notice, OwnerOnly, PaginatorBase, RegisterCommand, RegisterInteractionMiddleware, RepliableHandler, RequireBotPermissions, RequirePermissions, RequireRole, ResolvedEmoji, RoleMenuRoute, RowComponent, ShutdownPhase, Silence, SlashRoute, StartupPhase, StringMenuRoute, Subscribe, Subscriber, UnstorageDriver, UserContextMenuRoute, UserMenuRoute, WebhookLog, WebhookUrl, and, assertPermissions, buildKey, decodeFor, defineEffectGate, defineGate, mergeRoles, or, paginate, prefixOf, setCustomIdErrors, version };
+export { ArraySourceBase, AutocompleteRoute, BaseHandler, BaseReplySender, BuilderComponent, Bus, ButtonRoute, ChannelMenuRoute, Commands, ContextMenus, Cooldown, CursorSourceBase, CustomId, DmOnly, Fault, GuildOnly, InteractionKind, KeyvDriver, MemoryDriver, MentionableMenuRoute, MessageContextMenuRoute, ModalRoute, Notice, OwnerOnly, PaginatorBase, RegisterCommand, RegisterInteractionMiddleware, RepliableHandler, RequireBotPermissions, RequirePermissions, RequireRole, ResolvedEmoji, RoleMenuRoute, RowComponent, ShutdownPhase, Silence, SlashRoute, StartupPhase, StringMenuRoute, Subscribe, Subscriber, UnstorageDriver, UserContextMenuRoute, UserMenuRoute, WebhookLog, WebhookUrl, and, assertPermissions, buildKey, decodeFor, defineEffectGate, defineGate, mergeRoles, or, paginate, prefixOf, setCustomIdErrors, version };
 //# sourceMappingURL=index.mjs.map