meocord 4.2.2 → 4.2.3

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

@@ -1,10 +1,10 @@
 import { ServiceIdentifier, Container } from 'inversify';
-import { Client, Interaction, Message, MessageReaction, PartialMessageReaction, User, PartialUser, ClientEvents, Base, Locale, GuildMember, Role, GuildBasedChannel, Guild, APIMessageTopLevelComponent, JSONEncodable, APIEmbed, MessageFlagsResolvable, TextBasedChannel, BaseChannel, APIAuthorizingIntegrationOwnersMap, APIInteractionGuildMember, PermissionResolvable, APIUser, CacheType, CommandInteractionOptionResolver, ThreadChannel, AnyThreadChannel, ChatInputCommandInteraction, AutocompleteInteraction, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, PrimaryEntryPointCommandInteraction, ContextMenuCommandInteraction, CommandInteraction, ButtonInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, MentionableSelectMenuInteraction, ChannelSelectMenuInteraction, MessageComponentInteraction, ModalSubmitInteraction, BaseInteraction, DMChannel, PartialGroupDMChannel, OmitPartialGroupDMChannel, Attachment, ModalSubmitFields, MessagePayload, InteractionReplyOptions, InteractionUpdateOptions, InteractionEditReplyOptions, MessageEditOptions, APIModalInteractionResponseCallbackData, ModalComponentData, InteractionDeferReplyOptions, InteractionDeferUpdateOptions, MessageResolvable, DiscordAPIError } from 'discord.js';
+import { Client, Interaction, Message, MessageReaction, PartialMessageReaction, User, PartialUser, ClientEvents, Base, Locale, GuildMember, Role, GuildBasedChannel, Guild, APIMessageTopLevelComponent, JSONEncodable, APIEmbed, MessageFlagsResolvable, TextBasedChannel, BaseChannel, APIAuthorizingIntegrationOwnersMap, APIInteractionGuildMember, PermissionResolvable, APIUser, CacheType, CommandInteractionOptionResolver, ThreadChannel, AnyThreadChannel, ChatInputCommandInteraction, AutocompleteInteraction, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, PrimaryEntryPointCommandInteraction, ContextMenuCommandInteraction, CommandInteraction, ButtonInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, MentionableSelectMenuInteraction, ChannelSelectMenuInteraction, MessageComponentInteraction, ModalSubmitInteraction, BaseInteraction, DMChannel, PartialGroupDMChannel, OmitPartialGroupDMChannel, Attachment, ModalSubmitFields, MessagePayload, InteractionReplyOptions, InteractionUpdateOptions, InteractionEditReplyOptions, MessageEditOptions, APIModalInteractionResponseCallbackData, ModalComponentData, InteractionDeferReplyOptions, InteractionDeferUpdateOptions, MessageResolvable, LaunchActivityOptions, ApplicationCommandOptionChoiceData, DiscordAPIError } from 'discord.js';
 import { ReactionHandlerAction, CommandType } from '../enum/index.cjs';
-import { a8 as Provider, P as ProviderToken } from '../index-Dlf0ZZtS.cjs';
+import { a8 as Provider, P as ProviderToken } from '../index-CqXImwF_.cjs';
 import { CooldownStore, ExecutionContextType, ExecutionContext, CooldownScope, MetadataDecorator, ResponsePhase, ResponseCall } from '../common/index.cjs';
 import { DispatchObserver, GuardInterface, InterceptorInterface, ExceptionFilter, ThemeOverride, ThemeResolvers, ThemeResolver, MessageCommandOptions, MessagePrefix, RootTheme, DeepReadonly, MeoCordTheme } from '../interface/index.cjs';
-export { ao as ClassProvider, F as FactoryProvider, ap as ValueProvider } from '../index-Dlf0ZZtS.cjs';
+export { ao as ClassProvider, F as FactoryProvider, ap as ValueProvider } from '../index-CqXImwF_.cjs';
 import { ThemeCache } from '../common/index.cjs';
 import { Translator } from '../common/index.cjs';
 import '@rsbuild/core';
