{"version":3,"file":"index.d.ts","names":["APIInteractionGuildMember","ActionRowBuilder","ActivityType","BaseInteraction","ChatInputCommandInteraction","Client","ClientOptions","ContextMenuCommandInteraction","EmbedBuilder","GatewayIntentBits","GuildMember","LocaleString","Message","MessageFlags","Partials","PermissionsBitField","PermissionsString","RESTPostAPIApplicationCommandsJSONBody","RESTPostAPIChatInputApplicationCommandsJSONBody","RESTPostAPIContextMenuApplicationCommandsJSONBody","ShardingManager","User","Constructor$1","Array","T","ExecutionContext","Readonly","SpraxiumGuard","Promise","ReadonlyContainer","GuardEntry","Record","PrefixCommandConfig","PrefixCommandHandlerMetadata","PrefixArgType","PrefixArgValidation","RegExp","PrefixArgMetadata","PrefixGuildEntry","PrefixGuildProvider","PrefixConfig","SlashI18nKeys","SlashCommandConfig","SlashCommandHandlerMetadata","ContextMenuCommandType","ContextMenuCommandConfig","ContextMenuCommandHandlerMetadata","AutoDeferOptions","ResolvedContextMenuCommand","ResolvedContextMenuHandler","ResolvedContextMenuEntry","ContextMenuDispatcher","Map","PrefixGuildManager","ParsedPrefixMessage","PrefixSubcommandInfo","PrefixCommandInfo","PrefixSubcommandEntry","ResolvedPrefixCommand","ResolvedPrefixEntry","ResolvedPrefixHandler","PrefixRegistry","ReadonlyArray","PrefixBinder","PrefixDispatcher","ResolvedSlashCommand","ResolvedSlashHandler","ResolvedSlashEntry","ResolvedAutocompleteHandler","SlashLocalizationMap","Partial","SlashLocalizationResult","SlashRegistry","Set","ReadonlyMap","SlashRegistrar","SlashDispatcher","ReturnType","SlashLocalizationProvider","SlashLocalizationBridge","SpraxiumContainer","ModuleLoader","ActivityOptions","PresenceOptions","Pick","ShardOptions","ApplicationState","SpraxiumOptions","Omit","ShardEvalContext","ShardStatus","ShardActivityProps","PresenceStatus","NonNullable","ShardOverride","IntentPreset","resolveIntents","ParentHook","SpraxiumApplication","SpraxiumFactory","ClientFactory","ParentHookRegistry","PresenceManager","SpraxiumShardManager","isShardChild","ACTIVITY_TYPE_MAP","DEFAULT_PARTIALS","ALL_NON_PRIVILEGED_INTENTS","PRIVILEGED_INTENTS","DEFAULT_SPAWN_DELAY","BuiltInLogLevel","LogLevel","LogColor","LogColorInput","CustomLogLevel","EmbedFooterTemplate","EmbedThumbnailTemplate","EmbedFieldTemplate","DiscordEmbedTemplate","DiscordTransportConfig","TimestampFormat","Date","SpraxiumLoggerConfig","ExceptionLayoutClass","LayoutFn","SpraxiumException","ExceptionLayoutPayload","SpraxiumExceptionOptions","Error","InteractionFlag","Ephemeral","SuppressEmbeds","SuppressNotifications","IsComponentsV2","ExceptionLayout","ExceptionLayoutMap","ExceptionOptions","SpraxiumPlugin","N","C","PluginFactory","SpraxiumDevConfig","SpraxiumCoreConfig","ConfigEnv","SpraxiumConfigInput","SpraxiumConfigFn","SpraxiumConfigExport","defineConfig","definePlugin","ConfigStore","ConfigLoader","SpraxiumExecutionContext","LayoutRegistry","ExceptionHandler","defineExceptionLayout","DefaultExceptionLayout","ArgumentException","CommandNotFoundException","ConfigurationException","CooldownException","DMOnlyException","GuardDeniedException","GuildOnlyException","InternalException","MaintenanceException","NsfwOnlyException","OwnerOnlyException","PermissionDeniedException","PremiumOnlyException","RateLimitException","ValidationException","GuardRegistry","GuardExecutor","GuildOnly","DMOnly","OwnerOnly","PermissionGuard","RoleGuard","CooldownGuard","NSFWGuard","NoBotGuard","ThreadOnlyGuard","VoiceChannelGuard","Constructor","ResolvedListenerEntry","ListenerDispatcher","spraxiumError","spraxiumFatal","PatchableInteraction","installAutoDefer","APIInteractionGuildMember","BaseInteraction","ChatInputCommandInteraction","Client","ClientEvents","Events","GuildMember","Message","PermissionsBitField","User","METADATA_KEYS","Constructor","Array","T","ModuleMetadata","Module","ClassDecorator","Injectable","Inject","ParameterDecorator","Optional","Global","DiscordEvent","Listener","On","MethodDecorator","Once","Ctx","Guard","GuardOptionConfig","GuardOption","PropertyDecorator","ExecutionContext","Readonly","SpraxiumGuard","Promise","SpraxiumOnBoot","SpraxiumOnShutdown","SpraxiumOnReady","ReadonlyContainer","GuardEntry","Record","PrefixCommandConfig","PrefixCommandHandlerMetadata","PrefixArgType","PrefixArgValidation","RegExp","PrefixArgDefinition","PrefixArgMetadata","Omit","PrefixGuildEntry","PrefixGuildProvider","PrefixConfig","PrefixSubcommandConfig","SlashI18nKeys","SlashCommandConfig","SlashCommandHandlerMetadata","SlashOptionType","SlashOptionChoice","V","SlashBaseOptionConfig","SlashStringOptionConfig","SlashIntegerOptionConfig","SlashNumberOptionConfig","GuildChannelType","SlashChannelOptionConfig","SlashOptionMetadata","SlashSubcommandMetadata","SlashSubcommandGroupMetadata","SlashAutocompleteHandlerMetadata","ContextMenuCommandType","ContextMenuCommandConfig","ContextMenuCommandHandlerMetadata","GuardOptions","K","GuardInput","withOptions","UseGuards","Guards","ExceptionLayoutClass","WithLayout","PrefixCommand","PrefixCommandHandler","PrefixSubcommand","BaseArgConfig","PrefixArg","SlashCommand","SlashCommandHandler","SlashOptionParam","SlashOption","SlashOpt","SlashStringOption","SlashIntegerOption","SlashNumberOption","SlashBooleanOption","SlashUserOption","SlashChannelOption","SlashRoleOption","SlashMentionableOption","SlashAttachmentOption","SlashFocused","SlashSubcommand","SlashSubcommandGroup","SlashSubcommandGroups","SlashAutocompleteHandler","ContextMenuCommand","ContextMenuCommandHandler","DeferOptions","Defer","AutoDeferOptions","AutoDefer","SlashContext"],"sources":["../src/types/ban-options.type.ts","../src/types/constructor.type.ts","../src/types/http-method.type.ts","../src/types/param-source.type.ts","../src/types/param-definition.type.ts","../src/types/route-definition.type.ts","../src/types/serialized-user.type.ts","../src/types/serialized-ban.type.ts","../src/types/serialized-guild.type.ts","../src/types/serialized-role.type.ts","../src/types/serialized-member.type.ts","../src/interfaces/bot-bridge.interface.ts","../src/interfaces/http-guard.interface.ts","../src/interfaces/http-middleware.interface.ts","../src/interfaces/http-client-module-metadata.interface.ts","../src/interfaces/rate-limit-config.interface.ts","../src/interfaces/security-config.interface.ts","../src/interfaces/http-config.interface.ts","../src/interfaces/http-module.interface.ts","../src/interfaces/registered-controller.interface.ts","../src/interfaces/error-validation-detail.interface.ts","../src/bridge/bridge.factory.ts","../src/bridge/direct-bot.bridge.ts","../src/bridge/sharded-bot.bridge.ts","../src/bridge/serializers/guild.serializer.ts","../src/bridge/serializers/member.serializer.ts","../src/bridge/serializers/ban.serializer.ts","../src/constants/defaults.constant.ts","../src/constants/metadata-keys.constant.ts","../src/constants/security-defaults.constant.ts","../src/decorators/route.decorator.ts","../src/decorators/param.decorator.ts","../src/decorators/http-client-module.decorator.ts","../src/errors/http.error.ts","../src/errors/bad-request.error.ts","../src/errors/conflict.error.ts","../src/errors/forbidden.error.ts","../src/errors/internal-server.error.ts","../src/errors/method-not-allowed.error.ts","../src/errors/not-found.error.ts","../src/errors/not-implemented.error.ts","../src/errors/service-unavailable.error.ts","../src/errors/too-many-requests.error.ts","../src/errors/unauthorized.error.ts","../src/errors/unprocessable-entity.error.ts","../src/errors/validation.error.ts","../src/guards/api-key.guard.ts","../src/guards/guard.executor.ts","../../core/dist/index.d.ts","../src/http.config.ts","../src/http.module.ts","../src/middleware/body-limit.middleware.ts","../src/middleware/cors.middleware.ts","../src/middleware/logger.middleware.ts","../src/middleware/rate-limit.middleware.ts","../src/middleware/security-headers.middleware.ts","../src/service/http-registry.service.ts","../../common/dist/index.d.ts","../src/service/http-server.service.ts","../src/service/param-resolver.service.ts","../src/service/route-builder.service.ts","../src/service/route-registry.service.ts","../src/service/validation-pipe.service.ts"],"sourcesContent":["import \"reflect-metadata\";\nimport { APIInteractionGuildMember, ActionRowBuilder, ActivityType, BaseInteraction, ChatInputCommandInteraction, Client, ClientOptions, ContextMenuCommandInteraction, EmbedBuilder, GatewayIntentBits, GuildMember, LocaleString, Message, MessageFlags, Partials, PermissionsBitField, PermissionsString, RESTPostAPIApplicationCommandsJSONBody, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody, ShardingManager, User } from \"discord.js\";\n\n//#region ../common/dist/index.d.ts\n\n//# sourceMappingURL=metadata-keys.constant.d.ts.map\n//#endregion\n//#region src/types/constructor.type.d.ts\ntype Constructor$1<T = unknown> = new (...args: Array<any>) => T;\n//# sourceMappingURL=constructor.type.d.ts.map\n//#endregion\n//#region src/interfaces/module-metadata.interface.d.ts\n\n//# sourceMappingURL=guard-option.decorator.d.ts.map\n//#endregion\n//#region src/interfaces/execution-context.interface.d.ts\n/**\n * Represents whatever triggered the handler , could be an interaction or a message.\n * Passed into every guard's canActivate().\n */\ninterface ExecutionContext {\n  /** Snowflake ID of the user who triggered the handler. */\n  getUserId(): string;\n  /** The User object of whoever triggered the handler. */\n  getUser(): User;\n  /** Snowflake ID of the guild, or null when invoked in a DM. */\n  getGuildId(): string | null;\n  /** Snowflake ID of the channel where the handler was triggered. */\n  getChannelId(): string;\n  /** The name of the event/command that was triggered. */\n  getCommandName(): string;\n  /**\n   * The resolved guild member, or null in DMs or when the member is not cached.\n   * Works for all interaction types (ChatInput, Button, SelectMenu, Modal, etc.)\n   * and for Message-based handlers.\n   */\n  getMember(): GuildMember | APIInteractionGuildMember | null;\n  /**\n   * The member's resolved guild permissions, or null in DMs / uncached members.\n   * Works for all interaction types and Message-based handlers.\n   */\n  getMemberPermissions(): Readonly<PermissionsBitField> | null;\n  /**\n   * The raw BaseInteraction or Message backing this context.\n   * Prefer the typed helpers (getMember, getMemberPermissions, getUser) over\n   * casting this directly.\n   */\n  getInteraction(): BaseInteraction | Message;\n  /** True when the handler was triggered via a slash (ChatInput) interaction. */\n  isSlashCommand(): boolean;\n  /** True when the handler was triggered via a text prefix message. */\n  isPrefixCommand(): boolean;\n}\n//# sourceMappingURL=execution-context.interface.d.ts.map\n//#endregion\n//#region src/interfaces/spraxium-guard.interface.d.ts\n/**\n * Every guard must implement this interface.\n * Return (or resolve to) true to allow the command, false to block it.\n */\ninterface SpraxiumGuard {\n  canActivate(ctx: ExecutionContext): Promise<boolean> | boolean;\n}\n//# sourceMappingURL=spraxium-guard.interface.d.ts.map\n//#endregion\n//#region src/interfaces/lifecycle.interface.d.ts\n\n//# sourceMappingURL=lifecycle.interface.d.ts.map\n//#endregion\n//#region src/interfaces/readonly-container.interface.d.ts\ndeclare abstract class ReadonlyContainer {\n  abstract get<T = unknown>(token: unknown): T | undefined;\n}\n//# sourceMappingURL=readonly-container.interface.d.ts.map\n//#endregion\n//#region src/interfaces/guard-entry.interface.d.ts\ninterface GuardEntry {\n  guard: new () => SpraxiumGuard;\n  options: Record<string, unknown>;\n}\n//# sourceMappingURL=guard-entry.interface.d.ts.map\n\n//#endregion\n//#region src/interfaces/prefix-command-config.interface.d.ts\n/**\n * Configuration for `@PrefixCommand()` , structure-only declaration.\n *\n * The class decorated with `@PrefixCommand()` acts as a metadata container:\n * it defines the command name, aliases, argument schema, and description.\n * Execution logic belongs in a separate `@PrefixCommandHandler()` class.\n */\ninterface PrefixCommandConfig {\n  /** Primary trigger name (e.g. `'ban'` for `!ban`). */\n  name: string;\n  /** Alternative trigger names. */\n  aliases?: Array<string>;\n  /** Short help text shown in help commands. */\n  description?: string;\n  /** Override the global prefix for this specific command. */\n  prefix?: string;\n  /** Usage string shown when arguments are invalid (e.g. `'!ban <user> [reason]'`). */\n  usage?: string;\n  /** Category for grouping in help output. */\n  category?: string;\n  /** Per-command cooldown in seconds. Overrides global cooldown. */\n  cooldown?: number;\n}\n//# sourceMappingURL=prefix-command-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-command-handler-metadata.interface.d.ts\n/**\n * Metadata stored by `@PrefixCommandHandler()`.\n *\n * Links a handler class (which contains the `handle()` method) to the\n * `@PrefixCommand()` class it handles.\n */\ninterface PrefixCommandHandlerMetadata {\n  /** Reference to the `@PrefixCommand()` class this handler processes. */\n  command: new () => object;\n  /** If set, this handler only fires for `!cmd <subcommand>`. */\n  subcommand?: string;\n}\n//# sourceMappingURL=prefix-command-handler-metadata.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-arg-metadata.interface.d.ts\n/** Supported argument types for `@PrefixArg.*()` decorators. */\ntype PrefixArgType = 'string' | 'integer' | 'number' | 'boolean' | 'user' | 'channel' | 'role' | 'member' | 'snowflake' | 'url' | 'duration' | 'color' | 'emoji' | 'rest';\ninterface PrefixArgValidation {\n  /** Custom regex the raw input must match before coercion. */\n  pattern?: RegExp;\n  /** Custom validator function. Return `true` to pass or a string error message. */\n  validate?: (value: string) => true | string;\n}\n/**\n * User-facing argument definition returned by a command's `build()` method\n * or a `@PrefixSubcommand()` method. Omits `position` , the framework\n * assigns position from the array index.\n */\n\n/**\n * Full internal metadata for a single prefix argument.\n * Created by the framework from `PrefixArgDefinition` with an assigned position.\n */\ninterface PrefixArgMetadata {\n  /** Argument name used for lookup via `@Arg('name')` on the handler. */\n  name: string;\n  /** Expected type , determines coercion and validation logic. */\n  type: PrefixArgType;\n  /** Positional index in the raw argv array. */\n  position: number;\n  /** Whether the argument must be present. @default true */\n  required: boolean;\n  /** Minimum numeric value (integer/number types). */\n  min?: number;\n  /** Maximum numeric value (integer/number types). */\n  max?: number;\n  /** Minimum string length (string type). */\n  minLength?: number;\n  /** Maximum string length (string type). */\n  maxLength?: number;\n  /** Allowed literal values (acts as an enum). */\n  choices?: Array<string>;\n  /** Custom validation rules (regex and/or function). */\n  validation?: PrefixArgValidation;\n}\n//# sourceMappingURL=prefix-arg-metadata.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-guild.interface.d.ts\n/**\n * A single guild's prefix configuration, returned by a\n * `PrefixGuildProvider` during bootstrap or at runtime.\n */\ninterface PrefixGuildEntry {\n  /** Discord guild (server) snowflake ID. */\n  guildId: string;\n  /** One or more prefixes active for this guild. */\n  prefix: string | Array<string>;\n  /** Arbitrary metadata the developer can attach (e.g. language, tier). */\n  metadata?: Record<string, unknown>;\n}\n/**\n * Async function that supplies initial per-guild prefix data at boot time.\n *\n * The framework calls this once during bootstrap and loads the returned\n * entries into the in-memory `PrefixGuildManager`. The developer can\n * source this data from a database, API, or any async store.\n *\n * @example\n * ```ts\n * const provider: PrefixGuildProvider = async () => {\n *   const rows = await db.query('SELECT guild_id, prefix FROM guild_settings');\n *   return rows.map(r => ({ guildId: r.guild_id, prefix: r.prefix }));\n * };\n * ```\n */\ntype PrefixGuildProvider = () => Promise<Array<PrefixGuildEntry>> | Array<PrefixGuildEntry>;\n//# sourceMappingURL=prefix-guild.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-config.interface.d.ts\n/**\n * Configuration for the prefix command subsystem.\n *\n * Set in `SpraxiumCoreConfig.prefix` or via\n * `SpraxiumFactory.create({ prefix: ... })`.\n */\ninterface PrefixConfig {\n  /** The global prefix string(s). @default '!' */\n  prefix: string | Array<string>;\n  /**\n   * Async function that supplies initial per-guild prefix data at boot time.\n   *\n   * The framework calls this once during bootstrap and loads the returned\n   * entries into the in-memory `PrefixGuildManager`.\n   *\n   * After boot, use the `PrefixGuildManager` API to update prefixes at runtime\n   * without restarting the bot.\n   *\n   * @example\n   * ```ts\n   * guildPrefixProvider: async () => {\n   *   const rows = await db.query('SELECT guild_id, prefix FROM settings');\n   *   return rows.map(r => ({ guildId: r.guild_id, prefix: r.prefix }));\n   * }\n   * ```\n   */\n  guildPrefixProvider?: PrefixGuildProvider;\n  /** Whether prefix matching is case-sensitive. @default false */\n  caseSensitive?: boolean;\n  /** Whether commands should accept a bot mention as a prefix. @default true */\n  mentionPrefix?: boolean;\n  /** Default cooldown in seconds applied to all commands. @default 0 */\n  defaultCooldown?: number;\n  /** Whether to reply with \"command not found\" when no match is found. @default false */\n  replyOnNotFound?: boolean;\n}\n//# sourceMappingURL=prefix-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-subcommand-config.interface.d.ts\n/**\n * Configuration for `@PrefixSubcommand()` , declares a subcommand within\n * a `@PrefixCommand()` class.\n *\n * Each decorated method returns a `PrefixArgDefinition[]` defining the\n * argument schema for that specific subcommand.\n */\n\n//# sourceMappingURL=prefix-subcommand-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-i18n-keys.interface.d.ts\ninterface SlashI18nKeys {\n  /** Locale lookup key for this entity's name localizations. */\n  name: string;\n  /** Locale lookup key for this entity's description localizations. */\n  description: string;\n}\n//# sourceMappingURL=slash-i18n-keys.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-command-config.interface.d.ts\ninterface SlashCommandConfig {\n  name: string;\n  description: string;\n  guild?: string;\n  dmPermission?: boolean;\n  defaultMemberPermissions?: bigint | number | null;\n  nsfw?: boolean;\n  i18n?: SlashI18nKeys;\n}\n//# sourceMappingURL=slash-command-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-command-handler-metadata.interface.d.ts\ninterface SlashCommandHandlerMetadata {\n  command: new () => object;\n  sub?: string;\n  group?: string;\n}\n//# sourceMappingURL=slash-command-handler-metadata.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-option-metadata.interface.d.ts\n\n//# sourceMappingURL=slash-autocomplete-handler-metadata.interface.d.ts.map\n\n//#endregion\n//#region src/interfaces/context-menu-command-config.interface.d.ts\n/**\n * Type of context menu command exposed by Discord.\n *\n * - `'user'`: appears under right-click on a user (`Apps` submenu)\n * - `'message'`: appears under right-click on a message (`Apps` submenu)\n */\ntype ContextMenuCommandType = 'user' | 'message';\ninterface ContextMenuCommandConfig {\n  /**\n   * Display name shown to the user inside the `Apps` submenu.\n   * Up to 32 characters; spaces are allowed (unlike slash command names).\n   */\n  name: string;\n  /**\n   * Whether this is a user-targeted or message-targeted context menu command.\n   */\n  type: ContextMenuCommandType;\n  /**\n   * If set, the command is registered as a guild command in this guild\n   * instead of globally. Useful for testing.\n   */\n  guild?: string;\n  /**\n   * Whether the command is allowed in DMs. Defaults to `true`.\n   * Ignored for context menu commands targeted at messages in DMs.\n   */\n  dmPermission?: boolean;\n  /**\n   * Discord permissions required by default to invoke this command.\n   * Server admins can override this in guild settings.\n   */\n  defaultMemberPermissions?: bigint | number | null;\n  /**\n   * Marks the command as NSFW. Discord will hide it from age-restricted users\n   * outside age-gated channels.\n   */\n  nsfw?: boolean;\n}\n//# sourceMappingURL=context-menu-command-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/context-menu-command-handler-metadata.interface.d.ts\ninterface ContextMenuCommandHandlerMetadata {\n  command: new () => object;\n}\n//# sourceMappingURL=context-menu-command-handler-metadata.interface.d.ts.map\n//#endregion\n//#region src/types/guard-options.type.d.ts\n\n//# sourceMappingURL=defer.decorator.d.ts.map\n//#endregion\n//#region src/decorators/auto-defer.decorator.d.ts\ninterface AutoDeferOptions {\n  /**\n   * Whether the deferred reply should be ephemeral (visible only to the user).\n   * Defaults to `false`.\n   */\n  ephemeral?: boolean;\n  /**\n   * How many milliseconds to wait before automatically deferring the interaction.\n   * If the handler responds within this window, Discord will never show \"Thinking...\"\n   * to the user. If the handler takes longer, the framework defers automatically.\n   *\n   * Discord's hard deadline is 3000 ms, so keep this well below that.\n   * Defaults to `2000` ms.\n   */\n  threshold?: number;\n}\n/**\n * Automatically defers the interaction **only if** the handler takes longer\n * than `threshold` milliseconds (default 2000 ms) to respond.\n *\n * Unlike `@Defer()`, which always shows \"Thinking...\" immediately, `@AutoDefer`\n * is transparent for fast handlers -- Discord never shows the loading state.\n *\n * The framework patches `interaction.reply()` so the handler can always call\n * `interaction.reply()` without worrying about whether a defer happened.\n * If the interaction was deferred behind the scenes, the patch transparently\n * routes the call to `interaction.editReply()` instead.\n *\n * @example\n * ```ts\n * @SlashCommandHandler(StatsCommand)\n * @AutoDefer({ ephemeral: true, threshold: 1500 })\n * export class StatsCommandHandler {\n *   async handle(@Ctx() interaction: ChatInputCommandInteraction) {\n *     const data = await this.db.fetchStats(); // may take 0-3 s\n *     await interaction.reply({ embeds: [buildEmbed(data)] }); // always safe\n *   }\n * }\n * ```\n */\n//#endregion\n//#region src/context-menu/interfaces/index.d.ts\ninterface ResolvedContextMenuCommand {\n  ctor: Constructor$1;\n  config: ContextMenuCommandConfig;\n}\ninterface ResolvedContextMenuHandler {\n  handlerCtor: Constructor$1;\n  instance: unknown;\n  meta: ContextMenuCommandHandlerMetadata;\n  commandCtor: Constructor$1;\n  config: ContextMenuCommandConfig;\n}\ninterface ResolvedContextMenuEntry {\n  commandName: string;\n  type: ContextMenuCommandConfig['type'];\n  handlerClass: string;\n}\n//# sourceMappingURL=index.d.ts.map\n//#endregion\n//#region src/context-menu/context-menu.dispatcher.d.ts\ndeclare class ContextMenuDispatcher {\n  private readonly registry;\n  private readonly binder;\n  private readonly registrar;\n  registerCommand(ctor: Constructor$1): void;\n  registerHandler(ctor: Constructor$1, instance: unknown): void;\n  bind(client: Client): void;\n  buildPayloads(): Array<RESTPostAPIContextMenuApplicationCommandsJSONBody>;\n  buildGuildGroupedPayloads(): Map<string, Array<RESTPostAPIContextMenuApplicationCommandsJSONBody>>;\n  getResolved(): Array<ResolvedContextMenuEntry>;\n  get size(): number;\n  get commandCount(): number;\n}\n//# sourceMappingURL=context-menu.dispatcher.d.ts.map\n//#endregion\n//#region src/prefix/guild/prefix-guild.manager.d.ts\n/**\n * Manages per-guild prefix overrides at runtime.\n *\n * During bootstrap, the framework loads initial data via a\n * `PrefixGuildProvider` if one is configured. After boot, use the\n * mutation API (`set`, `update`, `remove`) to change prefixes\n * dynamically , no restart required.\n *\n * The `PrefixParser` reads from this manager on every message to\n * determine the active prefix for a guild.\n */\ndeclare class PrefixGuildManager {\n  private readonly log;\n  private readonly store;\n  getGuildPrefix(guildId: string): Array<string> | undefined;\n  getGuildEntry(guildId: string): Readonly<PrefixGuildEntry> | undefined;\n  hasGuildPrefix(guildId: string): boolean;\n  getAllGuildIds(): Array<string>;\n  get size(): number;\n  setGuildPrefix(guildId: string, prefix: string | Array<string>, metadata?: Record<string, unknown>): void;\n  updateGuildPrefix(guildId: string, prefix: string | Array<string>, metadata?: Record<string, unknown>): void;\n  removeGuildPrefix(guildId: string): boolean;\n  clear(): void;\n  loadFromProvider(provider: PrefixGuildProvider): Promise<void>;\n}\n//# sourceMappingURL=prefix-guild.manager.d.ts.map\n//#endregion\n//#region src/prefix/interfaces/parsed-message.interface.d.ts\n/** Result of parsing a raw message into command parts. */\ninterface ParsedPrefixMessage {\n  /** The detected prefix string. */\n  prefix: string;\n  /** The command name (lowercased unless caseSensitive). */\n  commandName: string;\n  /** Raw argv tokens after the command name. */\n  argv: Array<string>;\n}\n//# sourceMappingURL=parsed-message.interface.d.ts.map\n//#endregion\n//#region src/prefix/interfaces/prefix-subcommand-info.interface.d.ts\n/** Structured info for a single prefix subcommand, used in help rendering. */\ninterface PrefixSubcommandInfo {\n  name: string;\n  description: string;\n  handlerClass: string;\n  args: Array<PrefixArgMetadata>;\n}\n//# sourceMappingURL=prefix-subcommand-info.interface.d.ts.map\n//#endregion\n//#region src/prefix/interfaces/command-info.interface.d.ts\n/** Structured command info for help rendering. */\ninterface PrefixCommandInfo {\n  name: string;\n  aliases: Array<string>;\n  description: string;\n  category: string;\n  usage: string;\n  cooldown: number;\n  args: Array<PrefixArgMetadata>;\n  subcommands: Array<PrefixSubcommandInfo>;\n}\n//# sourceMappingURL=command-info.interface.d.ts.map\n//#endregion\n//#region src/prefix/interfaces/subcommand-entry.interface.d.ts\n/** Resolved metadata for a single subcommand declared via @PrefixSubcommand(). */\ninterface PrefixSubcommandEntry {\n  name: string;\n  description: string;\n  args: Array<PrefixArgMetadata>;\n}\n//# sourceMappingURL=subcommand-entry.interface.d.ts.map\n//#endregion\n//#region src/prefix/interfaces/resolved-command.interface.d.ts\n/** A fully resolved command registration combining class + decorator metadata. */\ninterface ResolvedPrefixCommand {\n  ctor: Constructor$1;\n  config: PrefixCommandConfig;\n  /** Root-level arguments (from `build()` decorators). Empty for subcommand-based commands. */\n  args: Array<PrefixArgMetadata>;\n  /** Subcommand definitions (from `@PrefixSubcommand()` methods). */\n  subcommands: Array<PrefixSubcommandEntry>;\n}\n//# sourceMappingURL=resolved-command.interface.d.ts.map\n//#endregion\n//#region src/prefix/interfaces/resolved-entry.interface.d.ts\n/** Snapshot returned for boot logging / diagnostics. */\ninterface ResolvedPrefixEntry {\n  commandName: string;\n  aliases: Array<string>;\n  handlerClass: string;\n  subcommand: string | undefined;\n  argCount: number;\n}\n//# sourceMappingURL=resolved-entry.interface.d.ts.map\n//#endregion\n//#region src/prefix/interfaces/resolved-handler.interface.d.ts\n/** A fully resolved handler registration combining class + instance + metadata. */\ninterface ResolvedPrefixHandler {\n  handlerCtor: Constructor$1;\n  instance: unknown;\n  meta: PrefixCommandHandlerMetadata;\n  /** Resolved reference to the parent command entry. */\n  command: ResolvedPrefixCommand;\n}\n//# sourceMappingURL=resolved-handler.interface.d.ts.map\n//#endregion\n//#region src/prefix/prefix.registry.d.ts\ndeclare class PrefixRegistry {\n  private readonly commands;\n  private readonly nameIndex;\n  private readonly handlers;\n  registerCommand(ctor: Constructor$1): void;\n  registerHandler(ctor: Constructor$1, instance: unknown): void;\n  findCommand(nameOrAlias: string): ResolvedPrefixCommand | undefined;\n  findHandler(command: ResolvedPrefixCommand, subcommand: string | undefined): ResolvedPrefixHandler | undefined;\n  resolveArgs(command: ResolvedPrefixCommand, subcommand: string | undefined): Array<PrefixArgMetadata>;\n  isSubcommand(command: ResolvedPrefixCommand, name: string): boolean;\n  allHandlers(): ReadonlyArray<ResolvedPrefixHandler>;\n  getResolved(): Array<ResolvedPrefixEntry>;\n  getCommandInfo(): Array<PrefixCommandInfo>;\n  get size(): number;\n  get commandCount(): number;\n  private collectSubcommands;\n  private static resolveDefinitions;\n}\n//# sourceMappingURL=prefix.registry.d.ts.map\n//#endregion\n//#region src/prefix/prefix.binder.d.ts\ndeclare class PrefixBinder {\n  private readonly registry;\n  private readonly log;\n  private readonly boundClients;\n  private readonly parser;\n  private readonly invoker;\n  constructor(registry: PrefixRegistry);\n  bind(client: Client, config: PrefixConfig, guildManager: PrefixGuildManager): void;\n  get cooldowns(): PrefixBinder['invoker']['cooldowns'];\n  private handleMessage;\n}\n//# sourceMappingURL=prefix.binder.d.ts.map\n//#endregion\n//#region src/prefix/prefix.dispatcher.d.ts\ndeclare class PrefixDispatcher {\n  private readonly registry;\n  private readonly binder;\n  readonly guildPrefixes: PrefixGuildManager;\n  registerCommand(ctor: Constructor$1): void;\n  registerHandler(ctor: Constructor$1, instance: unknown): void;\n  bind(client: Client, config: PrefixConfig): void;\n  getResolved(): Array<ResolvedPrefixEntry>;\n  getCommandInfo(): Array<PrefixCommandInfo>;\n  get size(): number;\n  get commandCount(): number;\n  get cooldowns(): PrefixBinder['cooldowns'];\n}\n//# sourceMappingURL=prefix.dispatcher.d.ts.map\n//#endregion\n//#region src/slash/interfaces/resolved-slash-command.interface.d.ts\ninterface ResolvedSlashCommand {\n  config: SlashCommandConfig;\n  ctor: Constructor$1;\n}\n//# sourceMappingURL=resolved-slash-command.interface.d.ts.map\n//#endregion\n//#region src/slash/interfaces/resolved-slash-handler.interface.d.ts\ninterface ResolvedSlashHandler {\n  handlerCtor: Constructor$1;\n  instance: unknown;\n  meta: SlashCommandHandlerMetadata;\n  commandCtor: Constructor$1;\n  config: SlashCommandConfig;\n}\n//# sourceMappingURL=resolved-slash-handler.interface.d.ts.map\n//#endregion\n//#region src/slash/interfaces/resolved-slash-entry.interface.d.ts\ninterface ResolvedSlashEntry {\n  commandName: string;\n  handlerClass: string;\n  sub?: string;\n  group?: string;\n  optionCount: number;\n}\n//# sourceMappingURL=resolved-slash-entry.interface.d.ts.map\n//#endregion\n//#region src/slash/interfaces/resolved-autocomplete-handler.interface.d.ts\ninterface ResolvedAutocompleteHandler {\n  commandName: string;\n  optionName: string;\n  instance: unknown;\n  handlerCtor: new (...args: Array<unknown>) => unknown;\n}\n//# sourceMappingURL=resolved-autocomplete-handler.interface.d.ts.map\n//#endregion\n//#region src/slash/types/slash-localization.type.d.ts\n/**\n * Mapped type for a Discord localization object.\n * Each key is a Discord-supported locale string; values are the translated text.\n */\ntype SlashLocalizationMap = Partial<Record<LocaleString, string>>;\n//# sourceMappingURL=slash-localization.type.d.ts.map\n//#endregion\n//#region src/slash/interfaces/slash-localization.interface.d.ts\n/**\n * Resolved name and description localizations for a slash command, subcommand,\n * subcommand group, or option; ready to be passed directly to a discord.js builder's\n * `setNameLocalizations` / `setDescriptionLocalizations` methods.\n */\ninterface SlashLocalizationResult {\n  name_localizations: SlashLocalizationMap;\n  description_localizations: SlashLocalizationMap;\n}\n//# sourceMappingURL=slash-localization.interface.d.ts.map\n//#endregion\n//#region src/slash/slash.registry.d.ts\ndeclare class SlashRegistry {\n  private readonly commands;\n  private readonly nameIndex;\n  private readonly handlers;\n  private readonly autocompleteHandlers;\n  registerCommand(ctor: Constructor$1): void;\n  registerHandler(ctor: Constructor$1, instance: unknown): void;\n  registerAutocompleteHandler(ctor: Constructor$1, instance: unknown): void;\n  findHandler(commandName: string, sub?: string, group?: string): ResolvedSlashHandler | undefined;\n  findAutocomplete(commandName: string, optionName: string): ResolvedAutocompleteHandler | undefined;\n  getCommandGuilds(): Set<string>;\n  allCommands(): ReadonlyMap<Constructor$1, ResolvedSlashCommand>;\n  allHandlers(): ReadonlyArray<ResolvedSlashHandler>;\n  getResolved(): Array<ResolvedSlashEntry>;\n  get size(): number;\n  get commandCount(): number;\n}\n//# sourceMappingURL=slash.registry.d.ts.map\n//#endregion\n//#region src/slash/slash.registrar.d.ts\ndeclare class SlashRegistrar {\n  private readonly registry;\n  private readonly log;\n  constructor(registry: SlashRegistry);\n  register(token: string, clientId: string, guildId?: string, force?: boolean, extraPayloads?: Array<RESTPostAPIApplicationCommandsJSONBody>, extraGuildPayloads?: Map<string, Array<RESTPostAPIApplicationCommandsJSONBody>>): Promise<void>;\n  private isUnchanged;\n  private writeHash;\n  private computeHash;\n  buildPayloads(): Array<RESTPostAPIChatInputApplicationCommandsJSONBody>;\n  private buildGlobalPayloads;\n  private buildGuildPayloads;\n  private buildCommandPayload;\n  private applyRootOptions;\n  private applySubcommands;\n  private applySubcommandGroups;\n}\n//# sourceMappingURL=slash.registrar.d.ts.map\n//#endregion\n//#region src/slash/slash.dispatcher.d.ts\ndeclare class SlashDispatcher {\n  private readonly registry;\n  private readonly binder;\n  private readonly registrar;\n  registerCommand(ctor: Constructor$1): void;\n  registerHandler(ctor: Constructor$1, instance: unknown): void;\n  registerAutocompleteHandler(ctor: Constructor$1, instance: unknown): void;\n  bind(client: Client): void;\n  register(token: string, clientId: string, guildId?: string, force?: boolean, extraPayloads?: Array<RESTPostAPIApplicationCommandsJSONBody>, extraGuildPayloads?: Map<string, Array<RESTPostAPIApplicationCommandsJSONBody>>): Promise<void>;\n  buildPayloads(): ReturnType<SlashRegistrar['buildPayloads']>;\n  getResolved(): Array<ResolvedSlashEntry>;\n  get size(): number;\n  get commandCount(): number;\n}\n//# sourceMappingURL=slash.dispatcher.d.ts.map\n//#endregion\n//#region src/slash/slash-localization.bridge.d.ts\ntype SlashLocalizationProvider = (keys: SlashI18nKeys) => SlashLocalizationResult;\n/**\n * Zero-dependency bridge between the slash registrar and @spraxium/i18n.\n *\n * Core cannot import i18n (circular: i18n has core as peer dep).\n * Instead, i18n calls `setProvider()` during its boot lifecycle,\n * and the slash registrar calls `resolve()` when it finds an `i18n` field.\n *\n * When no provider is registered (i18n plugin not configured),\n * `resolve()` returns null and the registrar skips localizations silently.\n */\ndeclare class SlashLocalizationBridge {\n  private static provider;\n  static setProvider(fn: SlashLocalizationProvider): void;\n  static resolve(keys: SlashI18nKeys): SlashLocalizationResult | null;\n  static reset(): void;\n}\n//# sourceMappingURL=slash-localization.bridge.d.ts.map\n//#endregion\n//#region src/bootstrap/spraxium.container.d.ts\ndeclare class SpraxiumContainer extends ReadonlyContainer {\n  private readonly parent?;\n  private readonly instances;\n  constructor(parent?: SpraxiumContainer | undefined);\n  set(token: unknown, instance: unknown): void;\n  get<T = unknown>(token: unknown): T | undefined;\n  has(token: unknown): boolean;\n  createChild(): SpraxiumContainer;\n}\n//# sourceMappingURL=spraxium.container.d.ts.map\n//#endregion\n//#region src/bootstrap/module.loader.d.ts\ndeclare class ModuleLoader {\n  static readonly instanceScanners: Set<(instance: unknown) => void>;\n  private readonly log;\n  private readonly rootContainer;\n  private readonly bootHooks;\n  private readonly shutdownHooks;\n  private readonly readyHooks;\n  private readonly loadedModules;\n  private readonly listenerDispatcher;\n  private readonly prefixDispatcher;\n  private readonly slashDispatcher;\n  private readonly contextMenuDispatcher;\n  private readonly moduleRows;\n  load(rootModule: Constructor$1, client: Client, globalProviders?: Map<unknown, unknown>): void;\n  private loadModule;\n  private instantiate;\n  private sortProviders;\n  private registerLifecycle;\n  runBootHooks(): Promise<void>;\n  runShutdownHooks(): Promise<void>;\n  runReadyHooks(client: Client<true>): Promise<void>;\n  getContainer(): SpraxiumContainer;\n  bindListeners(client: Client): void;\n  getPrefixDispatcher(): PrefixDispatcher;\n  getSlashDispatcher(): SlashDispatcher;\n  getContextMenuDispatcher(): ContextMenuDispatcher;\n  printBootTables(): void;\n}\n//# sourceMappingURL=module.loader.d.ts.map\n//#endregion\n//#region src/client/interfaces/activity-options.interface.d.ts\ninterface ActivityOptions {\n  name: string;\n  type: 'Playing' | 'Streaming' | 'Listening' | 'Watching' | 'Competing';\n  url?: string;\n}\n//# sourceMappingURL=activity-options.interface.d.ts.map\n//#endregion\n//#region src/client/interfaces/presence-options.interface.d.ts\ninterface PresenceOptions {\n  /** Bot status indicator. Defaults to 'online'. */\n  status?: 'online' | 'idle' | 'dnd' | 'invisible';\n  /** One or more activities. When rotateInterval is set and length > 1, they rotate automatically. */\n  activities?: Array<ActivityOptions>;\n  /** Milliseconds between each activity rotation step. Only effective when activities.length > 1. */\n  rotateInterval?: number;\n  /**\n   * Per-shard presence overrides. When running in sharded mode, a shard whose ID\n   * matches a key in this record will use that config merged over the global presence\n   * at boot time.\n   *\n   * For runtime overrides use PresenceManager.setShardPresence().\n   *\n   * @example\n   * perShard: {\n   *   0: { status: 'dnd', activities: [{ name: 'Shard 0', type: 'Playing' }] },\n   * }\n   */\n  perShard?: Record<number, Partial<Pick<PresenceOptions, 'status' | 'activities' | 'rotateInterval'>>>;\n}\n//# sourceMappingURL=presence-options.interface.d.ts.map\n//#endregion\n//#region src/client/interfaces/shard-options.interface.d.ts\n/**\n * Configuration for Discord.js ShardingManager.\n * Only used when SpraxiumOptions.sharding is provided.\n */\ninterface ShardOptions {\n  /**\n   * Total number of shards to spawn, or 'auto' to let Discord decide.\n   * 'auto' requires a valid bot token at spawn time.\n   */\n  totalShards: number | 'auto';\n  /** Subset of shard IDs to spawn. Omit to spawn all shards. */\n  shardList?: Array<number>;\n  /** Whether to respawn a shard if it crashes. Defaults to true. */\n  respawn?: boolean;\n  /**\n   * Delay in milliseconds between spawning each shard.\n   * Defaults to 5500 to respect Discord's identify rate limit.\n   */\n  spawnDelay?: number;\n}\n//# sourceMappingURL=shard-options.interface.d.ts.map\n//#endregion\n//#region src/application/interfaces/application-state.interface.d.ts\ninterface ApplicationState {\n  token?: string;\n  intents?: Array<GatewayIntentBits>;\n  partials?: Array<Partials>;\n  presence?: PresenceOptions;\n  sharding?: ShardOptions;\n  rootModule?: Constructor$1;\n  moduleLoader?: ModuleLoader;\n  client?: Client;\n  globalProviders: Map<unknown, unknown>;\n}\n//# sourceMappingURL=application-state.interface.d.ts.map\n//#endregion\n//#region src/application/interfaces/spraxium-options.interface.d.ts\ninterface SpraxiumOptions {\n  token?: string;\n  partials?: Array<Partials>;\n  clientOptions?: Omit<ClientOptions, 'intents' | 'partials'>;\n  intents?: Array<GatewayIntentBits>;\n  sharding?: ShardOptions;\n}\n//# sourceMappingURL=spraxium-options.interface.d.ts.map\n//#endregion\n//#region src/client/interfaces/shard-eval-context.interface.d.ts\ninterface ShardEvalContext {\n  guilds: {\n    cache: {\n      size: number;\n    };\n  };\n}\n//# sourceMappingURL=shard-eval-context.interface.d.ts.map\n//#endregion\n//#region src/client/interfaces/shard-status.interface.d.ts\ninterface ShardStatus {\n  guildCount?: number;\n  ready: boolean;\n}\n//# sourceMappingURL=shard-status.interface.d.ts.map\n\n//#endregion\n//#region src/client/interfaces/shard-activity-props.interface.d.ts\n/**\n * Custom key-value pairs that can be interpolated into activity name templates\n * alongside the built-in shard props.\n *\n * Built-in props are resolved automatically from the Discord client and do NOT\n * need to be passed here:\n *   {{shardId}}       , Current shard ID (0-based)\n *   {{shardNumber}}   , Current shard number (1-based, i.e. shardId + 1)\n *   {{totalShards}}   , Total number of shards\n *   {{totalServers}}  , Number of guilds on this shard\n *   {{ping}}          , WebSocket heartbeat latency in milliseconds\n *\n * @example\n * PresenceManager.setShardActivity(0, {\n *   name: 'v{{version}} · {{totalServers}} servers on shard {{shardNumber}}/{{totalShards}}',\n *   type: 'Playing',\n * }, { version: '2.0.0' });\n */\ninterface ShardActivityProps {\n  [key: string]: string | number | boolean | undefined;\n}\n//# sourceMappingURL=shard-activity-props.interface.d.ts.map\n//#endregion\n//#region src/client/interfaces/shard-override.interface.d.ts\ntype PresenceStatus = NonNullable<PresenceOptions['status']>;\ninterface ShardOverride {\n  status?: PresenceStatus;\n  activities?: Array<ActivityOptions>;\n  customProps?: Record<string, string | number | boolean | undefined>;\n}\n//# sourceMappingURL=shard-override.interface.d.ts.map\n//#endregion\n//#region src/client/types/intent-presets.type.d.ts\ndeclare enum IntentPreset {\n  Minimal = \"minimal\",\n  Standard = \"standard\",\n  WithMessageContent = \"with_message_content\",\n  AllNonPrivileged = \"all_non_privileged\",\n  All = \"all\",\n}\ndeclare function resolveIntents(preset: IntentPreset): Array<GatewayIntentBits>;\n//# sourceMappingURL=intent-presets.type.d.ts.map\n//#endregion\n//#region src/client/types/parent-hook.type.d.ts\ntype ParentHook = (manager: ShardingManager) => Promise<void> | void;\n//# sourceMappingURL=parent-hook.type.d.ts.map\n\n//#endregion\n//#region src/application/spraxium.application.d.ts\ndeclare class SpraxiumApplication {\n  private readonly options;\n  private readonly startedAt;\n  private readonly state;\n  private booted;\n  constructor(options: SpraxiumOptions, startedAt: number);\n  useModule(module: Constructor$1): this;\n  intents(preset: IntentPreset | Array<GatewayIntentBits>): this;\n  addIntents(...bits: Array<GatewayIntentBits>): this;\n  initPresence(config: PresenceOptions): this;\n  useSharding(options: ShardOptions): this;\n  partials(...names: Array<keyof typeof Partials>): this;\n  /**\n   * Registers a pre-built instance in the root DI container under the given token.\n   * Use this to inject value-providers such as validated environment schemas.\n   *\n   * Chainable. Must be called before `listen()`.\n   *\n   * @example\n   *   const env = EnvValidator.validate(AppEnv);\n   *   SpraxiumFactory.create({ token: env.token })\n   *     .useModule(AppModule)\n   *     .provide(AppEnv, env)\n   *     .listen();\n   */\n  provide(token: unknown, instance: unknown): this;\n  /**\n   * Registers a guard to be applied globally , before every command handler,\n   * regardless of class- or method-level @UseGuards().\n   *\n   * Chainable: call multiple times to stack global guards in registration order.\n   *\n   * @example\n   *   app.useGlobalGuards(GuildOnly);\n   *   app.useGlobalGuards(OwnerOnly, { ownerIds: ['123456789012345678'] });\n   */\n  useGlobalGuards(guardClass: new () => SpraxiumGuard, options?: Record<string, unknown>): this;\n  /**\n   * Forces slash command registration with the Discord REST API, bypassing the\n   * dev-mode hash cache. Useful after modifying commands at runtime without\n   * restarting the application.\n   *\n   * No-op if the application has not yet booted or has no slash commands.\n   */\n  forceRegisterSlashCommands(): Promise<void>;\n  listen(): Promise<void>;\n  private loadConfig;\n  private resolveToken;\n  private trySpawnShards;\n  private loadModules;\n  private runBootHooks;\n  private buildClient;\n  private wireClient;\n  private resolvePrefixConfig;\n  private validateMessageContentIntent;\n  private static readonly READY_TIMEOUT_MS;\n  private waitForReady;\n  private loginAndAwaitReady;\n}\n//# sourceMappingURL=spraxium.application.d.ts.map\n//#endregion\n//#region src/application/spraxium.factory.d.ts\ndeclare class SpraxiumFactory {\n  static create(options?: SpraxiumOptions): Promise<SpraxiumApplication>;\n}\n//# sourceMappingURL=spraxium.factory.d.ts.map\n//#endregion\n//#region src/client/client.factory.d.ts\ndeclare class ClientFactory {\n  static create(options: SpraxiumOptions): Client;\n}\n//# sourceMappingURL=client.factory.d.ts.map\n//#endregion\n//#region src/client/parent-hook.registry.d.ts\ndeclare class ParentHookRegistry {\n  private static readonly hooks;\n  static register(hook: ParentHook): void;\n  static unregister(hook: ParentHook): void;\n  static run(manager: ShardingManager): Promise<void>;\n}\n//# sourceMappingURL=parent-hook.registry.d.ts.map\n\n//#endregion\n//#region src/client/presence.manager.d.ts\n/**\n * Static presence management API , accessible from anywhere in the application.\n *\n * Activity names support `{{key}}` placeholder interpolation. The following\n * built-in variables are automatically resolved from the Discord client on every\n * presence update , no need to pass them manually:\n *\n *   {{shardId}}       , Current shard ID (0-based)\n *   {{shardNumber}}   , Current shard number (1-based)\n *   {{totalShards}}   , Total number of shards\n *   {{totalServers}}  , Number of guilds on this shard\n *   {{ping}}          , WebSocket heartbeat latency (ms)\n *\n * Additional custom variables can be supplied via setShardActivity().\n *\n * @example\n * PresenceManager.setActivity({ name: 'Watching {{totalServers}} servers', type: 'Watching' })\n * PresenceManager.startRotation([...activities], 30_000)\n * PresenceManager.setShardActivity(0, { name: 'Shard {{shardNumber}}/{{totalShards}}', type: 'Playing' })\n */\ndeclare class PresenceManager {\n  private static client;\n  private static bootPresence;\n  private static rotationTimer;\n  private static rotationIndex;\n  private static rotationList;\n  private static currentStatus;\n  private static currentActivity;\n  private static shardOverrides;\n  /**\n   * @internal , Called once by SpraxiumApplication inside client.once('ready').\n   * Application code must never call this directly.\n   */\n  static initialize(client: Client<true>, presence?: PresenceOptions): void;\n  private static assertReady;\n  /** Resolves the built-in {{key}} variables from the current client state. */\n  private static buildBuiltInProps;\n  /**\n   * Resolves `{{key}}` placeholders in an activity name.\n   * Built-in props are always injected; customProps are merged on top.\n   */\n  private static resolveActivity;\n  /**\n   * Applies the current in-memory presence state to the Discord client.\n   * Built-in `{{key}}` placeholders are re-resolved on every call so values\n   * like {{totalServers}} stay up-to-date.\n   * @internal\n   */\n  static applyPresence(): void;\n  /** Updates only the status indicator without touching the current activity. */\n  static setStatus(status: PresenceStatus): void;\n  /** Replaces the current activity without touching the status. */\n  static setActivity(activity: ActivityOptions): void;\n  /** Sets status and/or activities in one call. */\n  static setPresence(options: Pick<PresenceOptions, 'status' | 'activities'>): void;\n  /**\n   * Starts (or replaces) automatic activity rotation.\n   * Any existing rotation is stopped first.\n   * The interval is unref()'d so it never blocks clean shutdown.\n   */\n  static startRotation(activities: Array<ActivityOptions>, intervalMs: number): void;\n  /** Clears the rotation interval. The last active activity is kept. */\n  static stopRotation(): void;\n  /**\n   * Restores the exact presence configured at boot time.\n   * Per-shard runtime overrides are NOT cleared , call clearShardPresence(id) first\n   * if you want a full reset.\n   */\n  static reset(): void;\n  /**\n   * Sets a presence override for a specific shard ID.\n   * On the matching shard process, this overrides the global presence for\n   * every subsequent applyPresence() call.\n   */\n  static setShardPresence(shardId: number, options: Partial<Pick<PresenceOptions, 'status' | 'activities'>>): void;\n  /** Removes the override for a specific shard, falling back to the global presence. */\n  static clearShardPresence(shardId: number): void;\n  /**\n   * Sets the activity for a specific shard with optional custom `{{key}}` props.\n   * Built-in props ({{totalServers}}, {{shardNumber}}, etc.) are always available\n   * and do not need to be passed in `customProps`.\n   *\n   * @example\n   * PresenceManager.setShardActivity(0, {\n   *   name: 'v{{version}} · {{totalServers}} servers on shard {{shardNumber}}/{{totalShards}}',\n   *   type: 'Playing',\n   * }, { version: '2.0.0' });\n   */\n  static setShardActivity(shardId: number, activity: ActivityOptions, customProps?: ShardActivityProps): void;\n  /** Removes only the activity override for a specific shard, keeping any status override. */\n  static clearShardActivity(shardId: number): void;\n}\n//# sourceMappingURL=presence.manager.d.ts.map\n//#endregion\n//#region src/client/shard.manager.d.ts\ndeclare class SpraxiumShardManager {\n  private readonly options;\n  private readonly token;\n  private manager;\n  constructor(options: ShardOptions, token: string);\n  spawn(startedAt: number): Promise<void>;\n  private handleSpawnError;\n  private extractResponse;\n  private resolveScriptPath;\n  private buildExecArgv;\n  private registerShutdownHandlers;\n}\n//# sourceMappingURL=shard.manager.d.ts.map\n//#endregion\n//#region src/client/shard.util.d.ts\n/**\n * Returns `true` when the current process was spawned by a discord.js\n * ShardingManager (i.e. it is a shard child process).\n *\n * discord.js injects the `SHARDS` environment variable into every child\n * process it spawns, so this is a reliable way to detect shard workers.\n */\ndeclare function isShardChild(): boolean;\n//# sourceMappingURL=shard.util.d.ts.map\n//#endregion\n//#region src/client/constants/activity.constant.d.ts\ndeclare const ACTIVITY_TYPE_MAP: Record<ActivityOptions['type'], ActivityType>;\n//# sourceMappingURL=activity.constant.d.ts.map\n//#endregion\n//#region src/client/constants/defaults.constant.d.ts\ndeclare const DEFAULT_PARTIALS: Array<Partials>;\n//# sourceMappingURL=defaults.constant.d.ts.map\n//#endregion\n//#region src/client/constants/intents.constant.d.ts\ndeclare const ALL_NON_PRIVILEGED_INTENTS: Array<GatewayIntentBits>;\ndeclare const PRIVILEGED_INTENTS: Array<GatewayIntentBits>;\n//# sourceMappingURL=intents.constant.d.ts.map\n//#endregion\n//#region src/client/constants/shard.constant.d.ts\ndeclare const DEFAULT_SPAWN_DELAY = 5500;\n//# sourceMappingURL=shard.constant.d.ts.map\n\n//#endregion\n//#region ../logger/dist/index.d.ts\n//#region src/interfaces/log-level.type.d.ts\n/** Built-in log levels recognized by all transports. */\ntype BuiltInLogLevel = 'info' | 'success' | 'warn' | 'error' | 'debug' | 'command';\n/** Any built-in level, or an arbitrary custom string level. */\ntype LogLevel = BuiltInLogLevel | (string & {});\n//# sourceMappingURL=log-level.type.d.ts.map\n//#endregion\n//#region src/interfaces/log-color.type.d.ts\n/** A named ANSI color key, mapping to an `ANSI.*` function. */\ntype LogColor = 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'gray' | 'white' | 'redBright' | 'greenBright' | 'yellowBright' | 'blueBright' | 'magentaBright' | 'cyanBright' | 'whiteBright';\n/**\n * Accepted color input for custom log levels.\n * Either a named color string or a raw ANSI escape sequence wrapper function.\n */\ntype LogColorInput = LogColor | ((text: string) => string);\n//# sourceMappingURL=log-color.type.d.ts.map\n//#endregion\n//#region src/interfaces/log-fn.type.d.ts\n/** A convenience callable returned by `logger.extend()`. */\n\n//# sourceMappingURL=log-transport.interface.d.ts.map\n//#endregion\n//#region src/interfaces/custom-log-level.interface.d.ts\n/** Definition of a custom log level and the console color to render it with. */\ninterface CustomLogLevel {\n  name: string;\n  color: LogColorInput;\n}\n//# sourceMappingURL=custom-log-level.interface.d.ts.map\n//#endregion\n//#region src/interfaces/discord-embed-template.interface.d.ts\ninterface EmbedFooterTemplate {\n  text: string;\n}\ninterface EmbedThumbnailTemplate {\n  url: string;\n}\ninterface EmbedFieldTemplate {\n  name: string;\n  value: string;\n  inline?: boolean;\n}\n/** Template used to build Discord embed log messages. Supports `{{variable}}` interpolation. */\ninterface DiscordEmbedTemplate {\n  title?: string;\n  description?: string;\n  color?: number;\n  footer?: EmbedFooterTemplate;\n  timestamp?: boolean;\n  thumbnail?: EmbedThumbnailTemplate;\n  fields?: Array<EmbedFieldTemplate>;\n}\n//# sourceMappingURL=discord-embed-template.interface.d.ts.map\n//#endregion\n//#region src/interfaces/discord-transport-config.interface.d.ts\ninterface DiscordTransportConfig {\n  /** Whether to post to a webhook URL or a channel via the bot client. */\n  type: 'webhook' | 'channel';\n  /**\n   * Discord webhook URL.\n   * Required when `type` is `'webhook'`.\n   * Treat this value as a secret — never log it.\n   */\n  webhookUrl?: string;\n  /**\n   * Discord channel ID to post to via the bot client.\n   * Required when `type` is `'channel'`.\n   */\n  channelId?: string;\n  /** Log levels that will be forwarded to Discord. */\n  levels: Array<LogLevel>;\n  /** Optional embed template. Uses a sensible default when omitted. */\n  embed?: DiscordEmbedTemplate;\n}\n//# sourceMappingURL=discord-transport-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/sendable-channel.interface.d.ts\n/** Minimal interface for a Discord text channel or DM channel that can receive messages. */\n\n//# sourceMappingURL=sendable-channel.interface.d.ts.map\n//#endregion\n//#region src/utils/date-time.util.d.ts\n/** Built-in named timestamp formats. */\ntype TimestampFormat = 'default' | 'iso' | 'time-only' | ((d: Date) => string);\n//#endregion\n//#region src/utils/token-masker.util.d.ts\n/**\n * Scans log message strings for patterns that match a Discord bot token and\n * replaces them with `[REDACTED]`.\n *\n * Security: masking is applied before any transport receives the entry, so\n * tokens never reach remote transports (webhooks, channels, etc.).\n */\n\n//# sourceMappingURL=table-builder.util.d.ts.map\n//#endregion\n//#region src/interfaces/spraxium-logger-config.interface.d.ts\ninterface SpraxiumLoggerConfig {\n  /** Custom log levels to register alongside the built-in set. */\n  levels?: Array<CustomLogLevel>;\n  /**\n   * Whether to scan log messages for Discord bot token patterns and replace\n   * them with `[REDACTED]`. Defaults to `true`.\n   */\n  maskTokens?: boolean;\n  /** When `true`, registers a listener that logs every slash command execution. */\n  commandLogging?: boolean;\n  /** Attach a Discord webhook or channel transport. */\n  discord?: DiscordTransportConfig;\n  /**\n   * Controls how the timestamp prefix is rendered in console output.\n   *\n   * - `'default'`   - `DD/MM/YYYY - HH:MM:SS` (default)\n   * - `'iso'`       - ISO 8601: `2026-05-02T14:30:00.000Z`\n   * - `'time-only'` - `HH:MM:SS`\n   * - `(d) => string` - custom formatter\n   */\n  timestampFormat?: TimestampFormat;\n  /**\n   * BCP 47 locale tag used when formatting the time portion of log timestamps.\n   * Defaults to `'en-US'`. Example: `'pt-BR'` to produce `HH:MM:SS` in a\n   * Brazilian Portuguese ICU table.\n   */\n  timestampLocale?: string;\n}\n//# sourceMappingURL=spraxium-logger-config.interface.d.ts.map\n//#endregion\n//#region src/services/logger.service.d.ts\n//#endregion\n//#region src/exceptions/types/exception-layout-class.type.d.ts\n/**\n * Loose constructor type for exception layouts.\n *\n * Kept loose (using `any`) to avoid a circular import: the full\n * ExceptionLayout interface with proper generic types lives in\n * exception-layout.interface.ts, which imports SpraxiumException.\n */\ntype ExceptionLayoutClass = new () => {\n  build(exception: any, ctx: any): any;\n};\n//# sourceMappingURL=exception-layout-class.type.d.ts.map\n//#endregion\n//#region src/exceptions/types/layout-fn.type.d.ts\ntype LayoutFn = (exception: SpraxiumException, ctx: ExecutionContext) => ExceptionLayoutPayload | Promise<ExceptionLayoutPayload>;\n//# sourceMappingURL=layout-fn.type.d.ts.map\n\n//#endregion\n//#region src/exceptions/spraxium.exception.d.ts\n/**\n * Base class for all Spraxium exceptions.\n *\n * Extend this to create typed, domain-specific exceptions that plug into\n * the automatic exception handler, layout resolution, and placeholder engine.\n *\n * @example\n * export class CooldownException extends SpraxiumException {\n *   constructor(props?: { seconds?: number }) {\n *     super({ code: 'COOLDOWN', props });\n *   }\n * }\n *\n * // At the throw site , no embed/content logic here:\n * throw new CooldownException({ seconds: 10 });\n */\ndeclare class SpraxiumException extends Error {\n  readonly code: string;\n  readonly props: Record<string, unknown>;\n  readonly shouldReply: boolean;\n  readonly shouldLog: boolean;\n  readonly layout?: ExceptionLayoutClass;\n  constructor(options: SpraxiumExceptionOptions);\n}\n//# sourceMappingURL=spraxium.exception.d.ts.map\n//#endregion\n//#region src/exceptions/interfaces/exception-layout.interface.d.ts\n/** Subset of MessageFlags valid in InteractionReplyOptions / followUp. */\ntype InteractionFlag = MessageFlags.Ephemeral | MessageFlags.SuppressEmbeds | MessageFlags.SuppressNotifications | MessageFlags.IsComponentsV2;\n/**\n * The Discord-compatible reply payload produced by an exception layout.\n *\n * All fields are optional , a layout may return just `content`, just `embeds`,\n * or any combination. When `ephemeral` is omitted it defaults to `true`.\n */\ninterface ExceptionLayoutPayload {\n  content?: string;\n  embeds?: Array<EmbedBuilder>;\n  components?: Array<ActionRowBuilder<any>>;\n  /** Whether the reply is visible only to the triggering user. Defaults to true. */\n  ephemeral?: boolean;\n  flags?: InteractionFlag;\n}\n/**\n * Contract for exception layout classes.\n *\n * A layout translates a thrown exception + its execution context into a\n * Discord reply payload. Keep layout classes focused on presentation only.\n *\n * @example\n * class CooldownLayout implements ExceptionLayout {\n *   build(ex: SpraxiumException): ExceptionLayoutPayload {\n *     return {\n *       embeds: [new EmbedBuilder().setDescription(`Wait **${ex.props.seconds}s**`)],\n *       ephemeral: true,\n *     };\n *   }\n * }\n *\n * // Or use the factory (no class needed):\n * const CooldownLayout = defineExceptionLayout((ex) => ({\n *   embeds: [new EmbedBuilder().setDescription(`Wait **${ex.props.seconds}s**`)],\n *   ephemeral: true,\n * }));\n */\ninterface ExceptionLayout {\n  build(exception: SpraxiumException, ctx: ExecutionContext): ExceptionLayoutPayload | Promise<ExceptionLayoutPayload>;\n}\n/**\n * Maps exception class names (or 'default') to layout constructor classes.\n *\n * Resolution order:\n *   1. `exception.layout` , per-instance override in the throw/constructor\n *   2. `layouts[ExceptionClassName]` , layout mapped to this exception type\n *   3. `@WithLayout(LayoutClass)` , decorator on the exception class itself\n *   4. `layouts.default` , global user-configured fallback\n *   5. `DefaultExceptionLayout` , framework built-in fallback (always present)\n *\n * @example\n * exceptions: {\n *   layouts: {\n *     default: MyErrorLayout,\n *     CooldownException: CooldownEmbedLayout,\n *     PremiumOnlyException: PremiumAccessLayout,\n *   }\n * }\n */\ntype ExceptionLayoutMap = {\n  default?: ExceptionLayoutClass;\n  [exceptionName: string]: ExceptionLayoutClass | undefined;\n};\n/**\n * Exception configuration block accepted by SpraxiumOptions.\n */\ninterface ExceptionOptions {\n  /**\n   * Map of exception class names → layout classes.\n   * Fallback resolution: per-instance > this map > @WithLayout > built-in default.\n   */\n  layouts?: ExceptionLayoutMap;\n  /**\n   * Log unknown (non-SpraxiumException) errors to the framework logger.\n   * @default true\n   */\n  logUnhandled?: boolean;\n}\ninterface SpraxiumExceptionOptions {\n  /**\n   * Stable machine-readable identifier for this exception type.\n   * Used in logs and consumed by layout's {{code}} placeholder.\n   * @example 'COOLDOWN', 'GUARD_DENIED', 'PERMISSION_DENIED'\n   */\n  code: string;\n  /**\n   * Human-readable description. Supports {{placeholder}} interpolation.\n   * NOT automatically shown to users , the layout decides what to display.\n   * @example 'Wait {{seconds}}s before using this command again.'\n   */\n  message?: string;\n  /**\n   * Runtime props injected at the throw site.\n   * Available to the placeholder engine and to layouts.\n   * @example { seconds: 10 }\n   */\n  props?: Record<string, unknown>;\n  /**\n   * Whether the exception handler should send a Discord reply.\n   * @default true\n   */\n  shouldReply?: boolean;\n  /**\n   * Whether the exception handler should write to the logger.\n   * @default false\n   */\n  shouldLog?: boolean;\n  /**\n   * Per-instance layout override. Takes priority over everything else\n   * including @WithLayout and the global exception config map.\n   */\n  layout?: ExceptionLayoutClass;\n}\n//#endregion\n//#region src/config/interfaces/config.interface.d.ts\ninterface SpraxiumPlugin<N extends string = string, C = unknown> {\n  readonly namespace: N;\n  readonly config: C;\n}\ntype PluginFactory<N extends string, C> = ((config: C) => SpraxiumPlugin<N, C>) & {\n  readonly namespace: N;\n};\ninterface SpraxiumDevConfig {\n  /** Main entry file relative to project root. @default 'src/main.ts' */\n  entrypoint?: string;\n  /** Additional directories or files to watch for hot reload. */\n  include?: Array<string>;\n  /** Relative path patterns to skip when watching src/ (matched via String.includes). */\n  exclude?: Array<string>;\n  /** Milliseconds to wait before restarting after a detected change. @default 300 */\n  debounce?: number;\n}\ninterface SpraxiumCoreConfig {\n  debug?: boolean;\n  plugins?: Array<SpraxiumPlugin>;\n  dev?: SpraxiumDevConfig;\n  logger?: SpraxiumLoggerConfig;\n  /**\n   * Exception handler configuration , layout mapping and logging behavior.\n   *\n   * Declare here (in `spraxium.config.ts`) rather than in the bootstrap options.\n   *\n   * @example\n   * exceptions: {\n   *   layouts: { default: MyErrorLayout, CooldownException: CooldownEmbedLayout }\n   * }\n   */\n  exceptions?: ExceptionOptions;\n  /**\n   * Prefix command subsystem configuration.\n   *\n   * @example\n   * prefix: {\n   *   prefix: '!',\n   *   guildPrefix: async (guildId) => db.getPrefix(guildId),\n   *   caseSensitive: false,\n   *   mentionPrefix: true,\n   *   defaultCooldown: 3,\n   * }\n   */\n  prefix?: PrefixConfig;\n}\ninterface ConfigEnv {\n  mode: 'development' | 'neutral' | 'production';\n  isDev: boolean;\n  isNeutral: boolean;\n  isProd: boolean;\n}\ntype SpraxiumConfigInput = SpraxiumCoreConfig;\ntype SpraxiumConfigFn = (env: ConfigEnv) => SpraxiumConfigInput;\ntype SpraxiumConfigExport = SpraxiumConfigInput | SpraxiumConfigFn;\n//# sourceMappingURL=config.interface.d.ts.map\n//#endregion\n//#region src/config/define-config.helper.d.ts\n/**\n * Define Spraxium configuration.\n *\n * @example\n * ```ts\n * import { defineConfig } from '@spraxium/core';\n * import { analytics } from '@spraxium/analytics';\n *\n * export default defineConfig({\n *   debug: true,\n *   plugins: [\n *     analytics({ enabled: true, trackingId: 'GA-123' }),\n *   ],\n * });\n * ```\n */\ndeclare function defineConfig(config: SpraxiumConfigInput | ((env: ConfigEnv) => SpraxiumConfigInput)): SpraxiumConfigExport;\n//# sourceMappingURL=define-config.helper.d.ts.map\n//#endregion\n//#region src/config/define-plugin.helper.d.ts\n/**\n * Creates a typed plugin factory for use in `defineConfig({ plugins: [...] })`.\n *\n * @example\n * ```ts\n * // In your plugin package:\n * export const analytics = definePlugin<'analytics', AnalyticsConfig>('analytics');\n *\n * // In spraxium.config.ts:\n * import { analytics } from '@spraxium/analytics';\n * export default defineConfig({\n *   plugins: [analytics({ enabled: true })],\n * });\n *\n * // In your service:\n * const config = ConfigStore.getPluginConfig(analytics); // typed as AnalyticsConfig | undefined\n * ```\n */\ndeclare function definePlugin<N extends string, C = unknown>(namespace: N): PluginFactory<N, C>;\n//# sourceMappingURL=define-plugin.helper.d.ts.map\n//#endregion\n//#region src/config/config.store.d.ts\ndeclare class ConfigStore {\n  private static config;\n  static load(config: SpraxiumCoreConfig): void;\n  static getCoreConfig(): Omit<SpraxiumCoreConfig, 'plugins'>;\n  static getPluginConfig<N extends string, C>(factory: PluginFactory<N, C>): C | undefined;\n  static getRaw(): Readonly<SpraxiumCoreConfig>;\n  static reset(): void;\n}\n//# sourceMappingURL=config.store.d.ts.map\n//#endregion\n//#region src/config/config.loader.d.ts\ndeclare class ConfigLoader {\n  static load(projectRoot?: string): Promise<SpraxiumConfigInput>;\n  private static findConfigFile;\n  private static resolveEnv;\n}\n//# sourceMappingURL=config.loader.d.ts.map\n//#endregion\n//#region src/context/execution.context.d.ts\ndeclare class SpraxiumExecutionContext implements ExecutionContext {\n  private readonly raw;\n  private readonly commandName;\n  constructor(raw: BaseInteraction | Message, commandName: string);\n  getUserId(): string;\n  getUser(): User;\n  getGuildId(): string | null;\n  getChannelId(): string;\n  getCommandName(): string;\n  getMember(): GuildMember | APIInteractionGuildMember | null;\n  getMemberPermissions(): Readonly<PermissionsBitField> | null;\n  getInteraction(): BaseInteraction | Message;\n  isSlashCommand(): boolean;\n  isPrefixCommand(): boolean;\n}\n//# sourceMappingURL=execution.context.d.ts.map\n//#endregion\n//#region src/exceptions/layout.registry.d.ts\ndeclare class LayoutRegistry {\n  static resolve(exception: SpraxiumException, map?: ExceptionLayoutMap): ExceptionLayout;\n  static resolveClass(exception: SpraxiumException, map?: ExceptionLayoutMap): ExceptionLayoutClass;\n}\n//# sourceMappingURL=layout.registry.d.ts.map\n\n//#endregion\n//#region src/exceptions/exception.handler.d.ts\n/**\n * Central exception handler for the Spraxium interaction pipeline.\n *\n * Responsibilities (in order):\n *   1. Normalize any thrown value → SpraxiumException\n *   2. Log if `shouldLog` is true on the exception\n *   3. Resolve the correct layout via LayoutRegistry\n *   4. Build the Discord reply payload\n *   5. Send the reply via DiscordReplyStrategy\n *\n * Steps 3–5 are individually guarded , a layout/reply failure will never\n * propagate out or produce a secondary unhandled rejection.\n */\ndeclare class ExceptionHandler {\n  /**\n   * Handles a caught error from the command or guard pipeline.\n   *\n   * @param err      The raw caught value (any type).\n   * @param ctx      The execution context active when the error was thrown.\n   * @param options  User-configured exception options (layouts, logUnhandled).\n   */\n  static handle(err: unknown, ctx: ExecutionContext, options?: ExceptionOptions): Promise<void>;\n  /**\n   * Normalizes any thrown value into a SpraxiumException.\n   * Native SpraxiumExceptions pass through unchanged.\n   * Everything else is wrapped in an InternalException.\n   */\n  private static normalize;\n  private static logException;\n}\n//# sourceMappingURL=exception.handler.d.ts.map\n//#endregion\n//#region src/exceptions/define-exception-layout.helper.d.ts\n/**\n * Creates an ExceptionLayout class from a plain function.\n *\n * Use this when you don't want to write a full class. The returned value\n * is a proper constructor and can be used anywhere a layout class is expected:\n * in `@WithLayout`, in `exceptions.layouts`, or as a per-instance override.\n *\n * @example\n * const CooldownLayout = defineExceptionLayout((ex) => ({\n *   embeds: [\n *     new EmbedBuilder()\n *       .setColor(0xff6b6b)\n *       .setDescription(`⏳ Wait **${ex.props.seconds}s** and try again.`),\n *   ],\n *   ephemeral: true,\n * }));\n *\n * @WithLayout(CooldownLayout)\n * export class CooldownException extends SpraxiumException { ... }\n */\ndeclare function defineExceptionLayout(fn: LayoutFn): ExceptionLayoutClass;\n//# sourceMappingURL=define-exception-layout.helper.d.ts.map\n//#endregion\n//#region src/exceptions/layouts/default.exception-layout.d.ts\n/**\n * Built-in fallback layout used when no custom layout is registered.\n *\n * Renders a minimal ephemeral red embed with the exception message\n * after resolving any {{placeholder}} tokens against the exception's props.\n *\n * Replace this globally by registering `default` in `exceptions.layouts`:\n * @example\n * exceptions: { layouts: { default: MyCompanyErrorLayout } }\n */\ndeclare class DefaultExceptionLayout implements ExceptionLayout {\n  build(exception: SpraxiumException): ExceptionLayoutPayload;\n}\n//# sourceMappingURL=default.exception-layout.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/argument.exception.d.ts\n/**\n * Thrown when the user provides invalid or missing arguments to a prefix command.\n *\n * The exception handler will render a usage/error layout with the following\n * {{placeholder}} variables available:\n * - `{{command}}` , the command name\n * - `{{expected}}` , the expected argument type\n * - `{{received}}` , the raw input received\n * - `{{usage}}` , the full usage string\n * - `{{argument}}` , the argument name\n */\ndeclare class ArgumentException extends SpraxiumException {\n  constructor(props?: Record<string, unknown>);\n}\n//# sourceMappingURL=argument.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/command-not-found.exception.d.ts\n/**\n * Thrown when no handler is found for a recognized prefix command.\n * Can be caught by a fallback layout to show a \"command not found\" message.\n *\n * Available {{placeholder}} variables:\n * - `{{command}}` , the attempted command name\n * - `{{prefix}}` , the prefix that was used\n */\ndeclare class CommandNotFoundException extends SpraxiumException {\n  constructor(props?: Record<string, unknown>);\n}\n//# sourceMappingURL=command-not-found.exception.d.ts.map\n\n//#endregion\n//#region src/exceptions/built-in/configuration.exception.d.ts\n/**\n * Thrown when a configuration error is detected at runtime.\n *\n * Does NOT reply to the user , configuration issues are operational concerns\n * that belong in logs, not in Discord messages.\n *\n * Available props in layout templates:\n * - `{{key}}` , the config key that is invalid or missing\n * - `{{reason}}` , description of the problem\n *\n * @example\n * throw new ConfigurationException({ key: 'clientId', reason: 'must be a valid Discord snowflake' });\n */\ndeclare class ConfigurationException extends SpraxiumException {\n  constructor(props?: {\n    key?: string;\n    reason?: string;\n  } & Record<string, unknown>);\n}\n//# sourceMappingURL=configuration.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/cooldown.exception.d.ts\n/**\n * Thrown when a user triggers a command cooldown.\n *\n * Available props in layout templates:\n * - `{{seconds}}` , remaining wait time in seconds\n *\n * @example\n * throw new CooldownException({ seconds: 10 });\n */\ndeclare class CooldownException extends SpraxiumException {\n  constructor(props?: {\n    seconds?: number;\n  } & Record<string, unknown>);\n}\n//# sourceMappingURL=cooldown.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/dm-only.exception.d.ts\n/**\n * Thrown when a command is used in a server but requires a DM context.\n *\n * Used by the built-in `DMOnly` guard and can be thrown manually.\n *\n * @example\n * throw new DMOnlyException();\n */\ndeclare class DMOnlyException extends SpraxiumException {\n  constructor(props?: Record<string, unknown>);\n}\n//# sourceMappingURL=dm-only.exception.d.ts.map\n\n//#endregion\n//#region src/exceptions/built-in/guard-denied.exception.d.ts\n/**\n * Thrown when a guard denies access to a command.\n *\n * Prefer throwing this over returning `false` when you want the exception\n * system to handle the reply , it keeps guards lean and reply logic out of guard code.\n *\n * Available props in layout templates:\n * - `{{guardName}}` , the class name of the guard that denied (optional)\n * - `{{reason}}` , machine-readable reason string (optional)\n *\n * @example\n * async canActivate(ctx: ExecutionContext): Promise<boolean> {\n *   if (!ctx.getGuildId()) throw new GuardDeniedException({ guardName: 'GuildOnly' });\n *   return true;\n * }\n */\ndeclare class GuardDeniedException extends SpraxiumException {\n  constructor(props?: {\n    guardName?: string;\n    reason?: string;\n  } & Record<string, unknown>);\n}\n//# sourceMappingURL=guard-denied.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/guild-only.exception.d.ts\n/**\n * Thrown when a command is used in a DM but requires a guild (server) context.\n *\n * Used by the built-in `GuildOnly` guard and can be thrown manually.\n *\n * @example\n * throw new GuildOnlyException();\n */\ndeclare class GuildOnlyException extends SpraxiumException {\n  constructor(props?: Record<string, unknown>);\n}\n//# sourceMappingURL=guild-only.exception.d.ts.map\n\n//#endregion\n//#region src/exceptions/built-in/internal.exception.d.ts\n/**\n * Thrown for unexpected internal errors.\n *\n * Replies with a generic user-facing message to avoid leaking implementation\n * details. The original error cause is always logged via the framework logger.\n *\n * Available props in layout templates:\n * - `{{cause}}` , the raw error message (NOT shown to users by default layout)\n *\n * @example\n * try {\n *   await someRiskyOperation();\n * } catch (err) {\n *   throw new InternalException({ cause: err instanceof Error ? err.message : String(err) });\n * }\n */\ndeclare class InternalException extends SpraxiumException {\n  constructor(props?: {\n    cause?: string;\n  } & Record<string, unknown>);\n}\n//# sourceMappingURL=internal.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/maintenance.exception.d.ts\n/**\n * Thrown when the bot or a specific feature is under maintenance.\n *\n * Available props in layout templates:\n * - `{{feature}}` , name of the feature under maintenance (optional)\n * - `{{eta}}` , estimated time for completion (optional)\n *\n * @example\n * throw new MaintenanceException({ feature: 'Economy', eta: '30 minutes' });\n */\ndeclare class MaintenanceException extends SpraxiumException {\n  constructor(props?: {\n    feature?: string;\n    eta?: string;\n  } & Record<string, unknown>);\n}\n//# sourceMappingURL=maintenance.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/nsfw-only.exception.d.ts\n/**\n * Thrown when a command is used in a non-NSFW channel but requires one.\n *\n * Used by the built-in `NSFWGuard` and can be thrown manually.\n *\n * @example\n * throw new NsfwOnlyException();\n */\ndeclare class NsfwOnlyException extends SpraxiumException {\n  constructor(props?: Record<string, unknown>);\n}\n//# sourceMappingURL=nsfw-only.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/owner-only.exception.d.ts\n/**\n * Thrown when a command is restricted to the bot owner(s).\n *\n * Used by the built-in `OwnerOnly` guard and can be thrown manually.\n *\n * @example\n * throw new OwnerOnlyException();\n */\ndeclare class OwnerOnlyException extends SpraxiumException {\n  constructor(props?: Record<string, unknown>);\n}\n//# sourceMappingURL=owner-only.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/permission-denied.exception.d.ts\n/**\n * Thrown when the user lacks Discord permissions required for this command.\n *\n * Available props in layout templates:\n * - `{{permission}}` , the required Discord permission name (optional)\n *\n * @example\n * throw new PermissionDeniedException({ permission: 'BanMembers' });\n */\ndeclare class PermissionDeniedException extends SpraxiumException {\n  constructor(props?: {\n    permission?: string;\n  } & Record<string, unknown>);\n}\n//# sourceMappingURL=permission-denied.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/premium-only.exception.d.ts\n/**\n * Thrown when a feature or command requires a premium subscription or role.\n *\n * Available props in layout templates:\n * - `{{tier}}` , the required plan/tier name (optional, e.g. 'Pro', 'Premium')\n *\n * @example\n * throw new PremiumOnlyException({ tier: 'Pro' });\n */\ndeclare class PremiumOnlyException extends SpraxiumException {\n  constructor(props?: {\n    tier?: string;\n  } & Record<string, unknown>);\n}\n//# sourceMappingURL=premium-only.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/rate-limit.exception.d.ts\n/**\n * Thrown when the bot is being rate limited and cannot fulfill a request.\n *\n * Available props in layout templates:\n * - `{{retryAfter}}` , milliseconds until the rate limit resets (optional)\n * - `{{route}}` , the API route that was rate limited (optional)\n *\n * @example\n * throw new RateLimitException({ retryAfter: 5000 });\n */\ndeclare class RateLimitException extends SpraxiumException {\n  constructor(props?: {\n    retryAfter?: number;\n    route?: string;\n  } & Record<string, unknown>);\n}\n//# sourceMappingURL=rate-limit.exception.d.ts.map\n//#endregion\n//#region src/exceptions/built-in/validation.exception.d.ts\n/**\n * Thrown when user-supplied input fails validation.\n *\n * Available props in layout templates:\n * - `{{field}}` , the name of the invalid field\n * - `{{reason}}` , human-readable reason for the failure (optional)\n *\n * @example\n * throw new ValidationException({ field: 'username', reason: 'must be at least 3 characters' });\n */\ndeclare class ValidationException extends SpraxiumException {\n  constructor(props?: {\n    field?: string;\n    reason?: string;\n  } & Record<string, unknown>);\n}\n//# sourceMappingURL=validation.exception.d.ts.map\n//#endregion\n//#region src/guards/guard.registry.d.ts\ndeclare class GuardRegistry {\n  private static entries;\n  static register(guardClass: new () => SpraxiumGuard, options?: Record<string, unknown>): void;\n  static getAll(): Array<GuardEntry>;\n  static clear(): void;\n}\n//# sourceMappingURL=guard.registry.d.ts.map\n//#endregion\n//#region src/guards/guard.executor.d.ts\ndeclare class GuardExecutor {\n  static execute(ctor: new (...args: Array<unknown>) => unknown, method: string | symbol, ctx: ExecutionContext): Promise<boolean>;\n  private static runEntry;\n  private static resolveGuard;\n}\n//# sourceMappingURL=guard.executor.d.ts.map\n\n//#endregion\n//#region src/guards/built-in/guild-only.guard.d.ts\n/**\n * Blocks commands invoked outside of a guild (i.e. in a DM).\n *\n * @example\n *   @UseGuards(GuildOnly)\n *   @SlashCommandHandler(KickCommand)\n *   export class KickHandler { ... }\n */\ndeclare class GuildOnly implements SpraxiumGuard {\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=guild-only.guard.d.ts.map\n//#endregion\n//#region src/guards/built-in/dm-only.guard.d.ts\n/**\n * Blocks commands invoked inside a guild (i.e. only allows DMs).\n *\n * @example\n *   @UseGuards(DMOnly)\n *   @SlashCommandHandler(ProfileCommand)\n *   export class ProfileHandler { ... }\n */\ndeclare class DMOnly implements SpraxiumGuard {\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=dm-only.guard.d.ts.map\n//#endregion\n//#region src/guards/built-in/owner-only.guard.d.ts\n/**\n * Restricts a command to a predefined list of bot owner user IDs.\n *\n * @example , per command:\n *   @UseGuards(withOptions(OwnerOnly, { ownerIds: ['123456789012345678'] }))\n *\n * @example , global:\n *   app.useGlobalGuards(OwnerOnly, { ownerIds: process.env.OWNER_IDS?.split(',') ?? [] });\n */\ndeclare class OwnerOnly implements SpraxiumGuard {\n  ownerIds: Array<string>;\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=owner-only.guard.d.ts.map\n//#endregion\n//#region src/guards/built-in/permission.guard.d.ts\n/**\n * Checks that the invoking member has ALL of the listed Discord permissions.\n *\n * Works with all interaction types (ChatInput, Button, SelectMenu, Modal, etc.)\n * and Message-based handlers.\n *\n * @example\n *   @UseGuards(withOptions(PermissionGuard, { permissions: ['BanMembers', 'KickMembers'] }))\n */\ndeclare class PermissionGuard implements SpraxiumGuard {\n  permissions: Array<PermissionsString>;\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=permission.guard.d.ts.map\n//#endregion\n//#region src/guards/built-in/role.guard.d.ts\n/**\n * Checks that the invoking member has at least one of the listed role\n * names or role IDs.\n *\n * Works with all interaction types (ChatInput, Button, SelectMenu, Modal, etc.)\n * and Message-based handlers.\n *\n * @example\n *   @UseGuards(withOptions(RoleGuard, { roles: ['Moderator', '1234567890'] }))\n */\ndeclare class RoleGuard implements SpraxiumGuard {\n  roles: Array<string>;\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=role.guard.d.ts.map\n//#endregion\n//#region src/guards/built-in/cooldown.guard.d.ts\n/**\n * Rate-limits a command per user.\n * A user who triggers the command must wait `cooldown` milliseconds before\n * invoking it again.\n *\n * @example\n *   @UseGuards(withOptions(CooldownGuard, { cooldown: 5_000 }))\n *   export class PingHandler { ... }\n */\ndeclare class CooldownGuard implements SpraxiumGuard {\n  /** How long (in ms) the user must wait between invocations. */\n  cooldown: number;\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=cooldown.guard.d.ts.map\n//#endregion\n//#region src/guards/built-in/nsfw.guard.d.ts\n/**\n * Blocks commands invoked in non-NSFW channels.\n *\n * Works for both slash commands (ChatInputCommandInteraction) and prefix\n * commands (Message). Returns false when the channel type does not expose\n * an `nsfw` property (e.g. DM channels).\n *\n * @example\n *   @UseGuards(NSFWGuard)\n *   export class AdultContentHandler { ... }\n */\ndeclare class NSFWGuard implements SpraxiumGuard {\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=nsfw.guard.d.ts.map\n//#endregion\n//#region src/guards/built-in/no-bot.guard.d.ts\n/**\n * Blocks invocations from bot accounts.\n * Works with all interaction types and Message-based handlers.\n *\n * @example , per handler:\n *   @UseGuards(NoBotGuard)\n *   export class EchoPrefixHandler { ... }\n *\n * @example , global:\n *   app.useGlobalGuards(NoBotGuard);\n */\ndeclare class NoBotGuard implements SpraxiumGuard {\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=no-bot.guard.d.ts.map\n//#endregion\n//#region src/guards/built-in/thread-only.guard.d.ts\n/**\n * Allows the command only when invoked inside a thread channel\n * (public, private, or announcement thread).\n *\n * @example\n *   @UseGuards(ThreadOnlyGuard)\n *   export class ThreadSurveyHandler { ... }\n */\ndeclare class ThreadOnlyGuard implements SpraxiumGuard {\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=thread-only.guard.d.ts.map\n//#endregion\n//#region src/guards/built-in/voice-channel.guard.d.ts\n/**\n * Requires the invoking member to be connected to a voice channel.\n * Works with all interaction types and Message-based handlers.\n * Always returns false in DMs (no voice channels there).\n *\n * @example\n *   @UseGuards(VoiceChannelGuard)\n *   export class PlayMusicHandler { ... }\n */\ndeclare class VoiceChannelGuard implements SpraxiumGuard {\n  canActivate(ctx: ExecutionContext): boolean;\n}\n//# sourceMappingURL=voice-channel.guard.d.ts.map\n//#endregion\n//#region src/listeners/interfaces/handler.types.d.ts\ntype Constructor<T = unknown> = new (...args: Array<any>) => T;\ninterface ResolvedListenerEntry {\n  className: string;\n  event: string;\n  method: string;\n  once: boolean;\n}\n//#endregion\n//#region src/listeners/listener.dispatcher.d.ts\ndeclare class ListenerDispatcher {\n  private readonly registry;\n  private readonly invoker;\n  private readonly binder;\n  registerListener(ctor: Constructor, instance: unknown): void;\n  bind(client: Client): void;\n  getResolved(): Array<ResolvedListenerEntry>;\n  get size(): number;\n}\n//# sourceMappingURL=listener.dispatcher.d.ts.map\n//#endregion\n//#region src/utils/spraxium-error.util.d.ts\ndeclare function spraxiumError(context: string, title: string, body: Array<string>, fix?: Array<string>): never;\ndeclare function spraxiumFatal(context: string, title: string, body: Array<string>, fix?: Array<string>): never;\n//# sourceMappingURL=spraxium-error.util.d.ts.map\n//#endregion\n//#region src/utils/auto-defer.util.d.ts\ntype PatchableInteraction = ChatInputCommandInteraction | ContextMenuCommandInteraction;\n/**\n * Installs the AutoDefer behaviour on a Discord interaction.\n *\n * - Starts a timer for `options.threshold` ms (default 2000).\n * - Patches `interaction.reply()` so the handler can always call it safely:\n *   if the timer fired first and the interaction was deferred, the patch\n *   transparently forwards the call to `interaction.editReply()`.\n * - If the handler replies before the threshold, the timer is cancelled and\n *   Discord never shows \"Thinking...\".\n *\n * Returns a `cleanup` function that **must** be called (via `finally`) after\n * the handler resolves to cancel the timer and restore the original method.\n */\ndeclare function installAutoDefer(interaction: PatchableInteraction, options: AutoDeferOptions): () => void;\n//#endregion\nexport { ACTIVITY_TYPE_MAP, ALL_NON_PRIVILEGED_INTENTS, ActivityOptions, ApplicationState, ArgumentException, ClientFactory, CommandNotFoundException, ConfigEnv, ConfigLoader, ConfigStore, ConfigurationException, ContextMenuDispatcher, CooldownException, CooldownGuard, DEFAULT_PARTIALS, DEFAULT_SPAWN_DELAY, DMOnly, DMOnlyException, DefaultExceptionLayout, ExceptionHandler, ExceptionLayout, ExceptionLayoutMap, ExceptionLayoutPayload, ExceptionOptions, GuardDeniedException, GuardExecutor, GuardRegistry, GuildOnly, GuildOnlyException, IntentPreset, InternalException, LayoutRegistry, ListenerDispatcher, MaintenanceException, ModuleLoader, NSFWGuard, NoBotGuard, NsfwOnlyException, OwnerOnly, OwnerOnlyException, PRIVILEGED_INTENTS, ParentHook, ParentHookRegistry, ParsedPrefixMessage, PermissionDeniedException, PermissionGuard, PluginFactory, type PrefixCommandInfo, PrefixDispatcher, PrefixGuildManager, PrefixSubcommandEntry, PremiumOnlyException, PresenceManager, PresenceOptions, PresenceStatus, RateLimitException, ResolvedAutocompleteHandler, ResolvedContextMenuCommand, ResolvedContextMenuEntry, ResolvedContextMenuHandler, ResolvedPrefixCommand, type ResolvedPrefixEntry, ResolvedSlashCommand, type ResolvedSlashEntry, ResolvedSlashHandler, RoleGuard, ShardActivityProps, ShardEvalContext, ShardOptions, ShardOverride, ShardStatus, SlashDispatcher, SlashLocalizationBridge, type SlashLocalizationMap, type SlashLocalizationResult, SpraxiumApplication, SpraxiumConfigExport, SpraxiumConfigFn, SpraxiumConfigInput, SpraxiumContainer, SpraxiumCoreConfig, SpraxiumDevConfig, SpraxiumException, SpraxiumExceptionOptions, SpraxiumExecutionContext, SpraxiumFactory, SpraxiumOptions, SpraxiumPlugin, SpraxiumShardManager, ThreadOnlyGuard, ValidationException, VoiceChannelGuard, defineConfig, defineExceptionLayout, definePlugin, installAutoDefer, isShardChild, resolveIntents, spraxiumError, spraxiumFatal };\n//# sourceMappingURL=index.d.ts.map","import \"reflect-metadata\";\nimport { APIInteractionGuildMember, BaseInteraction, ChatInputCommandInteraction, Client, ClientEvents, Events, GuildMember, Message, PermissionsBitField, User } from \"discord.js\";\n\n//#region src/constants/metadata-keys.constant.d.ts\ndeclare const METADATA_KEYS: {\n  readonly MODULE: \"spraxium:module\";\n  readonly INJECTABLE: \"spraxium:injectable\";\n  readonly INJECT: \"spraxium:inject\";\n  readonly OPTIONAL: \"spraxium:optional\";\n  readonly GLOBAL: \"spraxium:global\";\n  readonly LISTENER: \"spraxium:listener\";\n  readonly LISTENER_EVENT: \"spraxium:listener_event\";\n  readonly ON_EVENT: \"spraxium:on_event\";\n  readonly ONCE_EVENT: \"spraxium:once_event\";\n  readonly CTX_PARAM: \"spraxium:ctx_param\";\n  readonly GUARD: \"spraxium:guard\";\n  readonly GUARD_OPTION: \"spraxium:guard_option\";\n  readonly USE_GUARDS: \"spraxium:use_guards\";\n  readonly EXCEPTION_LAYOUT: \"spraxium:exception_layout\";\n  readonly PREFIX_COMMAND: \"spraxium:prefix_command\";\n  readonly PREFIX_COMMAND_HANDLER: \"spraxium:prefix_command_handler\";\n  readonly PREFIX_ARG: \"spraxium:prefix_arg\";\n  readonly PREFIX_ARG_PARAM: \"spraxium:prefix_arg_param\";\n  readonly PREFIX_SUBCOMMAND: \"spraxium:prefix_subcommand\";\n  readonly SLASH_COMMAND: \"spraxium:slash_command\";\n  readonly SLASH_COMMAND_HANDLER: \"spraxium:slash_command_handler\";\n  readonly SLASH_OPTION: \"spraxium:slash_option\";\n  readonly SLASH_OPT_PARAM: \"spraxium:slash_opt_param\";\n  readonly SLASH_FOCUSED_PARAM: \"spraxium:slash_focused_param\";\n  readonly SLASH_SUBCOMMAND: \"spraxium:slash_subcommand\";\n  readonly SLASH_SUBCOMMANDS_LIST: \"spraxium:slash_subcommands_list\";\n  readonly SLASH_SUBCOMMAND_GROUP: \"spraxium:slash_subcommand_group\";\n  readonly SLASH_SUBCOMMAND_GROUPS: \"spraxium:slash_subcommand_groups\";\n  readonly SLASH_AUTOCOMPLETE_HANDLER: \"spraxium:slash_autocomplete_handler\";\n  readonly CONTEXT_MENU_COMMAND: \"spraxium:context_menu_command\";\n  readonly CONTEXT_MENU_COMMAND_HANDLER: \"spraxium:context_menu_command_handler\";\n  readonly DEFER: \"spraxium:defer\";\n  readonly AUTO_DEFER: \"spraxium:auto_defer\";\n};\n//# sourceMappingURL=metadata-keys.constant.d.ts.map\n//#endregion\n//#region src/types/constructor.type.d.ts\ntype Constructor<T = unknown> = new (...args: Array<any>) => T;\n//# sourceMappingURL=constructor.type.d.ts.map\n//#endregion\n//#region src/interfaces/module-metadata.interface.d.ts\ninterface ModuleMetadata {\n  imports?: Array<Constructor>;\n  providers?: Array<Constructor>;\n  exports?: Array<Constructor>;\n  /** @Listener()-decorated event listener classes. */\n  listeners?: Array<Constructor>;\n  /** @PrefixCommand()-decorated structure classes (metadata only). */\n  commands?: Array<Constructor>;\n  /** @PrefixCommandHandler()-decorated handler classes (execution logic). */\n  handlers?: Array<Constructor>;\n}\n//# sourceMappingURL=module-metadata.interface.d.ts.map\n//#endregion\n//#region src/decorators/module.decorator.d.ts\ndeclare function Module(metadata?: ModuleMetadata): ClassDecorator;\n//# sourceMappingURL=module.decorator.d.ts.map\n//#endregion\n//#region src/decorators/injectable.decorator.d.ts\ndeclare function Injectable(): ClassDecorator;\n//# sourceMappingURL=injectable.decorator.d.ts.map\n//#endregion\n//#region src/decorators/inject.decorator.d.ts\ndeclare function Inject(token: unknown): ParameterDecorator;\ndeclare function Optional(): ParameterDecorator;\n//# sourceMappingURL=inject.decorator.d.ts.map\n//#endregion\n//#region src/decorators/global.decorator.d.ts\ndeclare function Global(): ClassDecorator;\n//# sourceMappingURL=global.decorator.d.ts.map\n\n//#endregion\n//#region src/decorators/listener.decorator.d.ts\n/** Union of all valid Discord.js client event names. */\ntype DiscordEvent = keyof ClientEvents;\n/**\n * Binds a class to a Discord event. Use @On() or @Once() on the methods\n * to register persistent or one-time handlers respectively.\n *\n * @example\n * @Listener(Events.MessageCreate)\n * export class MessageListener {\n *   @On()\n *   async onMessage(message: Message) {\n *     if (message.author.bot) return;\n *     console.log(message.content);\n *   }\n * }\n */\ndeclare function Listener(event: DiscordEvent): ClassDecorator;\n//# sourceMappingURL=listener.decorator.d.ts.map\n//#endregion\n//#region src/decorators/on.decorator.d.ts\n/**\n * Wires a method as a persistent event handler (client.on).\n * The event itself comes from @Listener() on the class.\n *\n * @example\n * @Listener(Events.MessageCreate)\n * export class MessageListener {\n *   @On()\n *   onMessage(message: Message) {\n *     console.log(message.content);\n *   }\n * }\n */\ndeclare function On(): MethodDecorator;\n//# sourceMappingURL=on.decorator.d.ts.map\n//#endregion\n//#region src/decorators/once.decorator.d.ts\n/**\n * Wires a method as a one-time handler (client.once).\n * The event itself comes from @Listener() on the class.\n *\n * @example\n * @Listener(Events.ClientReady)\n * export class ReadyListener {\n *   @Once()\n *   onReady(client: Client<true>) {\n *     console.log(`Logged in as ${client.user.tag}`);\n *   }\n * }\n */\ndeclare function Once(): MethodDecorator;\n//# sourceMappingURL=once.decorator.d.ts.map\n//#endregion\n//#region src/decorators/ctx.decorator.d.ts\n/**\n * Injects the raw Discord event args into an @On() / @Once() method parameter.\n *\n * @example\n * @Listener(Events.MessageCreate)\n * export class MessageListener {\n *   @On()\n *   onMessage(@Ctx() message: Message) {\n *     console.log(message.content);\n *   }\n * }\n */\ndeclare function Ctx(): ParameterDecorator;\n//# sourceMappingURL=ctx.decorator.d.ts.map\n//#endregion\n//#region src/decorators/guard.decorator.d.ts\n/**\n * Marks a class as a guard. Must implement {@link SpraxiumGuard}.\n * Use {@link GuardOption} to declare configurable properties.\n *\n * @example\n *   @Guard()\n *   export class GuildOnlyGuard implements SpraxiumGuard {\n *     canActivate(ctx: ExecutionContext): boolean {\n *       return ctx.getGuildId() !== null;\n *     }\n *   }\n */\ndeclare function Guard(): ClassDecorator;\n//# sourceMappingURL=guard.decorator.d.ts.map\n//#endregion\n//#region src/interfaces/guard-option-config.interface.d.ts\ninterface GuardOptionConfig {\n  /** Fallback value when the caller doesn't pass this option. */\n  default?: unknown;\n  /** Makes this option mandatory , throws if not provided and no default is set. */\n  required?: boolean;\n}\n//# sourceMappingURL=guard-option-config.interface.d.ts.map\n\n//#endregion\n//#region src/decorators/guard-option.decorator.d.ts\n/**\n * Marks a guard property as a configurable option.\n * Defaults can be set here; callers can override them via @UseGuards.\n *\n * @example\n *   @Guard()\n *   export class PermissionGuard implements SpraxiumGuard {\n *     @GuardOption({ required: true })\n *     permissions!: Array<string>;\n *   }\n */\ndeclare function GuardOption(config?: GuardOptionConfig): PropertyDecorator;\n//# sourceMappingURL=guard-option.decorator.d.ts.map\n//#endregion\n//#region src/interfaces/execution-context.interface.d.ts\n/**\n * Represents whatever triggered the handler , could be an interaction or a message.\n * Passed into every guard's canActivate().\n */\ninterface ExecutionContext {\n  /** Snowflake ID of the user who triggered the handler. */\n  getUserId(): string;\n  /** The User object of whoever triggered the handler. */\n  getUser(): User;\n  /** Snowflake ID of the guild, or null when invoked in a DM. */\n  getGuildId(): string | null;\n  /** Snowflake ID of the channel where the handler was triggered. */\n  getChannelId(): string;\n  /** The name of the event/command that was triggered. */\n  getCommandName(): string;\n  /**\n   * The resolved guild member, or null in DMs or when the member is not cached.\n   * Works for all interaction types (ChatInput, Button, SelectMenu, Modal, etc.)\n   * and for Message-based handlers.\n   */\n  getMember(): GuildMember | APIInteractionGuildMember | null;\n  /**\n   * The member's resolved guild permissions, or null in DMs / uncached members.\n   * Works for all interaction types and Message-based handlers.\n   */\n  getMemberPermissions(): Readonly<PermissionsBitField> | null;\n  /**\n   * The raw BaseInteraction or Message backing this context.\n   * Prefer the typed helpers (getMember, getMemberPermissions, getUser) over\n   * casting this directly.\n   */\n  getInteraction(): BaseInteraction | Message;\n  /** True when the handler was triggered via a slash (ChatInput) interaction. */\n  isSlashCommand(): boolean;\n  /** True when the handler was triggered via a text prefix message. */\n  isPrefixCommand(): boolean;\n}\n//# sourceMappingURL=execution-context.interface.d.ts.map\n//#endregion\n//#region src/interfaces/spraxium-guard.interface.d.ts\n/**\n * Every guard must implement this interface.\n * Return (or resolve to) true to allow the command, false to block it.\n */\ninterface SpraxiumGuard {\n  canActivate(ctx: ExecutionContext): Promise<boolean> | boolean;\n}\n//# sourceMappingURL=spraxium-guard.interface.d.ts.map\n//#endregion\n//#region src/interfaces/lifecycle.interface.d.ts\ninterface SpraxiumOnBoot {\n  onBoot(): void | Promise<void>;\n}\ninterface SpraxiumOnShutdown {\n  onShutdown(): void | Promise<void>;\n}\ninterface SpraxiumOnReady {\n  onReady(client: Client<true>): void | Promise<void>;\n}\n//# sourceMappingURL=lifecycle.interface.d.ts.map\n//#endregion\n//#region src/interfaces/readonly-container.interface.d.ts\ndeclare abstract class ReadonlyContainer {\n  abstract get<T = unknown>(token: unknown): T | undefined;\n}\n//# sourceMappingURL=readonly-container.interface.d.ts.map\n//#endregion\n//#region src/interfaces/guard-entry.interface.d.ts\ninterface GuardEntry {\n  guard: new () => SpraxiumGuard;\n  options: Record<string, unknown>;\n}\n//# sourceMappingURL=guard-entry.interface.d.ts.map\n\n//#endregion\n//#region src/interfaces/prefix-command-config.interface.d.ts\n/**\n * Configuration for `@PrefixCommand()` , structure-only declaration.\n *\n * The class decorated with `@PrefixCommand()` acts as a metadata container:\n * it defines the command name, aliases, argument schema, and description.\n * Execution logic belongs in a separate `@PrefixCommandHandler()` class.\n */\ninterface PrefixCommandConfig {\n  /** Primary trigger name (e.g. `'ban'` for `!ban`). */\n  name: string;\n  /** Alternative trigger names. */\n  aliases?: Array<string>;\n  /** Short help text shown in help commands. */\n  description?: string;\n  /** Override the global prefix for this specific command. */\n  prefix?: string;\n  /** Usage string shown when arguments are invalid (e.g. `'!ban <user> [reason]'`). */\n  usage?: string;\n  /** Category for grouping in help output. */\n  category?: string;\n  /** Per-command cooldown in seconds. Overrides global cooldown. */\n  cooldown?: number;\n}\n//# sourceMappingURL=prefix-command-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-command-handler-metadata.interface.d.ts\n/**\n * Metadata stored by `@PrefixCommandHandler()`.\n *\n * Links a handler class (which contains the `handle()` method) to the\n * `@PrefixCommand()` class it handles.\n */\ninterface PrefixCommandHandlerMetadata {\n  /** Reference to the `@PrefixCommand()` class this handler processes. */\n  command: new () => object;\n  /** If set, this handler only fires for `!cmd <subcommand>`. */\n  subcommand?: string;\n}\n//# sourceMappingURL=prefix-command-handler-metadata.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-arg-metadata.interface.d.ts\n/** Supported argument types for `@PrefixArg.*()` decorators. */\ntype PrefixArgType = 'string' | 'integer' | 'number' | 'boolean' | 'user' | 'channel' | 'role' | 'member' | 'snowflake' | 'url' | 'duration' | 'color' | 'emoji' | 'rest';\ninterface PrefixArgValidation {\n  /** Custom regex the raw input must match before coercion. */\n  pattern?: RegExp;\n  /** Custom validator function. Return `true` to pass or a string error message. */\n  validate?: (value: string) => true | string;\n}\n/**\n * User-facing argument definition returned by a command's `build()` method\n * or a `@PrefixSubcommand()` method. Omits `position` , the framework\n * assigns position from the array index.\n */\ntype PrefixArgDefinition = Omit<PrefixArgMetadata, 'position' | 'required'> & {\n  required?: boolean;\n};\n/**\n * Full internal metadata for a single prefix argument.\n * Created by the framework from `PrefixArgDefinition` with an assigned position.\n */\ninterface PrefixArgMetadata {\n  /** Argument name used for lookup via `@Arg('name')` on the handler. */\n  name: string;\n  /** Expected type , determines coercion and validation logic. */\n  type: PrefixArgType;\n  /** Positional index in the raw argv array. */\n  position: number;\n  /** Whether the argument must be present. @default true */\n  required: boolean;\n  /** Minimum numeric value (integer/number types). */\n  min?: number;\n  /** Maximum numeric value (integer/number types). */\n  max?: number;\n  /** Minimum string length (string type). */\n  minLength?: number;\n  /** Maximum string length (string type). */\n  maxLength?: number;\n  /** Allowed literal values (acts as an enum). */\n  choices?: Array<string>;\n  /** Custom validation rules (regex and/or function). */\n  validation?: PrefixArgValidation;\n}\n//# sourceMappingURL=prefix-arg-metadata.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-guild.interface.d.ts\n/**\n * A single guild's prefix configuration, returned by a\n * `PrefixGuildProvider` during bootstrap or at runtime.\n */\ninterface PrefixGuildEntry {\n  /** Discord guild (server) snowflake ID. */\n  guildId: string;\n  /** One or more prefixes active for this guild. */\n  prefix: string | Array<string>;\n  /** Arbitrary metadata the developer can attach (e.g. language, tier). */\n  metadata?: Record<string, unknown>;\n}\n/**\n * Async function that supplies initial per-guild prefix data at boot time.\n *\n * The framework calls this once during bootstrap and loads the returned\n * entries into the in-memory `PrefixGuildManager`. The developer can\n * source this data from a database, API, or any async store.\n *\n * @example\n * ```ts\n * const provider: PrefixGuildProvider = async () => {\n *   const rows = await db.query('SELECT guild_id, prefix FROM guild_settings');\n *   return rows.map(r => ({ guildId: r.guild_id, prefix: r.prefix }));\n * };\n * ```\n */\ntype PrefixGuildProvider = () => Promise<Array<PrefixGuildEntry>> | Array<PrefixGuildEntry>;\n//# sourceMappingURL=prefix-guild.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-config.interface.d.ts\n/**\n * Configuration for the prefix command subsystem.\n *\n * Set in `SpraxiumCoreConfig.prefix` or via\n * `SpraxiumFactory.create({ prefix: ... })`.\n */\ninterface PrefixConfig {\n  /** The global prefix string(s). @default '!' */\n  prefix: string | Array<string>;\n  /**\n   * Async function that supplies initial per-guild prefix data at boot time.\n   *\n   * The framework calls this once during bootstrap and loads the returned\n   * entries into the in-memory `PrefixGuildManager`.\n   *\n   * After boot, use the `PrefixGuildManager` API to update prefixes at runtime\n   * without restarting the bot.\n   *\n   * @example\n   * ```ts\n   * guildPrefixProvider: async () => {\n   *   const rows = await db.query('SELECT guild_id, prefix FROM settings');\n   *   return rows.map(r => ({ guildId: r.guild_id, prefix: r.prefix }));\n   * }\n   * ```\n   */\n  guildPrefixProvider?: PrefixGuildProvider;\n  /** Whether prefix matching is case-sensitive. @default false */\n  caseSensitive?: boolean;\n  /** Whether commands should accept a bot mention as a prefix. @default true */\n  mentionPrefix?: boolean;\n  /** Default cooldown in seconds applied to all commands. @default 0 */\n  defaultCooldown?: number;\n  /** Whether to reply with \"command not found\" when no match is found. @default false */\n  replyOnNotFound?: boolean;\n}\n//# sourceMappingURL=prefix-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-subcommand-config.interface.d.ts\n/**\n * Configuration for `@PrefixSubcommand()` , declares a subcommand within\n * a `@PrefixCommand()` class.\n *\n * Each decorated method returns a `PrefixArgDefinition[]` defining the\n * argument schema for that specific subcommand.\n */\ninterface PrefixSubcommandConfig {\n  /** Subcommand name (matched against the first argv token). */\n  name: string;\n  /** Short help text shown in help output. */\n  description?: string;\n}\n//# sourceMappingURL=prefix-subcommand-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-i18n-keys.interface.d.ts\ninterface SlashI18nKeys {\n  /** Locale lookup key for this entity's name localizations. */\n  name: string;\n  /** Locale lookup key for this entity's description localizations. */\n  description: string;\n}\n//# sourceMappingURL=slash-i18n-keys.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-command-config.interface.d.ts\ninterface SlashCommandConfig {\n  name: string;\n  description: string;\n  guild?: string;\n  dmPermission?: boolean;\n  defaultMemberPermissions?: bigint | number | null;\n  nsfw?: boolean;\n  i18n?: SlashI18nKeys;\n}\n//# sourceMappingURL=slash-command-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-command-handler-metadata.interface.d.ts\ninterface SlashCommandHandlerMetadata {\n  command: new () => object;\n  sub?: string;\n  group?: string;\n}\n//# sourceMappingURL=slash-command-handler-metadata.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-option-metadata.interface.d.ts\ntype SlashOptionType = 'STRING' | 'INTEGER' | 'NUMBER' | 'BOOLEAN' | 'USER' | 'CHANNEL' | 'ROLE' | 'MENTIONABLE' | 'ATTACHMENT';\ninterface SlashOptionChoice<V extends string | number = string | number> {\n  name: string;\n  value: V;\n}\ninterface SlashBaseOptionConfig {\n  description: string;\n  required?: boolean;\n  i18n?: SlashI18nKeys;\n}\ninterface SlashStringOptionConfig extends SlashBaseOptionConfig {\n  minLength?: number;\n  maxLength?: number;\n  choices?: Array<SlashOptionChoice<string>>;\n  autocomplete?: boolean;\n}\ninterface SlashIntegerOptionConfig extends SlashBaseOptionConfig {\n  min?: number;\n  max?: number;\n  choices?: Array<SlashOptionChoice<number>>;\n  autocomplete?: boolean;\n}\ninterface SlashNumberOptionConfig extends SlashBaseOptionConfig {\n  min?: number;\n  max?: number;\n  autocomplete?: boolean;\n}\n/**\n * Valid Discord channel types accepted by slash command channel options.\n * Mirrors the subset that discord.js's `addChannelTypes` allows.\n *\n * Values map to `ChannelType` enum members:\n * 0=GuildText, 2=GuildVoice, 4=GuildCategory, 5=GuildAnnouncement,\n * 10=AnnouncementThread, 11=PublicThread, 12=PrivateThread,\n * 13=GuildStageVoice, 15=GuildForum, 16=GuildMedia\n */\ntype GuildChannelType = 0 | 2 | 4 | 5 | 10 | 11 | 12 | 13 | 15 | 16;\ninterface SlashChannelOptionConfig extends SlashBaseOptionConfig {\n  channelTypes?: Array<GuildChannelType>;\n}\ninterface SlashOptionMetadata {\n  type: SlashOptionType;\n  name: string;\n  description: string;\n  required: boolean;\n  autocomplete: boolean;\n  minLength?: number;\n  maxLength?: number;\n  min?: number;\n  max?: number;\n  choices?: Array<SlashOptionChoice>;\n  channelTypes?: Array<GuildChannelType>;\n  i18n?: SlashI18nKeys;\n}\n//# sourceMappingURL=slash-option-metadata.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-subcommand-metadata.interface.d.ts\ninterface SlashSubcommandMetadata {\n  name: string;\n  description: string;\n  i18n?: SlashI18nKeys;\n}\ninterface SlashSubcommandGroupMetadata {\n  name: string;\n  description: string;\n  i18n?: SlashI18nKeys;\n}\n//# sourceMappingURL=slash-subcommand-metadata.interface.d.ts.map\n//#endregion\n//#region src/interfaces/slash-autocomplete-handler-metadata.interface.d.ts\ninterface SlashAutocompleteHandlerMetadata {\n  command: new () => object;\n  optionName: string;\n}\n//# sourceMappingURL=slash-autocomplete-handler-metadata.interface.d.ts.map\n\n//#endregion\n//#region src/interfaces/context-menu-command-config.interface.d.ts\n/**\n * Type of context menu command exposed by Discord.\n *\n * - `'user'`: appears under right-click on a user (`Apps` submenu)\n * - `'message'`: appears under right-click on a message (`Apps` submenu)\n */\ntype ContextMenuCommandType = 'user' | 'message';\ninterface ContextMenuCommandConfig {\n  /**\n   * Display name shown to the user inside the `Apps` submenu.\n   * Up to 32 characters; spaces are allowed (unlike slash command names).\n   */\n  name: string;\n  /**\n   * Whether this is a user-targeted or message-targeted context menu command.\n   */\n  type: ContextMenuCommandType;\n  /**\n   * If set, the command is registered as a guild command in this guild\n   * instead of globally. Useful for testing.\n   */\n  guild?: string;\n  /**\n   * Whether the command is allowed in DMs. Defaults to `true`.\n   * Ignored for context menu commands targeted at messages in DMs.\n   */\n  dmPermission?: boolean;\n  /**\n   * Discord permissions required by default to invoke this command.\n   * Server admins can override this in guild settings.\n   */\n  defaultMemberPermissions?: bigint | number | null;\n  /**\n   * Marks the command as NSFW. Discord will hide it from age-restricted users\n   * outside age-gated channels.\n   */\n  nsfw?: boolean;\n}\n//# sourceMappingURL=context-menu-command-config.interface.d.ts.map\n//#endregion\n//#region src/interfaces/context-menu-command-handler-metadata.interface.d.ts\ninterface ContextMenuCommandHandlerMetadata {\n  command: new () => object;\n}\n//# sourceMappingURL=context-menu-command-handler-metadata.interface.d.ts.map\n//#endregion\n//#region src/types/guard-options.type.d.ts\ntype GuardOptions<T extends SpraxiumGuard> = { [K in keyof T as K extends 'canActivate' ? never : T[K] extends ((...args: Array<unknown>) => unknown) ? never : K]?: T[K] };\ntype GuardInput = (new () => SpraxiumGuard) | [new () => SpraxiumGuard, Record<string, unknown>?];\n//# sourceMappingURL=guard-options.type.d.ts.map\n\n//#endregion\n//#region src/decorators/use-guards.decorator.d.ts\n/**\n * Helper for passing typed options to a guard inside @UseGuards().\n *\n * @example\n *   @UseGuards(withOptions(PermissionGuard, { permissions: ['BanMembers'] }))\n */\ndeclare function withOptions<T extends SpraxiumGuard>(guard: new () => T, options: GuardOptions<T>): [new () => T, Record<string, unknown>];\n/**\n * Attaches guards to a class or a specific method.\n * Supports bare constructors, tuples with options, or a mix of both.\n * Method-level guards run after class-level and global guards.\n */\ndeclare function UseGuards(...inputs: Array<GuardInput>): ClassDecorator & MethodDecorator;\n/** Alias for {@link UseGuards}. */\ndeclare const Guards: typeof UseGuards;\n//# sourceMappingURL=use-guards.decorator.d.ts.map\n//#endregion\n//#region src/types/exception-layout-class.type.d.ts\ntype ExceptionLayoutClass = new () => {\n  build(exception: any, ctx: any): any;\n};\n//# sourceMappingURL=exception-layout-class.type.d.ts.map\n\n//#endregion\n//#region src/decorators/with-layout.decorator.d.ts\n/**\n * Links an exception class to a layout class.\n * Keeps the layout declaration right next to the exception instead of buried in config.\n *\n * Resolution order: per-instance `layout` → `exceptions.layouts` map\n * → `@WithLayout` → `layouts.default` → `DefaultExceptionLayout`.\n *\n * @example\n * const CooldownLayout = defineExceptionLayout((ex) => ({\n *   embeds: [new EmbedBuilder().setDescription(`Wait **${ex.props.seconds}s**`)],\n *   ephemeral: true,\n * }));\n *\n * @WithLayout(CooldownLayout)\n * export class CooldownException extends SpraxiumException {\n *   constructor(props?: { seconds?: number }) {\n *     super({ code: 'COOLDOWN', props });\n *   }\n * }\n */\ndeclare function WithLayout(layoutClass: ExceptionLayoutClass): ClassDecorator;\n//# sourceMappingURL=with-layout.decorator.d.ts.map\n\n//#endregion\n//#region src/decorators/prefix-command.decorator.d.ts\n/**\n * Marks a class as a prefix command **definition** (structure only).\n *\n * The class itself holds no execution logic , it is a metadata container\n * that declares the command name, aliases, and argument schema.\n *\n * **Simple commands** , stack `@PrefixArg.*()` decorators on a `build()` method.\n * **Subcommand commands** , use `@PrefixSubcommand()` + `@PrefixArg.*()` on methods.\n *\n * Execution logic belongs in a separate `@PrefixCommandHandler()` class.\n *\n * Register in a module's `commands: []` array.\n *\n * @example\n * ```ts\n * @PrefixCommand({ name: 'ban', aliases: ['b'], description: 'Ban a user' })\n * export class BanCommand {\n *   @PrefixArg.User('target')\n *   @PrefixArg.String('reason', { required: false })\n *   build() {}\n * }\n * ```\n */\ndeclare function PrefixCommand(config: PrefixCommandConfig): ClassDecorator;\n//# sourceMappingURL=prefix-command.decorator.d.ts.map\n//#endregion\n//#region src/decorators/prefix-command-handler.decorator.d.ts\n/**\n * Links a handler class to a `@PrefixCommand()` definition.\n *\n * The handler must expose a `handle()` method which receives injected\n * parameters via `@Ctx()` and `@Arg('name')` decorators.\n *\n * Supports guards via `@UseGuards()` on the class or `handle()` method.\n *\n * Register in a module's `handlers: []` array.\n *\n * @example\n * ```ts\n * // Root handler , handles `!ban <user> [reason]`\n * @PrefixCommandHandler(BanCommand)\n * export class BanHandler {\n *   handle(@Ctx() msg: Message, @PrefixArg('target') user: User) { }\n * }\n *\n * // Subcommand handler , handles `!mod warn <user>`\n * @PrefixCommandHandler(ModCommand, { subcommand: 'warn' })\n * export class ModWarnHandler {\n *   handle(@Ctx() msg: Message, @PrefixArg('target') user: User) { }\n * }\n * ```\n */\ndeclare function PrefixCommandHandler(command: new () => object, options?: {\n  subcommand?: string;\n}): ClassDecorator;\n//# sourceMappingURL=prefix-command-handler.decorator.d.ts.map\n//#endregion\n//#region src/decorators/prefix-subcommand.decorator.d.ts\n/**\n * Declares a subcommand within a `@PrefixCommand()` class.\n *\n * Stack `@PrefixArg.*()` decorators on the same method to define the\n * argument schema for this specific subcommand. Each subcommand gets its\n * own handler class via `@PrefixCommandHandler(Command, { subcommand: 'name' })`.\n *\n * @example\n * ```ts\n * @PrefixCommand({ name: 'mod', description: 'Moderation commands' })\n * export class ModCommand {\n *   @PrefixSubcommand({ name: 'warn', description: 'Warn a user' })\n *   @PrefixArg.User('target')\n *   @PrefixArg.Rest('reason', { required: false })\n *   warn() {}\n *\n *   @PrefixSubcommand({ name: 'kick', description: 'Kick a user' })\n *   @PrefixArg.User('target')\n *   @PrefixArg.Rest('reason', { required: false })\n *   kick() {}\n * }\n * ```\n */\ndeclare function PrefixSubcommand(config: PrefixSubcommandConfig): MethodDecorator;\n//# sourceMappingURL=prefix-subcommand.decorator.d.ts.map\n//#endregion\n//#region src/interfaces/prefix-base-arg-config.interface.d.ts\ninterface BaseArgConfig {\n  required?: boolean;\n  min?: number;\n  max?: number;\n  minLength?: number;\n  maxLength?: number;\n  choices?: Array<string>;\n  validation?: PrefixArgValidation;\n}\n//# sourceMappingURL=prefix-base-arg-config.interface.d.ts.map\n\n//#endregion\n//#region src/decorators/prefix-arg.decorator.d.ts\n/**\n * **Parameter decorator** , injects a parsed prefix argument into a handler's\n * `handle()` method parameter by name.\n *\n * @example\n * ```ts\n * @PrefixCommandHandler(BanCommand)\n * export class BanHandler {\n *   handle(@Ctx() msg: Message, @PrefixArg('target') user: string) {}\n * }\n * ```\n */\ndeclare function PrefixArg(name: string): ParameterDecorator;\n/**\n * **Method decorators** , declare argument schemas on a command's `build()`\n * method or `@PrefixSubcommand()` methods. Stack top-to-bottom to define\n * positional order.\n *\n * @example\n * ```ts\n * @PrefixCommand({ name: 'roll', cooldown: 3 })\n * export class RollCommand {\n *   @PrefixArg.Integer('sides', { required: false, min: 2, max: 1000 })\n *   @PrefixArg.Integer('count', { required: false, min: 1, max: 25 })\n *   build() {}\n * }\n *\n * @PrefixCommand({ name: 'mod' })\n * export class ModCommand {\n *   @PrefixSubcommand({ name: 'ban', description: 'Ban a user' })\n *   @PrefixArg.User('target')\n *   @PrefixArg.Rest('reason', { required: false })\n *   ban() {}\n * }\n * ```\n */\ndeclare namespace PrefixArg {\n  /** String argument. */\n  function String(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Integer argument (rounded). */\n  function Integer(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Floating-point number argument. */\n  function Number(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Boolean argument (`true`/`false`/`yes`/`no`/`1`/`0`). */\n  function Boolean(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Discord user mention (parses `<@id>` or raw snowflake). */\n  function User(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Discord channel mention (parses `<#id>` or raw snowflake). */\n  function Channel(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Discord role mention (parses `<@&id>` or raw snowflake). */\n  function Role(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Discord guild member (fetched from mention or snowflake). */\n  function Member(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Raw Discord snowflake ID (17-20 digit number). */\n  function Snowflake(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Validated URL string. */\n  function Url(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Time duration (e.g. `5m`, `1h30m`, `2d`). Coerced to milliseconds. */\n  function Duration(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Hex color code (e.g. `#FF0000` or `FF0000`). Coerced to number. */\n  function Color(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Discord emoji (custom `<:name:id>` or unicode). */\n  function Emoji(name: string, config?: BaseArgConfig): MethodDecorator;\n  /** Variadic rest , all remaining tokens joined into a single string. */\n  function Rest(name: string, config?: BaseArgConfig): MethodDecorator;\n}\n//# sourceMappingURL=prefix-arg.decorator.d.ts.map\n//#endregion\n//#region src/decorators/slash-command.decorator.d.ts\n/**\n * Marks a class as a Discord slash command.\n *\n * The decorated class defines the command's schema , its name, description,\n * options, and subcommands. It does **not** contain handler logic; use\n * `@SlashCommandHandler` on a separate class for that.\n *\n * @param config - Command configuration (name, description, permissions, etc.)\n *\n * @example\n * \\@SlashCommand({ name: 'ping', description: 'Reply with Pong!' })\n * export class PingCommand {}\n *\n * @example\n * \\@SlashCommand({\n *   name: 'admin',\n *   description: 'Admin-only utilities',\n *   defaultMemberPermissions: PermissionFlagsBits.Administrator,\n * })\n * export class AdminCommand {}\n */\ndeclare function SlashCommand(config: SlashCommandConfig): ClassDecorator;\n//# sourceMappingURL=slash-command.decorator.d.ts.map\n\n//#endregion\n//#region src/decorators/slash-command-handler.decorator.d.ts\n/**\n * Marks a class as the execution handler for a slash command.\n *\n * The handler class must implement a `build()` method (or a method matching\n * the corresponding subcommand/group) that receives the interaction and\n * performs the business logic.\n *\n * @param command - The `@SlashCommand`-decorated class this handler belongs to.\n * @param options - Optional routing options for subcommand or group targeting.\n * @param options.sub - The subcommand name this handler responds to.\n * @param options.group - The subcommand group name this handler responds to.\n *\n * @example\n * // Handler for the root command\n * \\@SlashCommandHandler(PingCommand)\n * export class PingHandler {\n *   async build(interaction: ChatInputCommandInteraction) {\n *     await interaction.reply('Pong!');\n *   }\n * }\n *\n * @example\n * // Handler for a specific subcommand\n * \\@SlashCommandHandler(AdminCommand, { sub: 'ban' })\n * export class AdminBanHandler {\n *   async build(interaction: ChatInputCommandInteraction) { ... }\n * }\n */\ndeclare function SlashCommandHandler(command: new () => object, options?: {\n  sub?: string;\n  group?: string;\n}): ClassDecorator;\n//# sourceMappingURL=slash-command-handler.decorator.d.ts.map\n//#endregion\n//#region src/decorators/slash-option.decorator.d.ts\n/**\n * Injects a resolved slash command option value by name into a `handle()`\n * parameter. This is the unified replacement for the deprecated `@SlashOpt`\n * decorator. The option type is resolved at runtime by correlating `name`\n * with the matching `@SlashOption.*` declaration on the command class.\n *\n * Also acts as a builder namespace of method decorators (`@SlashOption.String`,\n * `@SlashOption.Integer`, etc.) for declaring options on a `@SlashCommand`.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example Parameter injection (handler)\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashOption('message') message: string,\n * ): Promise<void> {\n *   await interaction.reply(message);\n * }\n *\n * @example Option declaration (command)\n * \\@SlashOption.String('message', { description: 'Text to echo', required: true })\n * build() {}\n */\ndeclare function SlashOptionParam(name: string): ParameterDecorator;\ndeclare const SlashOption: typeof SlashOptionParam & {\n  /** Adds a `STRING` option. Supports `minLength`, `maxLength`, `choices`, and `autocomplete`. */\n  readonly String: (name: string, config: SlashStringOptionConfig) => MethodDecorator;\n  /** Adds an `INTEGER` (whole number) option. Supports `min`, `max`, `choices`, and `autocomplete`. */\n  readonly Integer: (name: string, config: SlashIntegerOptionConfig) => MethodDecorator;\n  /** Adds a `NUMBER` (decimal) option. Supports `min`, `max`, and `autocomplete`. */\n  readonly Number: (name: string, config: SlashNumberOptionConfig) => MethodDecorator;\n  /** Adds a `BOOLEAN` option. */\n  readonly Boolean: (name: string, config: SlashBaseOptionConfig) => MethodDecorator;\n  /** Adds a `USER` option, resolves to a Discord `User` object. */\n  readonly User: (name: string, config: SlashBaseOptionConfig) => MethodDecorator;\n  /** Adds a `CHANNEL` option. Use `channelTypes` to restrict accepted channel types. */\n  readonly Channel: (name: string, config: SlashChannelOptionConfig) => MethodDecorator;\n  /** Adds a `ROLE` option, resolves to a Discord `Role` object. */\n  readonly Role: (name: string, config: SlashBaseOptionConfig) => MethodDecorator;\n  /** Adds a `MENTIONABLE` option, resolves to either a `User` or `Role`. */\n  readonly Mentionable: (name: string, config: SlashBaseOptionConfig) => MethodDecorator;\n  /** Adds an `ATTACHMENT` option, resolves to a Discord `Attachment` object. */\n  readonly Attachment: (name: string, config: SlashBaseOptionConfig) => MethodDecorator;\n};\n//#endregion\n//#region src/decorators/slash-opt.decorator.d.ts\ndeclare function SlashOpt(name: string): ParameterDecorator;\n//# sourceMappingURL=slash-opt.decorator.d.ts.map\n\n//#endregion\n//#region src/decorators/slash-typed-options.decorator.d.ts\n/**\n * Injects the value of a `STRING` slash command option.\n * Resolves to `string | null` at runtime.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashStringOption('text') text: string | null,\n * ) {}\n */\ndeclare const SlashStringOption: (name: string) => ParameterDecorator;\n/**\n * Injects the value of an `INTEGER` slash command option.\n * Resolves to `number | null` at runtime.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashIntegerOption('count') count: number | null,\n * ) {}\n */\ndeclare const SlashIntegerOption: (name: string) => ParameterDecorator;\n/**\n * Injects the value of a `NUMBER` (decimal) slash command option.\n * Resolves to `number | null` at runtime.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashNumberOption('ratio') ratio: number | null,\n * ) {}\n */\ndeclare const SlashNumberOption: (name: string) => ParameterDecorator;\n/**\n * Injects the value of a `BOOLEAN` slash command option.\n * Resolves to `boolean | null` at runtime.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashBooleanOption('flag') flag: boolean | null,\n * ) {}\n */\ndeclare const SlashBooleanOption: (name: string) => ParameterDecorator;\n/**\n * Injects the value of a `USER` slash command option.\n * Resolves to a discord.js `User | null` at runtime.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashUserOption('target') target: User | null,\n * ) {}\n */\ndeclare const SlashUserOption: (name: string) => ParameterDecorator;\n/**\n * Injects the value of a `CHANNEL` slash command option.\n * Resolves to a discord.js `GuildBasedChannel | null` at runtime.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashChannelOption('channel') channel: TextChannel | null,\n * ) {}\n */\ndeclare const SlashChannelOption: (name: string) => ParameterDecorator;\n/**\n * Injects the value of a `ROLE` slash command option.\n * Resolves to a discord.js `Role | null` at runtime.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashRoleOption('role') role: Role | null,\n * ) {}\n */\ndeclare const SlashRoleOption: (name: string) => ParameterDecorator;\n/**\n * Injects the value of a `MENTIONABLE` slash command option.\n * Resolves to a discord.js `User | Role | null` at runtime.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashMentionableOption('mention') mention: User | Role | null,\n * ) {}\n */\ndeclare const SlashMentionableOption: (name: string) => ParameterDecorator;\n/**\n * Injects the value of an `ATTACHMENT` slash command option.\n * Resolves to a discord.js `Attachment | null` at runtime.\n *\n * @param name - The option name as declared on the command class.\n *\n * @example\n * async handle(\n *   \\@Ctx() interaction: ChatInputCommandInteraction,\n *   \\@SlashAttachmentOption('file') file: Attachment | null,\n * ) {}\n */\ndeclare const SlashAttachmentOption: (name: string) => ParameterDecorator;\n//# sourceMappingURL=slash-typed-options.decorator.d.ts.map\n//#endregion\n//#region src/decorators/slash-focused.decorator.d.ts\n/**\n * Parameter decorator that injects the currently focused option value into\n * an autocomplete handler method.\n *\n * Use this inside a `@SlashAutocompleteHandler` method to receive the partial\n * string the user has typed into the focused option field.\n *\n * @example\n * \\@SlashAutocompleteHandler(SearchCommand, 'query')\n * export class SearchAutocomplete {\n *   async build(\n *     interaction: AutocompleteInteraction,\n *     \\@SlashFocused() query: string,\n *   ) {\n *     const suggestions = await fetchSuggestions(query);\n *     await interaction.respond(suggestions.map((s) => ({ name: s, value: s })));\n *   }\n * }\n */\ndeclare function SlashFocused(): ParameterDecorator;\n//# sourceMappingURL=slash-focused.decorator.d.ts.map\n\n//#endregion\n//#region src/decorators/slash-subcommand.decorator.d.ts\n/**\n * Marks a method on a `@SlashCommand` class as a subcommand.\n *\n * Each decorated method becomes a Discord subcommand. The method name is used\n * to match the corresponding `@SlashCommandHandler` via its `sub` option.\n * Attach `@SlashOption.*` decorators to the same method to define the\n * subcommand's options.\n *\n * @param options - Subcommand configuration (name and description).\n *\n * @example\n * \\@SlashCommand({ name: 'user', description: 'User utilities' })\n * export class UserCommand {\n *   \\@SlashSubcommand({ name: 'info', description: 'Show user info' })\n *   \\@SlashOption.User('target', { description: 'The user', required: true })\n *   info() {}\n *\n *   \\@SlashSubcommand({ name: 'avatar', description: 'Show avatar' })\n *   avatar() {}\n * }\n */\ndeclare function SlashSubcommand(options: SlashSubcommandMetadata): MethodDecorator;\n//# sourceMappingURL=slash-subcommand.decorator.d.ts.map\n//#endregion\n//#region src/decorators/slash-subcommand-group.decorator.d.ts\n/**\n * Marks a class as a Discord subcommand group.\n *\n * A subcommand group class contains `@SlashSubcommand`-decorated methods,\n * each representing a subcommand within the group. Register the group on\n * a command class using `@SlashSubcommandGroups`.\n *\n * @param options - Group configuration (name and description).\n *\n * @example\n * \\@SlashSubcommandGroup({ name: 'settings', description: 'Bot settings' })\n * export class SettingsGroup {\n *   \\@SlashSubcommand({ name: 'view', description: 'View current settings' })\n *   view() {}\n *\n *   \\@SlashSubcommand({ name: 'reset', description: 'Reset to defaults' })\n *   reset() {}\n * }\n */\ndeclare function SlashSubcommandGroup(options: SlashSubcommandGroupMetadata): ClassDecorator;\n//# sourceMappingURL=slash-subcommand-group.decorator.d.ts.map\n//#endregion\n//#region src/decorators/slash-subcommand-groups.decorator.d.ts\n/**\n * Registers one or more `@SlashSubcommandGroup` classes on a `@SlashCommand`.\n *\n * Use this when a command needs to organize subcommands into named groups.\n * Each entry in `groups` must be a class decorated with `@SlashSubcommandGroup`.\n *\n * @param groups - Array of `@SlashSubcommandGroup`-decorated classes.\n *\n * @example\n * \\@SlashCommand({ name: 'config', description: 'Bot configuration' })\n * \\@SlashSubcommandGroups([SettingsGroup, NotificationsGroup])\n * export class ConfigCommand {}\n */\ndeclare function SlashSubcommandGroups(groups: Array<new (...args: Array<unknown>) => unknown>): ClassDecorator;\n//# sourceMappingURL=slash-subcommand-groups.decorator.d.ts.map\n\n//#endregion\n//#region src/decorators/slash-autocomplete-handler.decorator.d.ts\n/**\n * Marks a class as an autocomplete handler for a specific option on a slash command.\n *\n * The handler class must implement a `build()` method that receives the\n * `AutocompleteInteraction` and (optionally) the focused value via `@SlashFocused`.\n * Return suggestions by calling `interaction.respond()`.\n *\n * @param command - The `@SlashCommand`-decorated class that owns the option.\n * @param optionName - The name of the `@SlashOption.*` that has `autocomplete: true`.\n *\n * @example\n * // Command definition\n * \\@SlashCommand({ name: 'search', description: 'Search items' })\n * export class SearchCommand {\n *   \\@SlashOption.String('query', { description: 'Search query', autocomplete: true })\n *   build() {}\n * }\n *\n * // Autocomplete handler\n * \\@SlashAutocompleteHandler(SearchCommand, 'query')\n * export class SearchAutocomplete {\n *   async build(\n *     interaction: AutocompleteInteraction,\n *     \\@SlashFocused() query: string,\n *   ) {\n *     const results = await db.search(query);\n *     await interaction.respond(results.map((r) => ({ name: r.name, value: r.id })));\n *   }\n * }\n */\ndeclare function SlashAutocompleteHandler(command: new () => object, optionName: string): ClassDecorator;\n//# sourceMappingURL=slash-autocomplete-handler.decorator.d.ts.map\n//#endregion\n//#region src/decorators/context-menu-command.decorator.d.ts\n/**\n * Marks a class as a Discord context menu command (User or Message).\n *\n * Context menu commands appear in the `Apps` submenu when a user right-clicks\n * on another user or message. They take no options; Discord passes the\n * targeted user/message directly on the interaction.\n *\n * The decorated class only declares the command schema; pair it with a\n * `@ContextMenuCommandHandler`-decorated class for the execution logic.\n *\n * @example\n * // User context menu: appears on right-click → Apps → \"User Info\"\n * @ContextMenuCommand({ name: 'User Info', type: 'user' })\n * export class UserInfoCommand {}\n *\n * @example\n * // Message context menu: appears on right-click → Apps → \"Quote\"\n * @ContextMenuCommand({ name: 'Quote', type: 'message' })\n * export class QuoteCommand {}\n */\ndeclare function ContextMenuCommand(config: ContextMenuCommandConfig): ClassDecorator;\n//# sourceMappingURL=context-menu-command.decorator.d.ts.map\n//#endregion\n//#region src/decorators/context-menu-command-handler.decorator.d.ts\n/**\n * Marks a class as the execution handler for a context menu command.\n *\n * The handler must expose a `handle()` method. Use `@Ctx()` to receive the\n * underlying `UserContextMenuCommandInteraction` or\n * `MessageContextMenuCommandInteraction` from discord.js.\n *\n * @param command The `@ContextMenuCommand`-decorated class this handler responds to.\n *\n * @example\n * @ContextMenuCommandHandler(UserInfoCommand)\n * export class UserInfoHandler {\n *   async handle(@Ctx() interaction: UserContextMenuCommandInteraction) {\n *     await interaction.reply(`User: ${interaction.targetUser.tag}`);\n *   }\n * }\n */\ndeclare function ContextMenuCommandHandler(command: new () => object): ClassDecorator;\n//# sourceMappingURL=context-menu-command-handler.decorator.d.ts.map\n//#endregion\n//#region src/decorators/defer.decorator.d.ts\ninterface DeferOptions {\n  /**\n   * Whether the deferred reply should be ephemeral (visible only to the user).\n   * Defaults to `false`.\n   */\n  ephemeral?: boolean;\n}\n/**\n * Automatically defers the interaction before the handler runs, extending the\n * response window from 3 seconds to 15 minutes.\n *\n * Deferral happens **after** guards pass -- preventing a stuck \"thinking...\"\n * state if a guard denies the interaction.\n *\n * After using `@Defer()`, the handler must use `interaction.editReply()` instead\n * of `interaction.reply()`.\n *\n * @example\n * ```ts\n * @SlashCommandHandler(StatsCommand)\n * @Defer({ ephemeral: true })\n * export class StatsCommandHandler {\n *   async handle(@Ctx() interaction: ChatInputCommandInteraction) {\n *     const data = await this.db.fetchHeavyReport();\n *     await interaction.editReply({ embeds: [buildEmbed(data)] });\n *   }\n * }\n * ```\n */\ndeclare function Defer(options?: DeferOptions): ClassDecorator;\n//# sourceMappingURL=defer.decorator.d.ts.map\n//#endregion\n//#region src/decorators/auto-defer.decorator.d.ts\ninterface AutoDeferOptions {\n  /**\n   * Whether the deferred reply should be ephemeral (visible only to the user).\n   * Defaults to `false`.\n   */\n  ephemeral?: boolean;\n  /**\n   * How many milliseconds to wait before automatically deferring the interaction.\n   * If the handler responds within this window, Discord will never show \"Thinking...\"\n   * to the user. If the handler takes longer, the framework defers automatically.\n   *\n   * Discord's hard deadline is 3000 ms, so keep this well below that.\n   * Defaults to `2000` ms.\n   */\n  threshold?: number;\n}\n/**\n * Automatically defers the interaction **only if** the handler takes longer\n * than `threshold` milliseconds (default 2000 ms) to respond.\n *\n * Unlike `@Defer()`, which always shows \"Thinking...\" immediately, `@AutoDefer`\n * is transparent for fast handlers -- Discord never shows the loading state.\n *\n * The framework patches `interaction.reply()` so the handler can always call\n * `interaction.reply()` without worrying about whether a defer happened.\n * If the interaction was deferred behind the scenes, the patch transparently\n * routes the call to `interaction.editReply()` instead.\n *\n * @example\n * ```ts\n * @SlashCommandHandler(StatsCommand)\n * @AutoDefer({ ephemeral: true, threshold: 1500 })\n * export class StatsCommandHandler {\n *   async handle(@Ctx() interaction: ChatInputCommandInteraction) {\n *     const data = await this.db.fetchStats(); // may take 0-3 s\n *     await interaction.reply({ embeds: [buildEmbed(data)] }); // always safe\n *   }\n * }\n * ```\n */\ndeclare function AutoDefer(options?: AutoDeferOptions): ClassDecorator;\n//# sourceMappingURL=auto-defer.decorator.d.ts.map\n//#endregion\n//#region src/types/slash-context.type.d.ts\ntype SlashContext = ChatInputCommandInteraction;\n//# sourceMappingURL=slash-context.type.d.ts.map\n\n//#endregion\nexport { AutoDefer, AutoDeferOptions, Constructor, ContextMenuCommand, ContextMenuCommandConfig, ContextMenuCommandHandler, ContextMenuCommandHandlerMetadata, ContextMenuCommandType, Ctx, Defer, DeferOptions, DiscordEvent, Events, ExecutionContext, Global, Guard, GuardEntry, GuardInput, GuardOption, GuardOptionConfig, GuardOptions, Guards, GuildChannelType, Inject, Injectable, Listener, METADATA_KEYS, Module, ModuleMetadata, On, Once, Optional, PrefixArg, PrefixArgDefinition, PrefixArgMetadata, PrefixArgType, PrefixArgValidation, PrefixCommand, PrefixCommandConfig, PrefixCommandHandler, PrefixCommandHandlerMetadata, PrefixConfig, PrefixGuildEntry, PrefixGuildProvider, PrefixSubcommand, PrefixSubcommandConfig, ReadonlyContainer, SlashAttachmentOption, SlashAutocompleteHandler, SlashAutocompleteHandlerMetadata, SlashBaseOptionConfig, SlashBooleanOption, SlashChannelOption, SlashChannelOptionConfig, SlashCommand, SlashCommandConfig, SlashCommandHandler, SlashCommandHandlerMetadata, SlashContext, SlashFocused, SlashI18nKeys, SlashIntegerOption, SlashIntegerOptionConfig, SlashMentionableOption, SlashNumberOption, SlashNumberOptionConfig, SlashOpt, SlashOption, SlashOptionChoice, SlashOptionMetadata, SlashOptionType, SlashRoleOption, SlashStringOption, SlashStringOptionConfig, SlashSubcommand, SlashSubcommandGroup, SlashSubcommandGroupMetadata, SlashSubcommandGroups, SlashSubcommandMetadata, SlashUserOption, SpraxiumGuard, SpraxiumOnBoot, SpraxiumOnReady, SpraxiumOnShutdown, UseGuards, WithLayout, withOptions };\n//# sourceMappingURL=index.d.ts.map"],"mappings":"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"}