meocord 2.1.1 → 3.1.0

package/dist/types/controller.enum-DYfhYaat.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The kinds of interaction a `@Command` method can be bound to.
+ *
+ * Each member names one Discord interaction shape rather than a family of them, so a
+ * handler's parameter type follows from its command type alone. That is why the four
+ * entity select menus are separate members instead of one `SELECT_MENU`: Discord sends
+ * them as distinct component types (5-8) carrying different resolved data, and
+ * collapsing them would leave the handler with a union it has to re-narrow by hand.
+ */
+declare enum CommandType {
+    /** Chat input command, or one subcommand of it. */
+    SLASH = "SLASH",
+    /** User or message context menu command. */
+    CONTEXT_MENU = "CONTEXT_MENU",
+    /** Activity launch command (`ApplicationCommandType.PrimaryEntryPoint`). */
+    PRIMARY_ENTRY_POINT = "PRIMARY_ENTRY_POINT",
+    BUTTON = "BUTTON",
+    /** String select menu — the one whose options the application defines itself. */
+    SELECT_MENU = "SELECT_MENU",
+    USER_SELECT_MENU = "USER_SELECT_MENU",
+    ROLE_SELECT_MENU = "ROLE_SELECT_MENU",
+    MENTIONABLE_SELECT_MENU = "MENTIONABLE_SELECT_MENU",
+    CHANNEL_SELECT_MENU = "CHANNEL_SELECT_MENU",
+    MODAL_SUBMIT = "MODAL_SUBMIT"
+}
+/**
+ * Enum representing actions that can be performed on a message reaction.
+ */
+declare enum ReactionHandlerAction {
+    /** Reaction added to a message. */
+    ADD = "ADD",
+    /** Reaction removed from a message. */
+    REMOVE = "REMOVE"
+}
+
+export { CommandType as C, ReactionHandlerAction as R };

package/dist/types/core/index.d.ts