@@ -216,6 +216,8 @@ declare class TestingModule {
     private readonly services;
     /** How long `close()` waits for the `onShutdown` hooks, as the bot's `shutdownTimeout` does. */
     private readonly shutdownTimeout;
+    /** The `app`, whose presenter `init()` makes after the providers, as the bot does. */
+    private readonly app?;
     constructor(container: Container, controllers?: readonly (new (...args: any[]) => unknown)[], eventClasses?: readonly (new (...args: any[]) => unknown)[], providers?: ProviderMap, order?: readonly unknown[], messageOptions?: MessageCommandOptions, lifecycle?: readonly LifecycleUnit[], 
     /** The lifecycle units the container has constructed, which `close()` shuts down. */
     constructed?: ReadonlySet<unknown>, 
@@ -224,8 +226,12 @@ declare class TestingModule {
     /** The app's listed services, made at `init()` as the bot makes them before it logs in. */
     services?: readonly (new (...args: any[]) => unknown)[], 
     /** How long `close()` waits for the `onShutdown` hooks, as the bot's `shutdownTimeout` does. */
-    shutdownTimeout?: number);
+    shutdownTimeout?: number, 
+    /** The `app`, whose presenter `init()` makes after the providers, as the bot does. */
+    app?: object | undefined);
     private resolving?;
+    /** The instances whose `@On` and `@Once` handlers `emit` runs, read at `init()`. */
+    private sources?;
     private readying?;
     private closing?;
     /** The `onReady` hooks' pass, which `close()` waits for, less one whose `onReady` called `close()`. */
@@ -358,16 +364,24 @@ declare class TestingModule {
      *   command's or an autocomplete's options, or the handler's customId params with a modal's fields or
      *   a select menu's choices.
      *   An interaction's customId or command name must be one dispatch routes to the handler, ranking
-     *   every handler of the module as the bot does; a mock built without one is not checked. With a message alone, a patterned `@MessageHandler` gets the
-     *   params its pattern captures from the content, after the prefix of the module's `app`, with typed
-     *   params resolved as dispatch resolves them, from the message's guild caches first; a message
-     *   without content gets `{}`. A word that is not a value of its type, and a prefixed message that names
-     *   the command but leaves out a param, go through the handler's filters as a `MessageUsageError`, as
-     *   dispatch answers them.
+     *   every handler of the module as the bot does; a mock built without one is not checked. An autocomplete is
+     *   checked by its command path and its focused option: one dispatch gives to another `@Autocomplete` handler,
+     *   or to none, is refused under `useStrictMocks()`, and otherwise warned about once and run.
+     *   With a message alone, a patterned `@MessageHandler` gets the params its pattern captures from the content,
+     *   after the prefix of the module's `app`, with typed params resolved as dispatch resolves them, from the
+     *   message's guild caches first. A message whose `content` isn't a string, as a mock's without
+     *   `useStrictMocks()`, gets `{}`. Under strict mocks a message has empty `content`, and a patterned handler
+     *   rejects it, as dispatch runs no handler for a message with no text: give the mock the `content` the handler
+     *   takes. A word that is not a value of its type, and a prefixed message that names the command but leaves out
+     *   a param, go through the handler's filters as a `MessageUsageError`, as dispatch answers them.
+     *   An `@On` or `@Once` handler no route reaches runs as {@link emit} runs it, as an event with the arguments given,
+     *   under `useStrictMocks()`; without strict mocks it runs as its first argument's type, and `invoke` warns once
+     *   where that differs.
      * @returns Whether the handler ran, and the error a filter handled, if any. Rejects with an error no
      *   filter handles, or with the error a filter throws: the built-in fallback, which answers such
      *   errors in the bot, does not run here. Rejects before running anything with an interaction or a
-     *   message the handler's route does not match, naming both. Given fewer arguments than the handler
+     *   message the handler's route does not match, naming both, and under `useStrictMocks()` with such an
+     *   autocomplete. Given fewer arguments than the handler
      *   declares, with a first that is neither an interaction nor a message, such as a reaction without its
      *   `ReactionEvent`, it rejects under `useStrictMocks()`, and otherwise warns once and runs the handler.
      *
@@ -394,6 +408,22 @@ declare class TestingModule {
     invoke<C extends new (...args: any[]) => unknown, M extends HandlerName<C>>(controller: C, methodName: M, ...args: HandlerArgs<C, M>): Promise<InvocationResult>;
     /** The handlers already warned about for being given fewer arguments than they take, so each is named once. */
     private readonly warnedArgumentCounts;
+    /** The `@On` and `@Once` handlers already warned about for running other than as an event, so each is named once. */
+    private readonly warnedEventRuns;
+    /**
+     * Warns once, without strict mocks, that `invoke` runs an event handler other than as the bot does: as the type its
+     * first argument gives, or with params it added. Only `invoke` warns, on the test's own call.
+     */
+    private warnEventRun;
+    /** Runs an `@On` or `@Once` handler as the bot and `emit` do: as an event, with its arguments as given. */
+    private runEventHandler;
+    /** The autocomplete mismatches already warned about without strict mocks, so each handler and route warns once. */
+    private readonly warnedAutocompleteRoutes;
+    /**
+     * Refuses under strict mocks, and otherwise warns once, an autocomplete dispatch gives to another handler or to none.
+     * Without strict mocks the handler still runs, since a test that passes that way would fail.
+     */
+    private checkAutocompleteRoute;
     /**
      * Refuses under `useStrictMocks()`, or warns once otherwise, a call that gives a handler fewer arguments than it
      * declares when `invoke` builds none for it, as for a reaction given without its `ReactionEvent`.
@@ -404,10 +434,17 @@ declare class TestingModule {
     /** Counts `call` as under way until it settles. */
     private track;
     /**
-     * Makes this module the app of the input's client, as the bot is of its own, so `respond()` outside any call,
-     * as in a collector's callback on that client, answers in this module's theme.
+     * Makes this module the app of the input's client, as the bot is of its own: its answers are drawn by this
+     * module's presenter, in its theme and language, `respond()` outside any call included, as in a collector's callback
+     * on that client. A module without a presenter clears the client's under strict mocks, so the default draws; default
+     * mode leaves another module's in place and warns once.
      */
     private registerClient;
+    /**
+     * Makes this module the app of each event argument's client, as the bot is of its own, under strict mocks; default
+     * mode leaves the clients as they are and warns once where this module would draw answers otherwise.
+     */
+    private registerEventClients;
     private builtComponentRoutes?;
     /** The module's component routes, ranked as dispatch ranks them; throws, as the bot would, for two of one shape. */
     private componentRoutes;
@@ -451,8 +488,9 @@ declare class TestingModule {
     /**
      * Emits a client event to the module's `@On` and `@Once` handlers, through the pipeline the app runs
      * them in up to its event fallback: the global guards of the module's `app`, then each handler's own.
-     * Handlers on the module's controllers, class providers and their dependencies all receive it. A
-     * `@Once` handler handles only the first event, as it would on a client.
+     * As on the bot, every instance the module runs lifecycle hooks on, the cooldown store aside, receives
+     * it: the controllers and services, what they and the stages inject, and each provided class or value.
+     * A `@Once` handler handles only the first event, as it would on a client.
      *
      * The bot's event fallback doesn't run here. On a bot, a guard's `GuardDeniedError` is logged and the
      * event skipped, and a handler's `UserError` is logged and, when the event carries a message, answered
@@ -519,7 +557,9 @@ declare class TestingModuleBuilder {
     /**
      * Replaces a provider with a test double.
      *
-     * The double needs only the members the test uses; misspelled member names are still rejected.
+     * The double needs only the members the test uses; misspelled member names are still rejected. A token MeoCord binds
+     * itself, such as `ShardContext` or `HandlerRegistry`, takes the double in place of MeoCord's own, so a test can stub
+     * cross-shard calls.
      *
      * @param token - The provider to replace.
      * @example
@@ -747,9 +787,9 @@ type Implementation<T> = {
  * @see {@link MockState}
  */
 interface MockResult<T = unknown> {
-    /** `'return'` when the call returned, `'throw'` when it threw. */
-    type: 'return' | 'throw';
-    /** What the call returned, or the error it threw. */
+    /** `'return'` when the call returned, `'throw'` when it threw, `'incomplete'` while it is still running. */
+    type: 'return' | 'throw' | 'incomplete';
+    /** What the call returned, or the error it threw; `undefined` while it is incomplete. */
     value: T;
 }
 /**
@@ -1108,12 +1148,14 @@ type NotRaw<T> = T extends {
  * collections of what it picks, each empty unless given. Other data Discord always sends reads as Discord sends it,
  * such as `false` for a flag and `null` for what may be absent; what picks the handler, `commandName` or `customId`, is
  * the test's to give. Replies follow Discord's order, so a second `reply()` rejects, and {@link getResponse} reports
- * every answer the interaction got. Under `useStrictMocks()` an answer marks the interaction `replied` or `deferred`
- * once it resolves, as discord.js does after Discord takes it: an edit or follow-up made before then rejects with
- * `InteractionNotReplied`, and a second answer sent while the first is in flight is refused with Discord's 40060. In
- * default mode the mark is made at the call, with a warning where a bot would fail. Every method is a mock function, and one that returns a promise in discord.js
- * resolves. What the mock computes for itself, such as `memberPermissions` and `appPermissions`, calls none of them and
- * caches nothing, so a stub a test sets stays for its own code.
+ * every answer the interaction got; under `useStrictMocks()`, `launchActivity()`, `sendPremiumRequired()` and an
+ * autocomplete's `respond()` count as answers too. Under `useStrictMocks()` an answer marks the interaction `replied`,
+ * `deferred` or, for an autocomplete, `responded` once it resolves, as discord.js does after Discord takes it: an edit
+ * or follow-up made before then rejects with `InteractionNotReplied`, and a second answer sent while the first is in
+ * flight is refused with Discord's 40060. In default mode the mark is made at the call, with a warning where a bot
+ * would fail. Every method is a mock function, and one that returns a promise in discord.js resolves. What the mock
+ * computes for itself, such as `memberPermissions` and `appPermissions`, calls none of them and caches nothing, so a
+ * stub a test sets stays for its own code.
  *
  * An answer keeps that order whatever it is set to do: one a test gives a value with `mockResolvedValue` replies or
  * defers as a real one would, and one that rejects changes nothing. `fetchReply()` reads back what `reply()` or
@@ -1316,14 +1358,16 @@ interface MockGuildOverrides {
  * A manager's `fetch(id)` resolves to its cached item with that id, as discord.js looks there first, or to a new one it
  * caches under that id: a member, channel, emoji, sticker, scheduled event or AutoMod rule in this guild, a role with
  * that id, a ban, or an invite with that code. `members.fetch({ user: ids })` resolves to a collection of each of those
- * members, found or made the same way; `create()` and `edit()` resolve to a mock of its item, which `create()` caches
- * as discord.js does, but for an invite, made for the channel given and cached nowhere; a list fetch resolves to an
- * empty collection. Members, roles and channels given are put in
- * their managers' caches, where dispatch looks first when it resolves a message's typed params; a member
- * {@link createMockMember} made without a server is in this one. Its `roles.everyone` is the role given with the
- * guild's id, or else an @everyone role of its own at position 0 with no permissions, in `roles.cache` as Discord has
- * it. The guild is named `'Guild'` and its `preferredLocale` is `'en-US'` unless given, so `t.forGuild(guild)`
- * translates as for a new English server.
+ * members, found or made the same way; `create()` resolves to a mock of its item, a channel of the type its options
+ * name under `useStrictMocks()`, which it caches as discord.js does, but for an invite, made for the channel given and
+ * cached nowhere; `edit()` resolves under `useStrictMocks()` to the item with the id given, found or made the same way,
+ * and under `useStrictMocks()` either takes the `name` its options give. A list fetch resolves to an empty collection.
+ * Members, roles and channels given are put in their managers' caches, where dispatch looks first when it resolves a
+ * message's typed params; a member {@link createMockMember} made without a server is in this one. Its `roles.everyone`
+ * is the role given with the guild's id, or else an @everyone role of its own at position 0, in `roles.cache` as
+ * Discord has it. That role has no permissions in default mode; under `useStrictMocks()` it has the ones Discord
+ * gives @everyone in a new server. The guild is named `'Guild'` and its `preferredLocale` is `'en-US'` unless given,
+ * so `t.forGuild(guild)` translates as for a new English server.
  *
  * The mock makes a member for any id it's asked for, so a test of an id that isn't a member rejects the fetch, as
  * `guild.members.fetch.mockRejectedValue(createDiscordError(10007))`, or resolves a collection without that member.
@@ -1586,7 +1630,8 @@ interface ChatInputOptions {
  * entity option carries its id in `value` and the object itself, as the gateway sends it: a user option its `user`,
  * and in a server its `member` too. A user option's
  * `getMember()` is the user's member in the server of the interaction the options are given to, and `null` in a DM;
- * a member given resolves `getUser()` to its user. A getter throws discord.js's type error for an option of another
+ * a member given resolves `getUser()` to its user. Under `useStrictMocks()` a user option's `getMentionable()` is its
+ * member too where there is one, as discord.js reads it; default mode returns the user, with a warning once. A getter throws discord.js's type error for an option of another
  * type, as discord.js does, required or not. Only a user or member read as a role, or a role read as a user or member,
  * is `null`, or that error when required, as the option may be a mentionable one; a plain `{ id }` reads as any entity.
  * A whole number is an Integer option and a fraction a Number one, so
@@ -1594,7 +1639,13 @@ interface ChatInputOptions {
  *
  * The `focused` option reads as Discord sends it, through `getFocused()`, `getFocused(true)` and `data` alike: a
  * string, `''` when no value is given, and marked `focused` in `data`. A number given for it is its digits under
- * `useStrictMocks()`; otherwise it stays the number, with a warning when read.
+ * `useStrictMocks()`; otherwise it stays the number, with a warning when read. Under `useStrictMocks()` `get()` and the
+ * typed getters read it by name from that same option, as discord.js does; one given no value takes the string,
+ * integer and number getters alike. Default mode reads what was given, `null` for no value, with a warning once.
+ *
+ * Given to an `AutocompleteInteraction`, a user, member, role, channel, mentionable or attachment option reads as
+ * Discord sends an autocomplete's options under `useStrictMocks()`: its id alone, in `data` and the handler's params,
+ * with the entity getters returning `null`. Otherwise it keeps the object given, with a warning once.
  *
  * @typeParam Cached - `any` by default, to match `createMockInteraction(ChatInputCommandInteraction)`; pass it when the
  *   interaction under test is cache-pinned.
@@ -1649,6 +1700,7 @@ declare function createChatInputOptions<Cached extends CacheType = any>(opts?: C
  *
  * `invoke` also refuses a call that gives a handler fewer arguments than it declares where it builds none, such as a
  * reaction handler given its reaction without its `ReactionEvent`; without strict mocks, it warns once and calls it.
+ * It refuses an autocomplete that dispatch gives to another `@Autocomplete` handler, or to none, the same way.
  *
  * `compile()` also refuses an `overrideGuard`, `overrideInterceptor` or `overrideFilter` stub without the stage's
  * method, `canActivate`, `intercept` or `catch`; without strict mocks, it warns and builds the module.
@@ -1715,9 +1767,14 @@ interface MessageToResolve {
     botId?: string;
     /**
      * Whether the message is a direct message, where `mention: 'only'` does not apply, and a handler that works only in
-     * a server, by its scope or a `member`, `role` or `channel` param in its pattern, is not reached, as dispatch answers
-     * it with its usage. A flag of those types is refused only when the message gives it, which this does not read.
-     * Without it the message may be from anywhere, and a mention alone starts what it starts in a server.
+     * a server, by its scope or a `member`, `role` or `channel` param in its pattern, is not reached, as dispatch never
+     * runs it: it answers "This command works in a server only." to a message sent with a prefix or a mention, and
+     * nothing to one without, which may be chat. Under `useStrictMocks()` a handler with a required flag of those types,
+     * or one the message gives, is not reached either, as dispatch refuses it the same way; default mode resolves it,
+     * with a warning. Without it, a mention alone starts what it starts in a server, and a handler of any scope may
+     * answer, with a warning where one that works only in a DM does. Under `useStrictMocks()`, the message is read as
+     * sent in a server, as dispatch reads one: such a handler is passed over for one that works there, or resolves to
+     * `undefined`.
      */
     dm?: boolean;
 }
@@ -1889,11 +1946,13 @@ declare function createModalFields(values: Record<string, string | string[] | At
  *
  * Use it in a test for a team that wants no fallback in production. It reports the messages a locale lacks, the
  * messages the default catalog doesn't have, the plural forms a language needs but a plural lacks, such as `few` for
- * Russian, a translation of another shape than the default's, a text for a plural or a plural for a text, and each
- * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''`, counts as
- * lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
- * catalog from a plain variable or a JSON file too, which the compiler can't. An object counts as a plural only when
- * its every key is a plural category, so a group with an `other` key is a group.
+ * Russian, a translation of another shape than the default's, a text for a plural or a group, or a plural for a text, and each
+ * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''` or `null`, counts
+ * as lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
+ * catalog from a plain variable or a JSON file too, which the compiler can't. An object in the default catalog counts as
+ * a plural only when its every key is a plural category, so a group with an `other` key is a group, and a translation
+ * is read by the default catalog's shapes, as the translator reads it: one that keeps only a group's `other` message
+ * lacks the group's other messages.
  *
  * @remarks
  * MeoCord's own texts, a catalog's `meocord` group, fall back to English by design, so only a key MeoCord lacks, and
@@ -2082,9 +2141,15 @@ interface HandlerInspection {
     readonly controller: new (...args: any[]) => unknown;
     /** The handler method's name. */
     readonly methodName: string;
-    /** The guards that run before the handler, in order: global guards, class guards, then method guards. */
+    /**
+     * The guards that run before the handler, in order: global guards, class guards, then method guards. Under
+     * `useStrictMocks()`, only those for the handler's context types.
+     */
     readonly guards: readonly InspectedGuard[];
-    /** The interceptors around the handler, outermost first: global, class, then method interceptors. */
+    /**
+     * The interceptors around the handler, outermost first: global, class, then method interceptors. Under
+     * `useStrictMocks()`, only those for the handler's context types, and none for an autocomplete.
+     */
     readonly interceptors: readonly InspectedInterceptor[];
     /**
      * The exception filters for the handler, in the order they are tried: the method's, then the
@@ -2097,11 +2162,16 @@ interface HandlerInspection {
     readonly pattern: string | undefined;
     /**
      * The routes the handler answers because a class its controller extends declares them, such as `slash "ping"`:
-     * those its own class doesn't declare for it. Empty for a handler that declares all it answers. A test reads it;
-     * `toEqual` doesn't compare it, so an assertion on the other fields holds either way.
+     * those its own class doesn't declare for it. Empty for a handler that declares all it answers. Under
+     * `useStrictMocks()` it names an inherited `@On` or `@Once` event too, such as `event "guildCreate"`; default mode
+     * leaves events out, with a warning once where it would name one. A test reads it; `toEqual` doesn't compare it, so
+     * an assertion on the other fields holds either way.
      */
     readonly inheritedRoutes: readonly string[];
-    /** The `app`'s observers, in the order they are told about the call; empty without an `app`. */
+    /**
+     * The `app`'s observers, in the order they are told about the call; empty without an `app`. Under `useStrictMocks()`,
+     * only those whose `types` include the handler's.
+     */
     readonly observers: readonly (new (...args: any[]) => DispatchObserver)[];
     /**
      * Reads a metadata value as `ExecutionContext.get` does: the method's value, else the controller's.
@@ -2169,8 +2239,10 @@ interface InspectHandlerOptions {
  * Reports what runs when a handler is dispatched, and the metadata declared on it, without running anything.
  *
  * Use it to check that decorators set a handler up as intended: its guards with their params, its interceptors,
- * filters and cooldowns, in the order dispatch applies them. To check what a handler does, run it with
- * {@link TestingModule.invoke}.
+ * filters and cooldowns, in the order dispatch applies them. Under `useStrictMocks()`, the guards, interceptors and
+ * observers are those dispatch runs for the handler's context types: a stage declared with `types` is listed only for
+ * a handler of one of them, and an autocomplete lists no interceptors. Default mode lists every one, with a warning
+ * once where dispatch runs fewer. To check what a handler does, run it with {@link TestingModule.invoke}.
  *
  * @param controller - The controller class declaring the handler.
  * @param methodName - The handler method's name.
@@ -2215,7 +2287,8 @@ interface ResponseReport {
     /**
      * Every answer call the interaction got, through `respond()` or discord.js directly, in order: the payload it sent,
      * without `withResponse`, and the `error` of one Discord refused. Checking a call's `method` types its `payload` as
-     * that method takes it: the options of a reply, an edit or a deferral, the modal shown, or the message deleted.
+     * that method takes it: the options of a reply, an edit or a deferral, the modal shown, the message deleted, or an
+     * autocomplete's choices.
      */
     calls: readonly ((ResponseCall & {
         method: 'reply' | 'followUp';
@@ -2241,15 +2314,25 @@ interface ResponseReport {
     }) | (ResponseCall & {
         method: 'deleteReply';
         payload?: MessageResolvable | '@original';
+    }) | (ResponseCall & {
+        method: 'launchActivity';
+        payload?: Omit<LaunchActivityOptions, 'withResponse'>;
+    }) | (ResponseCall & {
+        method: 'sendPremiumRequired';
+        payload?: undefined;
+    }) | (ResponseCall & {
+        method: 'respond';
+        payload?: readonly ApplicationCommandOptionChoiceData[];
     }))[];
 }
 /**
  * Reports how an interaction was answered: where its answer stands, and every answer call it got, in order.
  *
  * Use it after `invoke` or `dispatch` to check what the member sees. A mock interaction records each `reply`,
- * `deferReply`, `editReply`, `followUp`, `deleteReply`, `update`, `deferUpdate` and `showModal`, whether the handler
- * made it through `respond()` or with discord.js directly, so both are reported, each once. For a message or a
- * reaction, read the mock's own methods.
+ * `deferReply`, `editReply`, `followUp`, `deleteReply`, `update`, `deferUpdate` and `showModal`, and under
+ * `useStrictMocks()` each `launchActivity`, `sendPremiumRequired` and autocomplete `respond` too, whether the handler made
+ * it through `respond()` or with discord.js directly, so both are reported, each once. For a message or a reaction, read
+ * the mock's own methods.
  *
  * @param interaction - The interaction a handler answered.
  * @returns The state, whether anything the member can see was sent, and the calls, in order.