@seedcord/core 0.1.0-next.1 → 0.1.0-next.2

package/dist/CustomId-Ddwg48VY.d.mts

@@ -0,0 +1,654 @@
+import { ActionRowBuilder, ButtonBuilder, ChannelSelectMenuBuilder, CheckboxBuilder, CheckboxGroupBuilder, CheckboxGroupOptionBuilder, ContainerBuilder, ContextMenuCommandBuilder, EmbedBuilder, FileBuilder, FileUploadBuilder, LabelBuilder, MediaGalleryBuilder, MentionableSelectMenuBuilder, ModalBuilder, RadioGroupBuilder, RadioGroupOptionBuilder, RoleSelectMenuBuilder, SectionBuilder, SeparatorBuilder, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, TextDisplayBuilder, TextInputBuilder, UserSelectMenuBuilder } from "@discordjs/builders";
+import { Snowflake } from "discord-api-types/v10";
+import { Config, IRateLimiter, RenderContext, ReplyResponse } from "@seedcord/types";
+
+//#region src/components/builderTypes.d.ts
+/**
+ * Available Discord.js builder classes for use with BuilderComponent for commands, embeds, modals, etc.
+ *
+ * @internal
+ */
+declare const BuilderTypes: {
+  command: typeof SlashCommandBuilder;
+  context_menu: typeof ContextMenuCommandBuilder;
+  subcommand: typeof SlashCommandSubcommandBuilder;
+  group: typeof SlashCommandSubcommandGroupBuilder;
+  embed: typeof EmbedBuilder;
+  modal: typeof ModalBuilder;
+  label: typeof LabelBuilder;
+  text_input: typeof TextInputBuilder;
+  file_upload: typeof FileUploadBuilder;
+  checkbox: typeof CheckboxBuilder;
+  checkbox_group: typeof CheckboxGroupBuilder;
+  checkbox_group_option: typeof CheckboxGroupOptionBuilder;
+  radio_group: typeof RadioGroupBuilder;
+  radio_group_option: typeof RadioGroupOptionBuilder;
+  button: typeof ButtonBuilder;
+  menu_string: typeof StringSelectMenuBuilder;
+  menu_option_string: typeof StringSelectMenuOptionBuilder;
+  menu_user: typeof UserSelectMenuBuilder;
+  menu_channel: typeof ChannelSelectMenuBuilder;
+  menu_mentionable: typeof MentionableSelectMenuBuilder;
+  menu_role: typeof RoleSelectMenuBuilder;
+  container: typeof ContainerBuilder;
+  text_display: typeof TextDisplayBuilder;
+  file: typeof FileBuilder;
+  media: typeof MediaGalleryBuilder;
+  section: typeof SectionBuilder;
+  separator: typeof SeparatorBuilder;
+};
+/**
+ * Available Discord.js action row classes for use with RowComponent for Select Menus and Buttons
+ *
+ * @internal
+ */
+declare const RowTypes: {
+  button: typeof ActionRowBuilder<ButtonBuilder>;
+  menu_string: typeof ActionRowBuilder<StringSelectMenuBuilder>;
+  menu_user: typeof ActionRowBuilder<UserSelectMenuBuilder>;
+  menu_channel: typeof ActionRowBuilder<ChannelSelectMenuBuilder>;
+  menu_mentionable: typeof ActionRowBuilder<MentionableSelectMenuBuilder>;
+  menu_role: typeof ActionRowBuilder<RoleSelectMenuBuilder>;
+};
+/**
+ * Available Discord.js builder types for use with BuilderComponent
+ */
+type BuilderType = keyof typeof BuilderTypes;
+/**
+ * @internal
+ */
+type InstantiatedBuilder<BuilderKey extends BuilderType> = InstanceType<(typeof BuilderTypes)[BuilderKey]>;
+/**
+ * Available Discord.js action row types for use with RowComponent
+ */
+type RowType = keyof typeof RowTypes;
+/**
+ * @internal
+ */
+type InstantiatedActionRow<RowKey extends RowType> = InstanceType<(typeof RowTypes)[RowKey]>;
+//#endregion
+//#region src/components/Component.d.ts
+/**
+ * Base class for Discord component wrappers.
+ *
+ * @typeParam TComponent - The Discord.js component type being wrapped
+ *
+ * @internal
+ */
+declare abstract class BaseComponent<TComponent> {
+  private readonly _component;
+  protected constructor(ComponentClass: new () => TComponent);
+  /**
+   * Returns the live builder, ready to send in a Discord message or nest in another component.
+   *
+   * Configure it through `this.instance`. Reading this can apply the bot color (see
+   * {@link BuilderComponent}), so it has a side effect.
+   * @example new SomeComponent().component
+   */
+  abstract get component(): InstantiatedBuilder<BuilderType> | InstantiatedActionRow<RowType>;
+  /**
+   * The wrapped builder, for calling Discord.js methods like setTitle() and setDescription() inside a subclass.
+   *
+   * @example this.instance.setTitle('My Modal')
+   */
+  protected get instance(): TComponent;
+}
+/**
+ * Base class for Discord.js builder components
+ *
+ * Wraps Discord.js builders (SlashCommandBuilder, EmbedBuilder, etc.) with
+ * Seedcord-specific defaults and helper methods.
+ *
+ * @typeParam BuilderKey - The type of Discord.js builder being wrapped
+ */
+declare abstract class BuilderComponent<BuilderKey extends BuilderType> extends BaseComponent<InstantiatedBuilder<BuilderKey>> {
+  readonly type: BuilderKey;
+  private colorApplied;
+  protected constructor(type: BuilderKey);
+  get component(): InstantiatedBuilder<BuilderKey>;
+  private applyBotColor;
+}
+/**
+ * Base class for Discord action row components
+ *
+ * Wraps Discord.js action row builder with Seedcord-specific defaults and helper methods.
+ *
+ * @typeParam RowKey - The Discord.js action row type being wrapped
+ */
+declare abstract class RowComponent<RowKey extends RowType> extends BaseComponent<InstantiatedActionRow<RowKey>> {
+  readonly type: RowKey;
+  protected constructor(type: RowKey);
+  get component(): InstantiatedActionRow<RowKey>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/basic.d.ts
+/**
+Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Class
+*/
+type Constructor<T, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/non-empty-tuple.d.ts
+/**
+Matches any non-empty tuple.
+
+@example
+```
+import type {NonEmptyTuple} from 'type-fest';
+
+const sum = (...numbers: NonEmptyTuple<number>) => numbers.reduce((total, value) => total + value, 0);
+
+sum(1, 2, 3);
+// Ok
+
+// @ts-expect-error
+sum();
+// Error: Expected at least 1 arguments, but got 0.
+```
+
+@see {@link RequireAtLeastOne} for objects
+
+@category Array
+*/
+type NonEmptyTuple<T = unknown> = readonly [T, ...T[]];
+//#endregion
+//#region src/decorators/Command.d.ts
+type CommandCtor = Constructor<BuilderComponent<'command' | 'context_menu'>>;
+interface GlobalMeta {
+  scope: 'global';
+}
+interface GuildMeta {
+  scope: 'guild';
+  guilds: string[];
+}
+type CommandMeta = GlobalMeta | GuildMeta;
+/**
+ * Attaches deployment metadata so the framework registers this command globally or in specific guilds.
+ *
+ * @param scope - Must be 'global' for global registration
+ * @decorator
+ * @example
+ * ```typescript
+ * \@RegisterCommand('global')
+ * class PingCommand extends BuilderComponent<'command'> {} // or BuilderComponent<'context_menu'>
+ * ```
+ */
+declare function RegisterCommand(scope: 'global'): (ctor: CommandCtor) => void;
+/**
+ * Registers a command for specific guild deployment.
+ *
+ * @param scope - Must be 'guild' for guild-specific registration
+ * @param guilds - Array of guild IDs where the command should be registered
+ * @decorator
+ * @example
+ * ```typescript
+ * \@RegisterCommand('guild', ['123456789'])
+ * class AdminCommand extends BuilderComponent<'command'> {} // or BuilderComponent<'context_menu'>
+ * ```
+ */
+declare function RegisterCommand(scope: 'guild', guilds: string[]): (ctor: CommandCtor) => void;
+//#endregion
+//#region src/interfaces/CoreBase.d.ts
+/**
+ * The transport-agnostic slice of the running framework, what core code (gates, notices, plugins'
+ * agnostic surface) accesses through `ctx.core`. Each transport's `Core` extends it, the gateway
+ * adds `bot` and `bus`.
+ */
+interface CoreBase {
+  /** Transports narrow this to their own config type. */
+  readonly config: Config;
+  /** Sliding-window rate limiting, the `Cooldown` gate's backend and a public direct-use API. */
+  readonly rateLimiter: IRateLimiter;
+}
+//#endregion
+//#region src/gates/Gate.d.ts
+/**
+ * The transport-agnostic gate context, the scalar identity of the acting user resolvable from any
+ * transport's payload. Every field except `core` is nullable, since an event or DM may carry no
+ * guild or member. Each transport extends it with its own rich arm. For e.g., the gateway adds the djs
+ * `user`/`guild`/`member` objects and the live interaction or event payload.
+ *
+ * @example
+ * ```ts
+ * // a gate reading only the base fields fits any handler on any transport
+ * const NeedsGuild = defineGate('NeedsGuild', (ctx: GateContextBase) => {
+ *     if (!ctx.guildId) throw new NotInGuild();
+ * });
+ * ```
+ */
+interface GateContextBase {
+  /** Gates read the config and the rate limiter through it. */
+  readonly core: CoreBase;
+  /** The acting user's id, or null on an event that carries none. */
+  readonly userId: string | null;
+  /** The guild id, or null outside a guild. */
+  readonly guildId: string | null;
+  /** The channel id, or null when the source carries none. */
+  readonly channelId: string | null;
+  /**
+   * The acting member's role ids without the everyone role, the shape a raw interaction payload
+   * carries. Empty outside a guild or when the source carries none.
+   */
+  readonly memberRoleIds: readonly string[];
+  /**
+   * The acting member's permission bits, or null outside a guild. On an interaction these are the
+   * channel-scoped permissions the payload carries, on a gateway event the member's guild-level ones.
+   */
+  readonly memberPermissions: bigint | null;
+}
+declare const GateBrand: unique symbol;
+/**
+ * A precondition attached to a handler. It refuses by throwing a `Notice` (a reply) or a `Silence`
+ * (a drop with no reply), and passes by returning. `Ctx` is the context it requires, so a gate that reads
+ * a field absent on a handler's context is rejected at compile time. `Name` is captured as a literal so
+ * a mismatch error can name the gate. Build one with {@link defineGate} or {@link defineEffectGate}.
+ *
+ * @typeParam Ctx - The context the gate requires, so reading a field absent on a handler's context is a compile error.
+ * @typeParam Name - The gate's name captured as a literal, so a mismatch error can name the gate.
+ *
+ * @example
+ * ```ts
+ * // a factory returning a typed, agnostic gate
+ * function MyGate(): Gate<GateContextBase, 'MyGate'> {
+ *     return defineGate('MyGate', (ctx) => {
+ *         if (shouldRefuse(ctx)) throw new MyNotice();
+ *     });
+ * }
+ * ```
+ *
+ * @see {@link defineGate}
+ */
+interface Gate<Ctx extends GateContextBase = GateContextBase, Name extends string = string> {
+  /** The gate's name, surfaced in a mismatch error and joined by the combinators. */
+  readonly name: Name;
+  /** Reads the context and refuses by throwing a Notice or a Silence, or passes by resolving. */
+  check(ctx: Ctx): Promise<void>;
+  /** @internal */
+  readonly [GateBrand]: true;
+}
+/**
+ * A gate that carries a side effect, split so the effect fires only once the gate is the one that
+ * let the request through. `check` peeks and refuses, `commit` applies the effect after the whole
+ * gate set passes. {@link Cooldown} is the catalog gate that returns one. Build one with
+ * {@link defineEffectGate}.
+ *
+ * @typeParam Ctx - The context the gate requires, so reading a field absent on a handler's context is a compile error.
+ * @typeParam Name - The gate's name captured as a literal, so a mismatch error can name the gate.
+ *
+ * @example
+ * ```ts
+ * // a factory returning a typed effect gate
+ * function MyEffectGate(): EffectGate<GateContextBase, 'MyEffectGate'> {
+ *     return defineEffectGate(
+ *         'MyEffectGate',
+ *         (ctx) => {
+ *             if (shouldRefuse(ctx)) throw new MyNotice();
+ *         },
+ *         (ctx) => {
+ *             applyMyEffect(ctx);
+ *         }
+ *     );
+ * }
+ * ```
+ *
+ * @see {@link defineEffectGate}
+ */
+interface EffectGate<Ctx extends GateContextBase = GateContextBase, Name extends string = string> extends Gate<Ctx, Name> {
+  /** Applies the side effect, run only after the whole gate set passes. */
+  commit(ctx: Ctx): Promise<void>;
+}
+/**
+ * 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, so a mismatch error can name the gate.
+ * @typeParam Ctx - The context the check reads, inferred from the `ctx` annotation.
+ *
+ * @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 `seedcord`
+ *
+ * @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
+ * // agnostic gate (no ctx annotation): fits any handler
+ * const Owner = defineGate('owner', (ctx) => {
+ *     if (!ctx.userId) throw new NotOwner();
+ * });
+ * ```
+ */
+declare function defineGate<const Name extends string, Ctx extends GateContextBase = GateContextBase>(name: Name, fn: (ctx: Ctx) => void | Promise<void>): Gate<Ctx, Name>;
+/**
+ * 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`, a refusing arm's queued commit is rolled back. This is how {@link Cooldown} peeks
+ * in `check` and charges the slot in `commit`.
+ *
+ * @typeParam Name - The gate's name captured as a literal, so a mismatch error can name the gate.
+ * @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.
+ *
+ * @see {@link defineGate}
+ * @see the `@Gated` decorator from `seedcord`
+ * @see {@link Cooldown}
+ *
+ * @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);
+ *         }
+ *     );
+ * }
+ * ```
+ */
+declare function defineEffectGate<const Name extends string, Ctx extends GateContextBase = GateContextBase>(name: Name, check: (ctx: Ctx) => void | Promise<void>, commit: (ctx: Ctx) => void | Promise<void>): EffectGate<Ctx, Name>;
+/**
+ * The context a {@link Gate} requires.
+ *
+ * @typeParam TGate - The gate type to read the required context from.
+ *
+ * @example
+ * ```ts
+ * type OwnerCtx = RequiredOf<ReturnType<typeof OwnerOnly>>; // GateContextBase
+ * ```
+ */
+type RequiredOf<TGate> = TGate extends Gate<infer Ctx> ? Ctx : never;
+//#endregion
+//#region src/stops/Notice.d.ts
+/**
+ * Base class for a user-facing refusal or a reported fault.
+ *
+ * Throw a `Notice` to stop a handler and reply to the user. The framework catches it at the controller
+ * boundary and renders {@link Notice.render}, which always decides what the user sees. With `report`
+ * false that render is all that happens. With `report` true the framework also logs the fault and
+ * publishes it to the `handledException` bus. A raw, non-Notice throw shows the generic message.
+ *
+ * @example
+ * ```ts
+ * import { Notice, BuilderComponent, type RenderContext, type ReplyResponse } from 'seedcord';
+ * import { TextDisplayBuilder } from '@discordjs/builders';
+ *
+ * // reading `.component` applies the configured bot color to the container accent
+ * class TooPoorCard extends BuilderComponent<'container'> {
+ *     constructor(balance: number) {
+ *         super('container');
+ *         this.instance.addTextDisplayComponents(
+ *             new TextDisplayBuilder().setContent(`### Insufficient balance\nYou need more than ${balance} coins.`)
+ *         );
+ *     }
+ * }
+ *
+ * class TooPoor extends Notice {
+ *     constructor(private readonly balance: number) {
+ *         super(`balance ${balance} is below the cost`);
+ *     }
+ *
+ *     render(_ctx: RenderContext): ReplyResponse {
+ *         return { components: [new TooPoorCard(this.balance).component] };
+ *     }
+ * }
+ *
+ * // in a handler, throwing stops the handler and replies with render(ctx)
+ * if (wallet.balance < cost) throw new TooPoor(wallet.balance);
+ * ```
+ */
+declare abstract class Notice extends Error {
+  /**
+   * Whether this denial is a reported fault. True also logs it and publishes it to the `handledException`
+   * bus. The user always sees {@link Notice.render} either way.
+   *
+   * @defaultValue `false`
+   */
+  report: boolean;
+  /**
+   * Whether the reply is ephemeral, so only the invoking user sees it. Set it false for a refusal the
+   * whole channel should see.
+   *
+   * @defaultValue `true`
+   */
+  ephemeral: boolean;
+  /**
+   * A short one-line reason. When every arm of an `or` gate refuses and each refusal sets this, `or`
+   * lists them instead of showing a neutral message.
+   */
+  summary?: string;
+  protected constructor(message: string, options?: ErrorOptions);
+  /**
+   * Builds what the user sees. Called fresh each time the denial is shown, so the builders are new
+   * and the bot color resolves at render time rather than at construction time.
+   */
+  abstract render(ctx: RenderContext): ReplyResponse;
+}
+//#endregion
+//#region src/gates/matching.d.ts
+type IntersectRequired<Gates extends readonly Gate<GateContextBase>[]> = Gates extends readonly [infer First extends Gate<GateContextBase>, ...infer Rest extends readonly Gate<GateContextBase>[]] ? RequiredOf<First> & IntersectRequired<Rest> : unknown;
+type TwoOrMore<Item> = readonly [Item, Item, ...Item[]];
+type GateName<TGate> = TGate extends Gate<GateContextBase, infer Name> ? Name : string;
+type JoinNames<Gates extends readonly Gate<GateContextBase>[], Sep extends string> = Gates extends readonly [infer Only extends Gate<GateContextBase>] ? GateName<Only> : Gates extends readonly [infer First extends Gate<GateContextBase>, ...infer Rest extends readonly Gate<GateContextBase>[]] ? `${GateName<First>}${Sep}${JoinNames<Rest, Sep>}` : string;
+type GateMismatch<Name extends string, Want extends string, Got extends string> = `gate '${Name}' wants a ${Want} handler but this handler is ${Got}`;
+type GateFitsWith<Provided, ProvidedLabel extends string, TGate, ReqLabel extends string> = [Provided] extends [RequiredOf<TGate>] ? TGate : Constructor<[GateMismatch<GateName<TGate>, ReqLabel, ProvidedLabel>]>;
+//#endregion
+//#region src/gates/catalog/options.d.ts
+/**
+ * The override a catalog gate accepts, a one-line `message` reword or a full `notice` replacement. Accepted by
+ * the agnostic gates ({@link OwnerOnly}, {@link GuildOnly}, {@link DmOnly}, {@link Cooldown}) and the gateway's
+ * `RequireRole` and `Nsfw`. The gateway's `RequirePermissions` and `RequireBotPermissions` take
+ * `RequirePermissionsOptions` instead.
+ *
+ * @example
+ * ```ts
+ * // reword the default refusal
+ * OwnerOnly({ message: 'Bot owners only.' });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // replace the refusal entirely, for example a translated Notice
+ * GuildOnly({ notice: new MyTranslatedNotice() });
+ * ```
+ */
+interface GateNoticeOptions {
+  /** Reword the default refusal, keeping its embed styling. */
+  message?: string;
+  /** Replace the default refusal Notice entirely, for full control or a translated copy. */
+  notice?: Notice;
+}
+declare function pickNotice(options: GateNoticeOptions | undefined, makeDefault: (message?: string) => Notice): Notice;
+//#endregion
+//#region src/customId/Field.d.ts
+/**
+ * One field in a customId shape, its wire kind plus the type it decodes to.
+ *
+ * @internal
+ */
+interface CustomIdField<Decoded> {
+  /** Which wire encoding this field uses. */
+  readonly kind: 'snowflake' | 'uuid' | 'int' | 'bool' | 'oneOf' | 'string';
+  /** Lower bound, for a bounded int field. */
+  readonly min?: number;
+  /** Upper bound, for a bounded int field. */
+  readonly max?: number;
+  /** The allowed values, for a oneOf field. */
+  readonly choices?: readonly string[];
+  /** Phantom only, carries the decoded type and is never set at runtime. */
+  readonly decoded?: Decoded;
+}
+/**
+ * The set of fields a customId carries, keyed by name.
+ *
+ * @internal
+ */
+type CustomIdShape = Record<string, CustomIdField<unknown>>;
+/**
+ * The decoded result, each field name mapped to its decoded type.
+ *
+ * @internal
+ */
+type DecodedParams<Shape extends CustomIdShape> = { [Name in keyof Shape]: Shape[Name] extends CustomIdField<infer Decoded> ? Decoded : never };
+//#endregion
+//#region src/customId/CustomId.d.ts
+/** Strip the layout hash off the routeKey to recover the stable prefix the controller routes by. @internal */
+declare function prefixOf(wire: string): string;
+/**
+ * A typed customId. The single source of truth shared by the component that mints it and the handler
+ * that reads it. This gives you typed reads on the `.customId` field in components. Values are packed into a compact wire string rather than plain stringified tokens, so the 100-char Discord limit goes further. More string per string, basically.
+ *
+ * @typeParam Prefix - The stable route prefix, e.g. 'approve'.
+ * @typeParam Shape - The accumulated fields, filled in by the chain.
+ *
+ * @example
+ * ```ts
+ * const ApproveId = new CustomId('approve')
+ *     .snowflake('userId')
+ *     .oneOf('action', ['approve', 'deny']);
+ *
+ * // Set the custom id on a button when creating it.
+ * new ButtonBuilder().setCustomId(ApproveId.encode({ userId: '123', action: 'approve' }));
+ *
+ * // reading in the handler: userId comes back a string
+ * const { userId, action } = this.params; // userId: string, action: 'approve' | 'deny'
+ * await this.event.guild?.members.fetch(userId);
+ * ```
+ */
+declare class CustomId<Prefix extends string, Shape extends CustomIdShape = {}> {
+  /** The stable route prefix, e.g. 'approve'. */
+  readonly prefix: Prefix;
+  /** Like a zod shape */
+  readonly shape: Shape;
+  /** The prefix plus a short hash of the shape, the part of the wire before the colon. */
+  readonly routeKey: string;
+  constructor(prefix: Prefix, shape?: Shape);
+  private add;
+  /**
+   * Add a Discord ID field, decoded as a string (the `Snowflake` type from discord-api-types).
+   *
+   * @example
+   * ```ts
+   * new CustomId('ban').snowflake('userId');
+   * ```
+   */
+  snowflake<Name extends string>(name: Name): CustomId<Prefix, Shape & Record<Name, CustomIdField<Snowflake>>>;
+  /**
+   * Add a UUID field, decoded as a lowercase uuid string.
+   *
+   * @example
+   * ```ts
+   * new CustomId('ticket').uuid('ticketId');
+   * ```
+   */
+  uuid<Name extends string>(name: Name): CustomId<Prefix, Shape & Record<Name, CustomIdField<string>>>;
+  /**
+   * Add an integer field with no bounds, for a value up to 2^53.
+   *
+   * @example
+   * ```ts
+   * new CustomId('shop').int('amount');
+   * ```
+   */
+  int<Name extends string>(name: Name): CustomId<Prefix, Shape & Record<Name, CustomIdField<number>>>;
+  /**
+   * Add an integer field bounded by min and max, so it packs into fewer characters on the wire.
+   *
+   * @example
+   * ```ts
+   * new CustomId('paginate').int('page', 1, 50);
+   * ```
+   */
+  int<Name extends string>(name: Name, min: number, max: number): CustomId<Prefix, Shape & Record<Name, CustomIdField<number>>>;
+  /**
+   * Add a boolean flag.
+   *
+   * @example
+   * ```ts
+   * new CustomId('settings').bool('silent');
+   * ```
+   */
+  bool<Name extends string>(name: Name): CustomId<Prefix, Shape & Record<Name, CustomIdField<boolean>>>;
+  /**
+   * Add a field that is one value from a fixed list, decoded as the literal union. No `as const` needed.
+   *
+   * @example
+   * ```ts
+   * new CustomId('poll').oneOf('choice', ['yes', 'no', 'abstain']);
+   * ```
+   */
+  oneOf<Name extends string, const Choices extends NonEmptyTuple<string>>(name: Name, choices: Choices): CustomId<Prefix, Shape & Record<Name, CustomIdField<Choices[number]>>>;
+  /**
+   * Add a free short text field. Avoid it where possible, it cannot be packed so it costs the most wire space.
+   *
+   * @example
+   * ```ts
+   * new CustomId('note').str('message');
+   * ```
+   */
+  str<Name extends string>(name: Name): CustomId<Prefix, Shape & Record<Name, CustomIdField<string>>>;
+  /**
+   * Mint a wire string from values. Throws if a value is out of its field's range or the wire is over 100 chars.
+   *
+   * @param values - One value per field, typed by the chain.
+   * @returns The wire string to put on the component's customId.
+   */
+  encode(values: DecodedParams<Shape>): string;
+  /**
+   * Read a wire string back into values.
+   *
+   * - This will refuse with a default Notice when the shape changed since the wire was minted.
+   * - Or refuse with a different default Notice on a corrupt or foreign wire.
+   *
+   * @param wire - The customId string from the interaction.
+   * @returns The decoded values, typed by the chain.
+   */
+  decode(wire: string): DecodedParams<Shape>;
+  /** True if this wire was minted from this customId's prefix, ignoring the shape hash. */
+  owns(wire: string): boolean;
+}
+/**
+ * Any customId, for places where the exact prefix and shape do not matter.
+ *
+ * @internal
+ */
+type AnyCustomId = CustomId<string, CustomIdShape>;
+/**
+ * The outcome of decoding a wire against several customIds, the matched prefix paired with its values.
+ *
+ * @internal
+ */
+type DecodedRoute<Defs extends readonly AnyCustomId[]> = { [Index in keyof Defs]: Defs[Index] extends AnyCustomId ? {
+  readonly prefix: Defs[Index]['prefix'];
+  readonly params: DecodedParams<Defs[Index]['shape']>;
+} : never }[number];
+/**
+ * Find the customId whose prefix owns this wire, decode against it, and report which one matched.
+ *
+ * @internal
+ */
+declare function decodeFor<Defs extends readonly AnyCustomId[]>(defs: Defs, wire: string): DecodedRoute<Defs>;
+//#endregion
+export { BuilderComponent as C, RowType as E, RegisterCommand as S, BuilderType as T, RequiredOf as _, CustomIdField as a, CoreBase as b, pickNotice as c, JoinNames as d, TwoOrMore as f, GateContextBase as g, Gate as h, prefixOf as i, GateFitsWith as l, EffectGate as m, CustomId as n, DecodedParams as o, Notice as p, decodeFor as r, GateNoticeOptions as s, AnyCustomId as t, IntersectRequired as u, defineEffectGate as v, RowComponent as w, CommandMeta as x, defineGate as y };
+//# sourceMappingURL=CustomId-Ddwg48VY.d.mts.map