@@ -19,10 +19,104 @@ declare class MeoCordApp {
     private activityInterval;
     private controllerInstancesCache;
     constructor(controllerClasses: (new (...args: any[]) => any)[], container: Container, discordClient: Client, discordToken: string, activities?: ActivityOptions[] | undefined);
+    /**
+     * Runs an event handler so a failure inside it cannot take the process down.
+     *
+     * discord.js calls listeners without awaiting them, so a rejection escaping one has
+     * nothing left to settle it: Node reports an unhandled rejection, which terminates
+     * the process by default. Losing the whole bot because one reaction landed on a
+     * deleted message, or one controller could not be resolved, is a worse failure than
+     * the one that caused it -- every other user is served by the same process.
+     *
+     * Nothing is silenced. The error is logged against the event that produced it, so a
+     * genuine misconfiguration -- an unbound controller, a missing dependency -- shows
+     * up on the very first interaction rather than staying hidden.
+     *
+     * @param event - The gateway event being handled, named in the log.
+     * @param run - The handler to run.
+     */
+    private runListener;
+    /**
+     * Rotates the bot's activity.
+     *
+     * Guarded separately from {@link runListener}: this runs on a timer rather than an
+     * event, and a throw from a timer callback is an uncaught exception no listener
+     * wrapper can reach.
+     */
+    private updateActivity;
     private getInstance;
     start(): Promise<void>;
     registerCommands(): Promise<void>;
+    /**
+     * Every pattern-matched route, ordered most specific first.
+     *
+     * Built once and cached, so dispatch stays a single ordered walk with an early exit
+     * rather than paying to rank anything per interaction. Ordering here is what lets
+     * `gi-profile-summary-{ownerId}-{uid}` keep the ids it owns when
+     * `gi-profile-{uuid}-{uid}` would also match them — without it, the winner would be
+     * whichever controller happened to be registered first.
+     */
+    private componentRoutes?;
+    private getComponentRoutes;
+    /**
+     * Warns rather than throws: an app whose patterns overlap boots and works today, and
+     * refusing to start would turn a latent mis-route into an outage on upgrade.
+     */
+    private reportAmbiguousRoutes;
+    /**
+     * Every `@Autocomplete` handler, ordered so an option-specific handler is found
+     * before a command-wide one.
+     *
+     * Cached alongside the component table: autocomplete fires on every keystroke, and
+     * rebuilding the list per keystroke would put reflection on the hottest path the
+     * framework has.
+     */
+    private autocompleteRoutes?;
+    private getAutocompleteRoutes;
+    /**
+     * Dispatches an interaction, and makes sure a failure anywhere in that still reaches
+     * the person who triggered it.
+     *
+     * {@link executeCommand} already reports what a handler throws, but everything
+     * *before* the handler can fail too — resolving a controller through the container
+     * is the common case — and a component that fails there would otherwise look dead
+     * with nothing said to the user and nothing in the log.
+     */
     private handleInteraction;
+    private dispatchInteraction;
+    /**
+     * The names a command interaction can be handled under, most specific first.
+     *
+     * Empty for anything that is not a registered command, which is how a component
+     * whose customId matched no pattern falls through to the unmatched warning instead
+     * of being looked up under a name it does not have.
+     */
+    private resolveNameRoutes;
+    /**
+     * Answers an autocomplete interaction from the `@Autocomplete` handler that claims it.
+     *
+     * Discord closes the window after three seconds and shows a loading state until
+     * something arrives, so an unclaimed option is answered with an empty list rather
+     * than left to time out -- a visibly empty menu is a better failure than a stuck one,
+     * and the warning says which option is missing a handler.
+     */
+    private handleAutocomplete;
+    /** Closes an autocomplete window that nothing else answered. */
+    private respondEmpty;
+    /**
+     * Runs a resolved command, shared by both dispatch paths so a pattern-matched
+     * component and a named slash command behave identically once the route is chosen.
+     */
+    private executeCommand;
+    /**
+     * Tells the user something went wrong, if the interaction can still hear it.
+     *
+     * A handler that replies and *then* throws is the common shape of a failure, and
+     * replying twice throws in turn -- out of the catch block, where nothing is left to
+     * handle it. Whatever the interaction's state, reporting an error must not be able
+     * to become a second, worse one.
+     */
+    private replyWithError;
     private handleMessage;
     private handleReaction;
     private gracefulShutdown;

package/dist/types/decorator/index.d.ts

@@ -1,6 +1,6 @@
+import { BuildableCommandType, CommandBuilderBase, CommandBuilderConstructor, CommandInteractionType, ReactionHandlerOptions, AutocompleteMetadata, CommandMetadata, GuardInterface } from '../interface/index.js';
+import { AutocompleteInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientOptions, ActivityOptions } from 'discord.js';
 import { CommandType } from '../enum/index.js';
-import { SlashCommandBuilder, SlashCommandSubcommandsOnlyBuilder, ContextMenuCommandBuilder, ButtonInteraction, StringSelectMenuInteraction, ChatInputCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, ModalSubmitInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientOptions, ActivityOptions } from 'discord.js';
-import { ReactionHandlerOptions, GuardInterface } from '../interface/index.js';
 import { ServiceIdentifier } from 'inversify';
 import 'webpack';
 
@@ -29,37 +29,6 @@ import 'webpack';
  */
 declare function Service<T>(): (target: new (...args: any[]) => T) => void;
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025 Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
-
-/**
- * Base interface for a command builder.
- */
-interface CommandBuilderBase<T extends CommandType.SLASH | CommandType.CONTEXT_MENU = CommandType.SLASH | CommandType.CONTEXT_MENU> {
-    /**
-     * Builds the command structure using the specified command name.
-     *
-     * @param commandName - The name of the command.
-     * @returns A SlashCommandBuilder or ContextMenuCommandBuilder instance.
-     */
-    build: (commandName: string) => T extends CommandType.SLASH ? SlashCommandBuilder | SlashCommandSubcommandsOnlyBuilder : T extends CommandType.CONTEXT_MENU ? ContextMenuCommandBuilder : never;
-}
-type CommandBuilderConstructor<T extends CommandType.SLASH | CommandType.CONTEXT_MENU> = new () => CommandBuilderBase<T>;
-/**
- * Command metadata describing a registered command method.
- */
-interface CommandMetadata<T extends string = string> {
-    methodName: string;
-    builder: ReturnType<CommandBuilderBase['build']> | undefined;
-    type: CommandType;
-    regex?: RegExp;
-    dynamicParams?: T[];
-}
-type CommandInteractionType<CBC extends CommandType.SLASH | CommandType.CONTEXT_MENU, T extends CommandBuilderConstructor<CBC> | CommandType> = T extends CommandType.BUTTON ? ButtonInteraction : T extends CommandType.SELECT_MENU ? StringSelectMenuInteraction : T extends CommandBuilderConstructor<CommandType.SLASH> ? ChatInputCommandInteraction : T extends CommandBuilderConstructor<CommandType.CONTEXT_MENU> ? UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction : T extends CommandType.MODAL_SUBMIT ? ModalSubmitInteraction : never;
-
 /**
  * MeoCord Framework
  * Copyright (c) 2025 Ukasyah Rahmatullah Zada
@@ -84,7 +53,7 @@ type CommandInteractionType<CBC extends CommandType.SLASH | CommandType.CONTEXT_
  * @returns A decorator function that makes the target class injectable
  *          and assigns the `commandType` metadata.
  */
-declare function CommandBuilder<T extends CommandType.SLASH | CommandType.CONTEXT_MENU>(commandType: T): (target: new () => CommandBuilderBase<T>) => void;
+declare function CommandBuilder<T extends BuildableCommandType>(commandType: T): (target: new () => CommandBuilderBase<T>) => void;
 
 /**
  * MeoCord Framework
@@ -150,11 +119,18 @@ declare function getMessageHandlers(controller: any): {
     keyword: string | undefined;
     method: string;
 }[];
+/** The character a parameter will not cross, so one pattern segment maps to one value. */
+declare const PARAM_SEPARATOR = "/";
 /**
  * Decorator to register command methods in a controller.
  *
- * @param commandName - The name or pattern of the command.
- * @param builderOrType - A command builder class or a command type from `CommandType`.
+ * @param commandName - What the command is addressed by. Commands registered with
+ *   Discord use their name, and a subcommand its full path — `settings notify email`,
+ *   parts separated by a space, the way Discord displays it. Components use a customId
+ *   pattern, where `{name}` captures one `/`-separated segment.
+ * @param builderOrType - A command builder class, or a `CommandType` for a handler that
+ *   registers nothing of its own: every component, and every subcommand of a command
+ *   whose builder already describes it.
  *
  * @example
  * ```typescript
@@ -163,13 +139,23 @@ declare function getMessageHandlers(controller: any): {
  *   await interaction.reply('This is the help command!')
  * }
  *
- * @Command('stats-{id}', CommandType.BUTTON)
- * public async handleStats(message: ButtonInteraction, { id }) {
- *   await message.reply(`Fetching stats for ID: ${id}`);
+ * @Command('settings notify email', CommandType.SLASH)
+ * public async handleNotifyEmail(interaction: ChatInputCommandInteraction, { enabled }) {
+ *   await interaction.reply(`Email notifications ${enabled ? 'on' : 'off'}`)
+ * }
+ *
+ * @Command('stats/{id}', CommandType.BUTTON)
+ * public async handleStats(interaction: ButtonInteraction, { id }) {
+ *   await interaction.reply(`Fetching stats for ID: ${id}`);
+ * }
+ *
+ * @Command('assign/{taskId}', CommandType.USER_SELECT_MENU)
+ * public async handleAssign(interaction: UserSelectMenuInteraction, { taskId }) {
+ *   await interaction.reply(`Assigned ${interaction.users.size} user(s) to ${taskId}`)
  * }
  * ```
  */
-declare function Command<CBC extends CommandType.SLASH | CommandType.CONTEXT_MENU, T extends CommandBuilderConstructor<CBC> | CommandType>(commandName: string, builderOrType: T): <P extends Record<string, any>, R extends Promise<void> | void>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>, params: P) => R> | TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>) => R>) => void;
+declare function Command<CBC extends BuildableCommandType, T extends CommandBuilderConstructor<CBC> | CommandType>(commandName: string, builderOrType: T): <P extends Record<string, any>, R extends Promise<void> | void>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>, params: P) => R> | TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>) => R>) => void;
 /**
  * Retrieves the command map for a given controller.
  *
@@ -177,6 +163,41 @@ declare function Command<CBC extends CommandType.SLASH | CommandType.CONTEXT_MEN
  * @returns A record containing command metadata indexed by command names.
  */
 declare function getCommandMap<T extends string>(controller: any): Record<string, CommandMetadata<T>[]>;
+/**
+ * Decorator to register an autocomplete handler for a chat input command's option.
+ *
+ * Autocomplete is a separate interaction from the command it belongs to, and Discord
+ * sends it while the user is still typing. It is not a `@Command`: nothing is
+ * registered for it — the option's own `setAutocomplete(true)` is what turns it on —
+ * and it is answered with `interaction.respond()` rather than a reply. Leaving it
+ * unhandled is not silent to the user: the client shows a loading state until the
+ * three-second window closes.
+ *
+ * @param commandPath - The command to complete, e.g. `settings` or `settings notify email`
+ *   for a subcommand. Parts are separated by a single space, as Discord displays them.
+ * @param optionName - The option to complete. Omit to handle every option of the command,
+ *   branching on `interaction.options.getFocused(true)`.
+ *
+ * @example
+ * ```typescript
+ * @Autocomplete('search', 'query')
+ * async completeQuery(interaction: AutocompleteInteraction) {
+ *   const { value } = interaction.options.getFocused(true)
+ *   await interaction.respond(this.search(value).map(name => ({ name, value: name })))
+ * }
+ * ```
+ */
+declare function Autocomplete<R extends void | Promise<void>>(commandPath: string, optionName?: string): <P extends Record<string, any>>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<(interaction: AutocompleteInteraction, params: P) => R> | TypedPropertyDescriptor<(interaction: AutocompleteInteraction) => R>) => void;
+/**
+ * Retrieves autocomplete handler metadata from a given controller.
+ *
+ * Handlers naming an option come first, so a command-wide handler acts as the fallback
+ * for options no specific handler claimed rather than shadowing them by declaration order.
+ *
+ * @param controller - The controller class instance.
+ * @returns The registered autocomplete handlers, most specific first.
+ */
+declare function getAutocompleteHandlers(controller: any): AutocompleteMetadata[];
 /**
  * Decorator to mark a class as a controller that can later be registered to the App class `(app.ts)` using the `@MeoCord` decorator.
  *
@@ -195,6 +216,18 @@ declare function getCommandMap<T extends string>(controller: any): Record<string
  * ```
  */
 declare function Controller(): (target: any) => void;
+/**
+ * Finds pattern pairs that can both match one customId.
+ *
+ * Patterns of different segment counts are disjoint, because a parameter cannot cross
+ * `/`. Within the same count, two patterns overlap unless some position holds literals
+ * that differ: `a/{x}/c` and `a/b/{y}` both take `a/b/c`, and neither is more literal
+ * than the other, so ranking cannot settle it either.
+ *
+ * @param patterns - The registered patterns.
+ * @returns Each ambiguous pair, once, in the order the patterns were given.
+ */
+declare function findAmbiguousRoutes(patterns: string[]): [string, string][];
 
 /**
  * MeoCord Framework
@@ -334,4 +367,4 @@ declare function MeoCord(options: {
     services?: ServiceIdentifier[];
 }): (target: any) => void;
 
-export { Command, CommandBuilder, Controller, Guard, MeoCord, MessageHandler, ReactionHandler, Service, UseGuard, getCommandMap, getMessageHandlers, getReactionHandlers };
+export { Autocomplete, Command, CommandBuilder, Controller, Guard, MeoCord, MessageHandler, PARAM_SEPARATOR, ReactionHandler, Service, UseGuard, findAmbiguousRoutes, getAutocompleteHandlers, getCommandMap, getMessageHandlers, getReactionHandlers };

package/dist/types/enum/index.d.ts

@@ -1,4 +1,4 @@
-export { C as CommandType, R as ReactionHandlerAction } from '../controller.enum-QA-IuReF.js';
+export { C as CommandType, R as ReactionHandlerAction } from '../controller.enum-DYfhYaat.js';
 
 /**
  * MeoCord Framework

package/dist/types/interface/index.d.ts

@@ -1,6 +1,90 @@
-import { User, PartialUser, BaseInteraction, Message, MessageReaction } from 'discord.js';
+import { SlashCommandBuilder, SlashCommandSubcommandsOnlyBuilder, ContextMenuCommandBuilder, RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody, ChatInputCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, PrimaryEntryPointCommandInteraction, ButtonInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, MentionableSelectMenuInteraction, ChannelSelectMenuInteraction, ModalSubmitInteraction, User, PartialUser, BaseInteraction, Message, MessageReaction } from 'discord.js';
 import { Configuration } from 'webpack';
-import { ReactionHandlerAction } from '../enum/index.js';
+import { CommandType, ReactionHandlerAction } from '../enum/index.js';
+
+/**
+ * MeoCord Framework
+ * Copyright (c) 2025 Ukasyah Rahmatullah Zada
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * The command types that are registered with Discord, and so need a builder.
+ *
+ * Components are addressed by a customId the application makes up, so they have
+ * nothing to register; these three are published through `application.commands.set`.
+ */
+type BuildableCommandType = CommandType.SLASH | CommandType.CONTEXT_MENU | CommandType.PRIMARY_ENTRY_POINT;
+/**
+ * The body an entry point command is registered with.
+ *
+ * `description` is added back on top of the discord-api-types body: that type omits it
+ * from every non-chat-input command, but the API accepts one for entry point commands
+ * — Discord's own default activity command ships with it set.
+ */
+type PrimaryEntryPointCommandData = RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody & {
+    description?: string;
+};
+/**
+ * The payload `build()` returns for a given command type.
+ *
+ * `PRIMARY_ENTRY_POINT` yields a raw REST body rather than a builder because
+ * `@discordjs/builders` ships none for it; `ApplicationCommandManager#set` accepts the
+ * JSON body directly, so nothing is lost.
+ */
+type CommandBuildResult<T extends BuildableCommandType> = T extends CommandType.SLASH ? SlashCommandBuilder | SlashCommandSubcommandsOnlyBuilder : T extends CommandType.CONTEXT_MENU ? ContextMenuCommandBuilder : T extends CommandType.PRIMARY_ENTRY_POINT ? PrimaryEntryPointCommandData : never;
+/**
+ * Base interface for a command builder.
+ */
+interface CommandBuilderBase<T extends BuildableCommandType = BuildableCommandType> {
+    /**
+     * Builds the command structure using the specified command name.
+     *
+     * @param commandName - The name of the command.
+     * @returns A builder instance, or a raw command body for entry point commands.
+     */
+    build: (commandName: string) => CommandBuildResult<T>;
+}
+type CommandBuilderConstructor<T extends BuildableCommandType> = new () => CommandBuilderBase<T>;
+/**
+ * Command metadata describing a registered command method.
+ */
+interface CommandMetadata<T extends string = string> {
+    methodName: string;
+    builder: ReturnType<CommandBuilderBase['build']> | undefined;
+    type: CommandType;
+    regex?: RegExp;
+    dynamicParams?: T[];
+    /**
+     * How specific this pattern is; higher wins when more than one route matches the
+     * same customId. A greedy parameter can overlap a more literal sibling —
+     * `gi-profile-{uuid:*}-{uid}` also matches an id meant for
+     * `gi-profile-summary-{ownerId}-{uid}` — so dispatch cannot rely on declaration order.
+     */
+    specificity?: number;
+}
+/** Metadata describing one `@Autocomplete` handler. */
+interface AutocompleteMetadata {
+    /** The command path the handler serves, e.g. `settings` or `settings notify email`. */
+    commandPath: string;
+    /** The option it completes, or `undefined` to complete every option of that command. */
+    optionName?: string;
+    methodName: string;
+}
+/** The interaction class each non-buildable command type hands to its handler. */
+interface ComponentInteractionMap {
+    [CommandType.BUTTON]: ButtonInteraction;
+    [CommandType.SELECT_MENU]: StringSelectMenuInteraction;
+    [CommandType.USER_SELECT_MENU]: UserSelectMenuInteraction;
+    [CommandType.ROLE_SELECT_MENU]: RoleSelectMenuInteraction;
+    [CommandType.MENTIONABLE_SELECT_MENU]: MentionableSelectMenuInteraction;
+    [CommandType.CHANNEL_SELECT_MENU]: ChannelSelectMenuInteraction;
+    [CommandType.MODAL_SUBMIT]: ModalSubmitInteraction;
+    [CommandType.SLASH]: ChatInputCommandInteraction;
+    [CommandType.CONTEXT_MENU]: UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction;
+    [CommandType.PRIMARY_ENTRY_POINT]: PrimaryEntryPointCommandInteraction;
+}
+type CommandInteractionType<CBC extends BuildableCommandType, T extends CommandBuilderConstructor<CBC> | CommandType> = T extends CommandBuilderConstructor<CommandType.SLASH> ? ChatInputCommandInteraction : T extends CommandBuilderConstructor<CommandType.CONTEXT_MENU> ? UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction : T extends CommandBuilderConstructor<CommandType.PRIMARY_ENTRY_POINT> ? PrimaryEntryPointCommandInteraction : T extends keyof ComponentInteractionMap ? ComponentInteractionMap[T] : never;
 
 /**
  * MeoCord Framework
@@ -92,4 +176,4 @@ interface MeoCordConfig {
     webpack?: (config: MeoCordWebpackConfig) => MeoCordWebpackConfig | undefined;
 }
 
-export type { GuardInterface, MeoCordConfig, MeoCordWebpackConfig, ReactionHandlerOptions };
+export type { AutocompleteMetadata, BuildableCommandType, CommandBuildResult, CommandBuilderBase, CommandBuilderConstructor, CommandInteractionType, CommandMetadata, GuardInterface, MeoCordConfig, MeoCordWebpackConfig, ReactionHandlerOptions };

package/dist/types/testing/index.d.ts

@@ -2,7 +2,7 @@ import { ServiceIdentifier, Container } from 'inversify';
 import { GuardInterface } from '../interface/index.js';
 import { CacheType, CommandInteractionOptionResolver, Channel, Client, Guild, Message, User } from 'discord.js';
 import 'webpack';
-import '../controller.enum-QA-IuReF.js';
+import '../controller.enum-DYfhYaat.js';
 
 /**
  * MeoCord Framework
@@ -277,30 +277,12 @@ declare function createMockMessage(): DeepMocked<Message>;
 interface ChatInputOptions {
     subcommandGroup?: string | null;
     subcommand?: string | null;
+    /** The option the user is currently typing, for autocomplete interactions. */
+    focused?: string | null;
     [name: string]: string | number | boolean | {
         id: string;
     } | null | undefined;
 }
-/**
- * Builds a typed options resolver from a plain record. Mirrors how the real
- * `CommandInteractionOptionResolver` works: declare what options the command
- * was invoked with, and the resolver finds them by name.
- *
- * All explicit methods are mock functions — override per test with `.mockReturnValue()`.
- * Methods not listed (e.g. `getAttachment`) are auto-stubbed by the Proxy.
- *
- * @example
- * ```ts
- * const interaction = createMockInteraction(ChatInputCommandInteraction)
- * interaction.options = createChatInputOptions({
- *   subcommandGroup: 'daily',
- *   subcommand: 'notes',
- *   uid: 12345678,
- * })
- * interaction.options.getSubcommand()  // → 'notes'
- * interaction.options.getNumber('uid') // → 12345678
- * ```
- */
 declare function createChatInputOptions<Cached extends CacheType = any>(opts?: ChatInputOptions): DeepMocked<CommandInteractionOptionResolver<Cached>>;
 
 export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createMock, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMessage, createMockUser, isMockFunction };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "meocord",
   "description": "Decorator-based Discord bot framework built on discord.js. Brings NestJS-style controllers, dependency injection, guards, and testing utilities to bot development — with a full CLI and TypeScript-first design.",
-  "version": "2.1.1",
+  "version": "3.1.0",
   "type": "module",
   "engines": {
     "node": ">=22"
   },
   "scripts": {
-    "lint": "eslint --fix . && tsc --noEmit && tsc --noEmit --project tsconfig.test.json",
+    "lint": "prettier --write \"**/*.md\" && eslint --fix . && tsc --noEmit && tsc --noEmit --project tsconfig.test.json",
     "build": "rm -rf ./dist && rollup -c",
     "prepare": "husky",
     "test": "vitest run",