meocord 4.1.2 → 4.2.1

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

@@ -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, 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, DiscordAPIError } from 'discord.js';
 import { ReactionHandlerAction, CommandType } from '../enum/index.js';
-import { a8 as Provider, P as ProviderToken } from '../index-D7n0FBMm.js';
+import { a8 as Provider, P as ProviderToken } from '../index-DKJclIi-.js';
 import { CooldownStore, ExecutionContextType, ExecutionContext, CooldownScope, MetadataDecorator, ResponsePhase, ResponseCall } from '../common/index.js';
 import { DispatchObserver, GuardInterface, InterceptorInterface, ExceptionFilter, ThemeOverride, ThemeResolvers, ThemeResolver, MessageCommandOptions, MessagePrefix, RootTheme, DeepReadonly, MeoCordTheme } from '../interface/index.js';
-export { ao as ClassProvider, F as FactoryProvider, ap as ValueProvider } from '../index-D7n0FBMm.js';
+export { ao as ClassProvider, F as FactoryProvider, ap as ValueProvider } from '../index-DKJclIi-.js';
 import { ThemeCache } from '../common/index.js';
 import { Translator } from '../common/index.js';
 import '@rsbuild/core';
@@ -161,7 +161,11 @@ interface DispatchedCall extends InvocationResult {
  * @category Module
  */
 interface EmitResult {
-    /** How many `@On` and `@Once` handlers ran; a handler a guard denied is not counted. */
+    /**
+     * How many `@On` and `@Once` handlers ran; a handler a guard denied by returning `false` is not counted. A guard
+     * that throws `GuardDeniedError` rejects `emit` instead, as the bot's event fallback, which skips the event, doesn't
+     * run in a testing module.
+     */
     ran: number;
 }
 /**
@@ -194,7 +198,7 @@ interface EmitResult {
  * @category Module
  * @see {@link MeoCordTestingModule}
  * @see {@link getResponse}
- * @see {@link https://meocord.dev/docs/4.1/invoke-and-dispatch | Invoke and dispatch}
+ * @see {@link https://meocord.dev/docs/4.2/invoke-and-dispatch | Invoke and dispatch}
  */
 declare class TestingModule {
     private readonly container;
@@ -224,6 +228,8 @@ declare class TestingModule {
     private resolving?;
     private readying?;
     private closing?;
+    /** The `onReady` hooks' pass, which `close()` waits for, less one whose `onReady` called `close()`. */
+    private readonly readyPass;
     /**
      * Resolves the module's `useFactory` providers, awaiting those that return a promise, in dependency
      * order. `invoke`, `dispatch` and `emit` call it first; call it yourself before `get` resolves anything that
@@ -266,12 +272,21 @@ declare class TestingModule {
      * It first gives up the theme read outside calls, if `init({ ready: true })` made it this module's;
      * reads outside calls then return MeoCord's defaults until another module or app is ready.
      *
+     * A stopped bot runs nothing more. Once `close()` is called, a module still runs what `dispatch`, `invoke` and `emit`
+     * are given, against services shut down, or shutting down, and warns once that it is closed, so a `close()` in the
+     * wrong place shows.
+     *
      * The cooldown store and what it injects shut down last, in the same sequence as the bot's. When any of them has an
      * `onShutdown`, the calls `invoke`, `dispatch` and `emit` have under way finish first, then the store operations
      * they started, so the store's last writes still reach it. The module stops waiting for the whole sequence after
      * its `shutdownTimeout`, 10 seconds unless set, and logs that it did. Give a test whose fake store never answers, or
      * whose `onShutdown` never settles, a short `shutdownTimeout`.
      *
+     * A `close()` while `init({ ready: true })` runs the `onReady` hooks waits for them first, within the same
+     * `shutdownTimeout`. An `onReady` still running once only the hooks' share of it is left is named in a warning, and
+     * its class is shut down all the same, as everything the module constructed is. One that calls `close()` itself isn't
+     * waited for.
+     *
      * @returns Once every hook has run. Rejects with the error of a hook that failed, or an
      *   `AggregateError` naming each when several did.
      *
@@ -287,6 +302,9 @@ declare class TestingModule {
      * ```
      */
     close(): Promise<void>;
+    private warnedClosed;
+    /** Warns once, after `close()`, that a call runs against services already shut down. */
+    private warnIfClosed;
     private runReady;
     /**
      * The module's {@link ThemeCache}: the instance its classes inject, holding what `themeFor`, or
@@ -349,7 +367,9 @@ declare class TestingModule {
      * @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.
+     *   message the handler's route does not match, naming both. 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.
      *
      * @example
      * ```ts
@@ -372,6 +392,13 @@ 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;
+    /**
+     * 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`.
+     */
+    private checkArgumentCount;
     /** The calls under way, each removed once it settles: what `close()` lets finish before the cooldown store stops. */
     private readonly calls;
     /** Counts `call` as under way until it settles. */
@@ -422,15 +449,20 @@ declare class TestingModule {
         action?: ReactionHandlerAction;
     }): Promise<DispatchedCall>;
     /**
-     * Emits a client event to the module's `@On` and `@Once` handlers, through the same pipeline the app
-     * runs them in: 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.
+     * 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.
+     *
+     * 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
+     * as a reply to it; here both reject `emit` as any error does, so a test checks them with `rejects`.
      *
      * @param event - The client event, such as `'guildMemberAdd'`.
      * @param args - The event's arguments, typed from discord.js's `ClientEvents`.
-     * @returns How many handlers ran. Rejects once every handler has settled if any threw: with that
-     *   error when one handler failed, or an `AggregateError` of them when several did.
+     * @returns How many handlers ran. Rejects once every handler has settled if any threw, a guard's
+     *   `GuardDeniedError` and a handler's `UserError` included: with that error when one handler failed,
+     *   or an `AggregateError` of them when several did.
      *
      * @example
      * ```ts
@@ -470,7 +502,7 @@ declare class TestingModule {
  * @group Testing
  * @category Module
  * @see {@link MeoCordTestingModule}
- * @see {@link https://meocord.dev/docs/4.1/testing | The testing module}
+ * @see {@link https://meocord.dev/docs/4.2/testing | The testing module}
  */
 declare class TestingModuleBuilder {
     private readonly options;
@@ -501,6 +533,10 @@ declare class TestingModuleBuilder {
     /**
      * Replaces a guard with a stub wherever it applies, globally or on a controller or handler.
      *
+     * It stands in for the guard wherever the guard is bound, a provider of the same token included, and wins over an
+     * `overrideProvider` of it. The stub needs a `canActivate`, its own or its prototype's: `compile()` refuses one without
+     * it under `useStrictMocks()`, and otherwise warns.
+     *
      * @param guard - The guard class to replace.
      * @example
      * ```ts
@@ -514,6 +550,10 @@ declare class TestingModuleBuilder {
      * Replaces an interceptor with a stub wherever it applies, globally or on a controller or handler.
      * The stub's `intercept` receives the context and `next`; call `next.handle()` to run the handler.
      *
+     * It stands in for the interceptor wherever it is bound, a provider of the same token included, and wins over an
+     * `overrideProvider` of it. A stub without `intercept` is refused by `compile()` under `useStrictMocks()`, and
+     * otherwise warned about.
+     *
      * @param interceptor - The interceptor class to replace.
      * @example
      * ```ts
@@ -527,6 +567,10 @@ declare class TestingModuleBuilder {
      * Replaces an exception filter with a stub wherever it applies. The filter's `@Catch` still decides
      * which errors reach the stub.
      *
+     * It stands in for the filter wherever it is bound, a provider of the same token included, and wins over an
+     * `overrideProvider` of it. A stub without `catch` is refused by `compile()` under `useStrictMocks()`, and otherwise
+     * warned about.
+     *
      * @param filter - The filter class to replace.
      * @example
      * ```ts
@@ -578,7 +622,12 @@ declare class TestingModuleBuilder {
      * its command's builder does not register, a customId pattern given as a command name, a builder that registers
      * another name, and component patterns that can match the same customId are named, as the bot names them.
      *
+     * Each check reports every startup error it finds, and the first is thrown, unchanged; when there are several, each
+     * is logged first, with the file it comes from. After {@link reportAllStartupErrors}, the errors decorators kept on
+     * the classes the module runs are among them.
+     *
      * @returns The compiled module.
+     * @throws Error for the first startup error the checks find.
      */
     compile(): TestingModule;
 }
@@ -609,7 +658,7 @@ declare class TestingModuleBuilder {
  * @category Module
  * @see {@link TestingModuleBuilder}
  * @see {@link TestingModule}
- * @see {@link https://meocord.dev/docs/4.1/testing | The testing module}
+ * @see {@link https://meocord.dev/docs/4.2/testing | The testing module}
  */
 declare class MeoCordTestingModule {
     /**
@@ -702,6 +751,22 @@ interface MockResult<T = unknown> {
     /** What the call returned, or the error it threw. */
     value: T;
 }
+/**
+ * One call's outcome once it has settled, as a mock function records it.
+ *
+ * It holds what a returned promise resolved or rejected with, or what the call returned or threw. Vitest's
+ * `toHaveResolved` and the rest read it.
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link MockState}
+ */
+interface MockSettledResult<T = unknown> {
+    /** `'fulfilled'` once the call resolved or returned, `'rejected'` once it rejected or threw, `'incomplete'` before. */
+    type: 'fulfilled' | 'rejected' | 'incomplete';
+    /** What the call resolved, returned, rejected or threw with; `undefined` while it is incomplete. */
+    value: T | undefined;
+}
 /**
  * What a mock function has recorded: each call's arguments, outcome and `this`, in order.
  *
@@ -720,6 +785,12 @@ interface MockState<T extends (...args: any[]) => any = (...args: any[]) => any>
     readonly instances: any[];
     /** Arguments from the most recent call, or undefined if never called. */
     readonly lastCall?: CallArgs<T>;
+    /** Each call's outcome once it has settled, in order. */
+    readonly settledResults: MockSettledResult<Awaited<CallResult<T>>>[];
+    /** When each call came, as a number that grows across meocord's own mocks. */
+    readonly invocationCallOrder: number[];
+    /** The `this` each call had, in order. */
+    readonly contexts: unknown[];
 }
 /**
  * The mock API of a mock function: what it has recorded, and the methods that change what it does.
@@ -805,12 +876,76 @@ type Mock<T extends (...args: any[]) => any = (...args: any[]) => any> = MockedF
  * @see {@link createMockFn}
  */
 declare function isMockFunction(fn: unknown): fn is MockInstance;
+/**
+ * A mock function a test runner makes, as {@link useMockFn} takes it.
+ *
+ * It is callable, records its calls in `mock.calls`, and has `mockImplementation`, `mockClear` and `mockReset`.
+ * Vitest's `vi.fn`, jest's `jest.fn` and bun's `mock` make one.
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link MockFnFactory}
+ */
+interface RunnerMock {
+    (...args: any[]): any;
+    /** The calls the mock has recorded, each an array of its arguments. */
+    mock: {
+        calls: readonly unknown[][];
+    };
+    /** Sets the implementation the mock runs. */
+    mockImplementation(fn: (...args: any[]) => any): unknown;
+    /** Forgets the calls the mock has recorded. */
+    mockClear(): unknown;
+    /** Forgets the calls and what the mock was told to do. */
+    mockReset(): unknown;
+}
+/**
+ * A test runner's mock function factory, such as `vi.fn`.
+ *
+ * Called with the implementation a mock starts with, it returns the runner's mock. See {@link useMockFn}.
+ *
+ * @group Testing
+ * @category Mocks
+ */
+type MockFnFactory = (impl?: (...args: any[]) => any) => RunnerMock;
+/**
+ * Makes every mock `meocord/testing` creates with the test runner's own mock function, such as Vitest's `vi.fn`.
+ *
+ * Call it once in the runner's setup file. The runner then treats meocord's mocks as its own: its `clearMocks` and
+ * `mockReset` config and `vi.clearAllMocks()` reach them, its matchers read them, and its whole mock API is there.
+ * Without it, mocks are {@link createMockFn}'s own, which jest's and Vitest's `expect` read too.
+ *
+ * @remarks
+ * Each mock starts with the runner's mock holding meocord's behaviour, such as an interaction's replies, as its own
+ * implementation. {@link resetAllMocks} puts that behaviour back where the runner's `mockReset` drops it, as jest's and
+ * bun's do; a runner's own reset-all, such as jest's `resetMocks`, can't, so under jest and bun reset with
+ * {@link resetAllMocks}. node:test's `mock.fn` records calls in a shape of its own, so under node:test leave meocord's
+ * own function in place. Calling it again with the same factory does nothing; another, once a mock exists, throws.
+ *
+ * @param factory - The runner's mock function factory: `vi.fn`, `jest.fn` or bun's `mock`.
+ * @throws Error when a mock already exists from another factory, or when `factory` doesn't make a mock with jest's and
+ *   Vitest's API.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * import { vi } from 'vitest'
+ *
+ * useMockFn(vi.fn)
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link createMockFn}
+ */
+declare function useMockFn(factory: MockFnFactory): void;
 /**
  * Clears the calls every mock from `meocord/testing` has recorded, keeping what each was told to do.
  *
- * Vitest's `clearMocks` and jest's `clearAllMocks()` reach only their own `vi.fn()` and `jest.fn()` mocks. This one
- * covers `createMockFn` and everything built on it, such as `createMockInteraction` and `createMockClient`. To also
- * undo what a test set, use {@link resetAllMocks}.
+ * Vitest's `clearMocks` and jest's `clearAllMocks()` reach only their own `vi.fn()` and `jest.fn()` mocks, and
+ * meocord's too once {@link useMockFn} makes them with the runner's function. This one covers `createMockFn` and
+ * everything built on it, such as `createMockInteraction` and `createMockClient`, either way. To also undo what a test
+ * set, use {@link resetAllMocks}.
  *
  * @example
  * ```ts
@@ -850,12 +985,21 @@ declare function resetAllMocks(): void;
  * Creates a mock function that jest's and Vitest's `expect` both read.
  *
  * Use it for a function double in code that must not depend on one test runner, such as a shared test helper; in a
- * Vitest test, `vi.fn()` works as well. {@link clearAllMocks} and {@link resetAllMocks} reach it.
+ * Vitest test, `vi.fn()` works as well. {@link clearAllMocks} and {@link resetAllMocks} reach it. Once
+ * {@link useMockFn} registers a runner's function, it returns that runner's mock.
  *
  * @remarks
  * `mockReturnValue`, `mockResolvedValue`, `mockRejectedValue` and `mockImplementation` share one implementation, so
  * the last one set wins. The `*Once` variants queue, and run first, in the order they were set.
  *
+ * It records what Vitest's `toHaveResolved` and `toHaveBeenCalledBefore` read as well. Its call order is counted
+ * across meocord's own mocks, apart from the runner's, so compare the order of two of meocord's mocks, or of two of the
+ * runner's, not one of each.
+ *
+ * A promise the implementation returns is handed back as one that settles the same way, not as the same object: test
+ * it with `toEqual`, `toHaveReturnedWith` or by awaiting it, not with `toBe`. A property set on the given promise, such
+ * as a `cancel` method, isn't carried over.
+ *
  * @param impl - The implementation to run until another is set.
  *
  * @example
@@ -927,6 +1071,11 @@ type OutsideServer = {
 } | {
     channel: DMChannel | PartialGroupDMChannel;
 };
+type NotRaw<T> = T extends {
+    member: unknown;
+} ? {
+    member?: Exclude<MockProps<T>['member'], APIInteractionGuildMember>;
+} : unknown;
 /**
  * Creates a mock instance of a discord.js class, such as an interaction, keeping its prototype so `instanceof` holds.
  *
@@ -938,19 +1087,31 @@ type OutsideServer = {
  * `user` of its own unless given, and its `locale` is `'en-US'`; without a `guildId` it is a DM, and with one its
  * `member` is its user: for a `user` given, when the test gives the `guild`, the guild's cached member for that user,
  * so a message and an interaction from one user in that server share it, and `memberPermissions` are that member's
- * permissions (`null` in a DM). A user is a person, `bot: false`, and a member has the server's @everyone role and the
- * roles {@link createMockMember} gave it; with a `guildId` but no `guild`, a server the bot isn't in, that @everyone role
- * has the `guildId`. A DM sent to a member goes through its user's `send()` and the user's one DM channel. Its
- * `channel` is a text channel of its server, the one its guild caches under `channelId`, or the user's DM channel. A
- * `channel` given sets what the test leaves out of `channelId`, `guildId` and `guild`, as discord.js reads them from
- * it: a DM channel is no server, and a server's channel its server; one in another server than the `guildId` given is
- * refused, naming both. A select menu has picked nothing unless given: its
- * `values` are the ids of the `users` and `members`, `roles` or `channels` given, the 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. Every method is a mock function, and one that returns a
- * promise in discord.js resolves.
+ * permissions, with its channel's overwrites applied under `useStrictMocks()` (`null` in a DM). A user is a person,
+ * `bot: false`, and a member has the server's @everyone role and the roles {@link createMockMember} gave it; with a
+ * `guildId` but no `guild`, a server the bot isn't in, that @everyone role has the `guildId`. A DM sent to a member
+ * goes through its user's `send()` and the user's one DM channel. Its `channel` is a text channel of its server, the
+ * one its guild caches under `channelId` when it is read, or the user's DM channel. A `channel` given sets what the test leaves out of
+ * `channelId`, `guildId` and `guild`, as discord.js reads them from it: a DM channel is no server, and a server's
+ * channel its server; one in another server than the `guildId` given is refused, naming both. Under `useStrictMocks()`
+ * a `message` given places it in the message's channel and server, a `guild` or a member's guild in that server, and a
+ * `guildId` alone in a server the bot isn't in, with no `guild` or `channel` and a raw member for its user; a
+ * `channel`, `guild` or `guildId` other than the place a test gave the message is refused, and a message whose place
+ * `createMockMessage()` made moves to the one given. In default mode it stays where its own channel and guild fields
+ * place it, and reading where it is warns once where strict mocks would place it otherwise. A select menu has picked
+ * nothing unless given: its `values` are the ids of the `users` and `members`, `roles` or `channels` given, the
+ * 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. 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
+ * `update()` sent; after `deleteReply()`, or before any answer, fetching, editing or deleting the original response
+ * rejects with 10008 (Unknown Message), while follow-ups stay reachable by their id. Flags are read as discord.js
+ * reads them, and its errors carry its codes, such as `InteractionAlreadyReplied`.
  *
  * Given `guild: null`, `member: null` or a DM channel, it is typed as an interaction that may come from anywhere, so
  * its `guild` and `member` read as possibly `null`; otherwise as one from a server the bot is in.
@@ -973,9 +1134,37 @@ type OutsideServer = {
  * @category Mocks
  * @see {@link MockProps}
  * @see {@link createChatInputOptions}
- * @see {@link https://meocord.dev/docs/4.1/mocks | Mocks}
+ * @see {@link https://meocord.dev/docs/4.2/mocks | Mocks}
  */
-declare function createMockInteraction<T extends object>(Class: InteractionClass<T>, props?: MockProps<T>): DeepMocked<T>;
+declare function createMockInteraction<T extends object>(Class: InteractionClass<T>, props?: MockProps<T> & NotRaw<T>): DeepMocked<T>;
+/**
+ * Creates a mock interaction from a server the bot isn't in: one given a {@link createMockRawMember | raw member} and
+ * that server's `guildId`, with no `channel`, as discord.js caches none there, as a user-installed command run there
+ * arrives.
+ *
+ * It is typed as discord.js types an interaction from such a server, `'raw'`: its `guild` is `null` and its `member`
+ * the raw member. Everything else is as {@link createMockInteraction} builds it.
+ *
+ * @param Class - The discord.js interaction class to mock.
+ * @param props - The interaction's properties, with the raw `member` and the server's `guildId`; see {@link MockProps}.
+ *
+ * @example
+ * ```ts
+ * import { expect } from 'vitest'
+ *
+ * const command = createMockInteraction(ChatInputCommandInteraction, { guildId: '100000000000000001', member: createMockRawMember() })
+ * expect(command.inRawGuild()).toBe(true)
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ */
+declare function createMockInteraction<T extends object>(Class: InteractionClass<T>, props: Omit<MockProps<WithCache<T, 'raw'>>, 'options' | 'channel'> & {
+    options?: object;
+    guildId: string;
+    member: APIInteractionGuildMember;
+    channel?: never;
+}): DeepMocked<WithCache<T, 'raw'>>;
 /**
  * Creates a mock interaction from outside a server: one given `guild: null`, `member: null` or a DM channel, as from a
  * direct message or a server the bot isn't in.
@@ -997,7 +1186,7 @@ declare function createMockInteraction<T extends object>(Class: InteractionClass
  * @group Testing
  * @category Mocks
  */
-declare function createMockInteraction<T extends object>(Class: InteractionClass<T>, props: MockProps<WithCache<T, CacheType>> & OutsideServer): DeepMocked<WithCache<T, CacheType>>;
+declare function createMockInteraction<T extends object>(Class: InteractionClass<T>, props: MockProps<WithCache<T, CacheType>> & OutsideServer & NotRaw<WithCache<T, CacheType>>): DeepMocked<WithCache<T, CacheType>>;
 /**
  * Creates a mock of any type, with no class needed, for service doubles and interfaces.
  *
@@ -1056,7 +1245,7 @@ declare function createMock<T extends object>(props?: MockProps<T>): DeepMocked<
  * @category Mocks
  * @see {@link createMockInteraction}
  */
-declare const createMockUser: (props?: MockProps<User>) => DeepMocked<User>;
+declare function createMockUser(props?: MockProps<User>): DeepMocked<User>;
 /**
  * Creates a mock {@link Client}, with `users`, `channels`, `guilds` and `application.commands` ready to stub.
  *
@@ -1171,6 +1360,48 @@ type ChannelOf<T> = T extends ThreadChannel ? AnyThreadChannel : T;
  * @see {@link createMockGuild}
  */
 declare function createMockChannel<T extends BaseChannel>(Class: InteractionClass<T>, props?: MockProps<T>): DeepMocked<ChannelOf<T>>;
+/**
+ * What {@link createMockRawMember} builds a member with: any field Discord sends, with `permissions` as a permission
+ * set and `user` as the fields of the user given.
+ *
+ * @group Testing
+ * @category Mocks
+ */
+type MockRawMemberOverrides = Partial<Omit<APIInteractionGuildMember, 'permissions' | 'user'>> & {
+    /** The member's permissions in the channel; unless given, what @everyone has in a server Discord makes today. */
+    permissions?: PermissionResolvable;
+    /** The member's user; a new person, `username` `'user'`, unless given. */
+    user?: Partial<APIUser>;
+};
+/**
+ * Creates the member Discord sends with an interaction from a server the bot isn't in, as discord.js keeps it.
+ *
+ * Give it as an interaction's `member`, with the server's `guildId` and no `guild`, to test a user-installed command
+ * run there: the interaction reads `inRawGuild()` true, `guild` and `channel` null, `user` the member's user and
+ * `memberPermissions` the member's, and a user option's member is the plain member Discord resolves too.
+ *
+ * @remarks
+ * It is plain data, not a `GuildMember`: `roles` are role ids, `permissions` is the permission bitfield as a string,
+ * and the rest are as Discord sends them, `null` for what may be absent and `false` for a flag. Code that reads
+ * `member.roles.cache` throws on it, as it does in Discord.
+ *
+ * @param overrides - Fields for the member; see {@link MockRawMemberOverrides}.
+ * @returns The member, as an `APIInteractionGuildMember`.
+ *
+ * @example
+ * ```ts
+ * import { expect } from 'vitest'
+ *
+ * const member = createMockRawMember({ roles: ['300000000000000001'], permissions: [PermissionFlagsBits.SendMessages] })
+ * const command = createMockInteraction(ChatInputCommandInteraction, { guildId: '100000000000000001', member })
+ * expect(command.inRawGuild()).toBe(true)
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link createMockMember}
+ */
+declare function createMockRawMember(overrides?: MockRawMemberOverrides): APIInteractionGuildMember;
 /**
  * What {@link createMockMember} builds a member with.
  *
@@ -1201,8 +1432,9 @@ interface MockMemberOverrides {
  * highest, by position, then the lower id. `permissions` are computed as discord.js computes them: every permission for
  * the server's owner, and otherwise its roles' permissions combined, @everyone's included, so a member with no roles has
  * @everyone's alone. The member is put in its guild's member cache, so an interaction or a message from its user in that
- * server has it as its `member`, and `memberPermissions` are its permissions. A DM sent to the member goes through its
- * user's `send()` and the user's one DM channel.
+ * server has it as its `member`, and `memberPermissions` are its permissions, with the interaction's channel's
+ * overwrites applied under `useStrictMocks()`. A DM sent to the member goes through its user's `send()` and the user's
+ * one DM channel.
  *
  * @param overrides - The member's user, server, roles and nickname; see {@link MockMemberOverrides}.
  * @returns The mock member.
@@ -1244,9 +1476,12 @@ interface MockMessageOverrides {
      * on the message's client, and in a server its `member` is the guild's cached member for that user, or a new one.
      */
     author?: User;
-    /** Its top-level components: action rows, or Components V2 such as a container. */
+    /**
+     * Its top-level components: action rows, or Components V2 such as a container. Builders or API JSON, held as
+     * discord.js's classes, such as `ActionRow` and `ButtonComponent`, built from their JSON at the time of the call.
+     */
     components?: readonly (APIMessageTopLevelComponent | JSONEncodable<APIMessageTopLevelComponent>)[];
-    /** Its embeds. */
+    /** Its embeds, builders or API JSON, held as discord.js's `Embed` built from their JSON at the time of the call. */
     embeds?: readonly (APIEmbed | JSONEncodable<APIEmbed>)[];
     /** Its flags: a number, flag names or a `MessageFlagsBitField`. */
     flags?: MessageFlagsResolvable;
@@ -1274,12 +1509,14 @@ interface MockMessageOverrides {
  * `@MessageHandler` does not skip it.
  *
  * @remarks
- * `delete()`, `edit()`, `reply()`, `react()`, `pin()` and `unpin()` throw once the message is deleted, and `edit()`
- * and `reply()` resolve to a new mock message. Without overrides the message is empty, in a server, from a new
- * person who is its `member`; with `guild: null` it is a direct message. Give `author` to send several messages as
- * one user, such as to reach a per-user cooldown. An author given, and the users, roles and channels the content
- * mentions, are cached as the gateway delivers them. It is typed as discord.js emits a message, never in a group DM,
- * so it fits `messageCreate` and the other message events.
+ * `delete()`, `edit()`, `reply()`, `react()`, `pin()` and `unpin()` throw once the message is deleted. `edit()` changes
+ * this message and resolves to it, and `reply()` resolves to the reply, sent in this message's channel and holding what
+ * was sent, as a channel's `send()` does. Under `useStrictMocks()` a message the bot sends is its `client.user`'s, and
+ * one sent in a DM is in that DM. Without overrides the message is empty, in a server, from a new person who is its
+ * `member`; with `guild: null` it is a direct message. Give `author` to send several messages as one user, such as to
+ * reach a per-user cooldown. An author given, and the users, roles and channels the content mentions, are cached as the
+ * gateway delivers them. It is typed as discord.js emits a message, never in a group DM, so it fits `messageCreate` and
+ * the other message events.
  *
  * @param overrides - The message's content, components and the rest; see {@link MockMessageOverrides}.
  *
@@ -1344,6 +1581,10 @@ interface ChatInputOptions {
  * A whole number is an Integer option and a fraction a Number one, so
  * `getInteger()` reads only a whole number, and `getNumber()` reads either.
  *
+ * 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.
+ *
  * @typeParam Cached - `any` by default, to match `createMockInteraction(ChatInputCommandInteraction)`; pass it when the
  *   interaction under test is cache-pinned.
  *
@@ -1365,6 +1606,76 @@ interface ChatInputOptions {
  */
 declare function createChatInputOptions<Cached extends CacheType = any>(opts?: ChatInputOptions): DeepMocked<CommandInteractionOptionResolver<Cached>>;
 
+/**
+ * Has every mock from `meocord/testing` compute the values discord.js computes, where it reads a placeholder otherwise.
+ *
+ * Call it once in the test runner's setup file. A message's `editable`, `deletable`, `pinnable`, `crosspostable`,
+ * `bulkDeletable`, `hasThread` and `partial`, a member's `manageable`, `kickable`, `bannable` and `moderatable`, a
+ * role's `editable`, a channel's and a thread's `viewable`, `manageable`, `deletable`, `joinable` and the rest, a voice
+ * channel's `full`, and `partial` on users, channels and reactions then run discord.js's own getters against the mock,
+ * and `message.thread` is `null` when the channel caches no thread under the message's id. So do a message's
+ * `editedAt`, a member's `presence`, a server's `verified` and `systemChannel` and a channel's `parent`, each `null` or
+ * `false` until the test gives what it is computed from. A reaction's `me` is `false`, a message's
+ * `mentions.repliedUser` and a modal's `message` are `null`, and a reaction has a whole message of its own, so
+ * MeoCord's dispatcher fetches neither. No placeholder warning is logged.
+ *
+ * @remarks
+ * Those getters read what a server holds, so strict mocks also have it as Discord sends it: the bot's member is in the
+ * server's member cache from the start, @everyone has the permissions Discord gives it in a new server, and a channel
+ * or thread made without a server has one of its own, a thread with a text channel as its parent. A message has empty
+ * `content`, a thread is neither archived nor locked, and a reaction's `count` is 1. A user, server or channel made
+ * with a generated id was created when the mock was made, as a message is. An interaction's `memberPermissions` apply
+ * its channel's overwrites, a thread's parent's for a thread, to its member's permissions. An interaction is in its
+ * message's channel and server, a guild's or a member's server, or, given a `guildId` alone, a server the bot isn't in.
+ * A message the bot sends is its `client.user`'s, and one it sends in a DM is in that DM. Give the bot's member a role
+ * to let it do more, such as kick a member its role ranks above. A value the test sets on a mock wins over the computed
+ * one. An interaction's answer that discord.js would refuse, such as a second `reply()` after one a test set with
+ * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. The next major version (5.0)
+ * computes these values, and refuses those answers, without the call.
+ *
+ * `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.
+ *
+ * `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.
+ *
+ * @throws Error when a mock already exists, which was made without it.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * useStrictMocks()
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link useMockFn}
+ * @see {@link https://meocord.dev/docs/4.2/mocks | Mocks}
+ */
+declare function useStrictMocks(): void;
+
+/**
+ * Has decorators keep the startup errors they find, as a bot built with `startupErrors: 'all'` does, so a testing
+ * module reports every one at once.
+ *
+ * Call it once in the test runner's setup file, before any test imports a controller: a decorator runs when its class
+ * is defined, as its file is imported. A decorator given what it cannot use then throws nothing as the file loads, and
+ * `MeoCordTestingModule.create(...).compile()` logs every startup error of the classes it runs, each with its handler
+ * and file, then throws the first. Without it, a decorator throws its error as its class is defined.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * reportAllStartupErrors()
+ * ```
+ *
+ * @group Testing
+ * @category Module
+ * @see {@link MeoCordTestingModule}
+ * @see {@link https://meocord.dev/docs/4.2/configuration | Configuration}
+ */
+declare function reportAllStartupErrors(): void;
+
 /**
  * The command types routed by a `customId` pattern: buttons, select menus and modals.
  *
@@ -1423,9 +1734,16 @@ interface ResolvedRoute {
      * handler receives `params`.
      */
     values?: Record<string, string | number | boolean>;
+    /**
+     * For a component route, the other patterns of its type that match the `customId` too, in the order they rank
+     * behind it: the ones that lost to it. Absent when no other pattern matches. A test reads it; `toEqual` doesn't
+     * compare it, so an assertion on the other fields holds either way.
+     */
+    alsoMatches?: string[];
 }
 /**
- * Two patterns of one component type that can both match a `customId`, as {@link findRouteConflicts} reports them.
+ * Two patterns of one component type that rank equally and can both match a `customId`, as {@link findRouteConflicts}
+ * reports them.
  *
  * @group Testing
  * @category Inspection
@@ -1435,6 +1753,11 @@ interface RouteConflict {
     type: ComponentCommandType;
     /** The two patterns. */
     patterns: [string, string];
+    /**
+     * The pattern that runs for the `customId`s both match: the one listed first. A test reads it; `toEqual` doesn't
+     * compare it, so an assertion on `type` and `patterns` alone holds.
+     */
+    runs: string;
 }
 /**
  * Resolves which handler a component's `customId` or a message's content reaches, as dispatch routes it.
@@ -1471,33 +1794,36 @@ interface RouteConflict {
  * @group Testing
  * @category Inspection
  * @see {@link findRouteConflicts}
- * @see {@link https://meocord.dev/docs/4.1/components | Buttons, selects and modals}
+ * @see {@link https://meocord.dev/docs/4.2/components | Buttons, selects and modals}
  */
 declare function resolveRoute(app: ControllerClass, input: {
     type: ComponentCommandType;
     customId: string;
 } | MessageToResolve): ResolvedRoute | undefined;
 /**
- * Finds component patterns that can match the same `customId`, which MeoCord otherwise only warns about at startup.
+ * Finds component patterns that rank equally and can match the same `customId`, which MeoCord otherwise only warns
+ * about at startup.
  *
- * Use it in a test to keep the warning from reaching production: two patterns that trade a literal for a parameter
- * in opposite places both take one id, and neither is more specific. Patterns are compared within a component type.
+ * Use it in a test to keep the warning from reaching production. Patterns rank segment by segment, a literal before a
+ * param and then the narrower type, so two collide only with the same literals and equally narrow params at each
+ * position, such as `{action:close|reopen}` and `{step:close|confirm}`, which both take `close`; the one listed
+ * first runs. Patterns are compared within a component type.
  *
  * @param app - The application class decorated with `@MeoCord`.
- * @returns Each pair of patterns that can match the same `customId`, with its component type.
+ * @returns Each pair of patterns that rank equally and can match the same `customId`, with its component type.
  *
  * @example
  * ```ts
  * import { expect } from 'vitest'
  *
  * @Controller()
- * class CardController {
- *   @Command('card/{id}/open', CommandType.BUTTON)
- *   async open(interaction: ButtonInteraction) { await respond(interaction).send('Opened.') }
- *   @Command('card/new/{kind}', CommandType.BUTTON)
- *   async create(interaction: ButtonInteraction) { await respond(interaction).send('Created.') }
+ * class TicketController {
+ *   @Command('ticket/{action:close|reopen}', CommandType.BUTTON)
+ *   async act(interaction: ButtonInteraction) { await respond(interaction).send('Done.') }
+ *   @Command('ticket/{step:close|confirm}', CommandType.BUTTON)
+ *   async step(interaction: ButtonInteraction) { await respond(interaction).send('Next.') }
  * }
- * @MeoCord({ controllers: [CardController], clientOptions: { intents: [] } })
+ * @MeoCord({ controllers: [TicketController], clientOptions: { intents: [] } })
  * class App {}
  * expect(findRouteConflicts(App)).toHaveLength(1)
  * ```
@@ -1549,9 +1875,11 @@ 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, and each `{param}` a translation uses that the message it translates doesn't take. 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.
+ * 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.
  *
  * @remarks
  * MeoCord's own texts, a catalog's `meocord` group, fall back to English by design, so only a key MeoCord lacks, and
@@ -1584,7 +1912,7 @@ declare function createModalFields(values: Record<string, string | string[] | At
  * @group Testing
  * @category Inspection
  * @see {@link createTranslator}
- * @see {@link https://meocord.dev/docs/4.1/localisation | Localisation}
+ * @see {@link https://meocord.dev/docs/4.2/localisation | Localisation}
  */
 declare function expectCompleteCatalog(translator: Translator<any>, options?: {
     meocord?: boolean;
@@ -1620,9 +1948,11 @@ interface CooldownStoreSuiteFramework {
  *
  * @remarks
  * The cases cover what a shared store most often gets wrong: a sliding window rather than fixed buckets,
- * `retryAfterMs` from the oldest call still in the window, calls in the same millisecond kept apart, and concurrent
- * calls at the limit where exactly one may pass. They use real time, with windows short enough that the suite takes
- * a few seconds, and each case counts under keys of its own. Each window is a whole number of milliseconds, as
+ * `retryAfterMs` until a use frees up, from the oldest of the newest `uses` calls in the window, calls in the same
+ * millisecond kept apart, concurrent calls at the limit where exactly one may pass, a batch refusal that names the
+ * longest wait, and a release that frees only the call it gave back. They use real time, with windows short enough that the suite takes
+ * a few seconds and margins wide enough that a correct store passes when timers fire late, as on a busy CI runner,
+ * and each case counts under keys of its own. Each window is a whole number of milliseconds, as
  * `@Cooldown` gives a store: it rounds its `seconds` to the millisecond.
  *
  * @param name - What the store is called in the report.
@@ -1639,7 +1969,7 @@ interface CooldownStoreSuiteFramework {
  * @group Testing
  * @category Inspection
  * @see {@link CooldownStore}
- * @see {@link https://meocord.dev/docs/4.1/recipes/cooldown-stores | Cooldown stores}
+ * @see {@link https://meocord.dev/docs/4.2/recipes/cooldown-stores | Cooldown stores}
  */
 declare function testCooldownStore(name: string, factory: () => CooldownStore | Promise<CooldownStore>, { describe, it, expect }: CooldownStoreSuiteFramework): void;
 
@@ -1751,6 +2081,12 @@ interface HandlerInspection {
     readonly cooldowns: readonly InspectedCooldown[];
     /** The `@MessageHandler` pattern, or `undefined` for a listener and for any other kind of handler. */
     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.
+     */
+    readonly inheritedRoutes: readonly string[];
     /** The `app`'s observers, in the order they are told about the call; empty without an `app`. */
     readonly observers: readonly (new (...args: any[]) => DispatchObserver)[];
     /**
@@ -1847,7 +2183,7 @@ interface InspectHandlerOptions {
  * @group Testing
  * @category Inspection
  * @see {@link createExecutionContext}
- * @see {@link https://meocord.dev/docs/4.1/testing-recipes | Testing recipes}
+ * @see {@link https://meocord.dev/docs/4.2/testing-recipes | Testing recipes}
  */
 declare function inspectHandler<C extends new (...args: any[]) => unknown>(controller: C, methodName: keyof InstanceType<C> & string, options?: InspectHandlerOptions): HandlerInspection;
 
@@ -1925,7 +2261,7 @@ interface ResponseReport {
  * @group Testing
  * @category Inspection
  * @see {@link TestingModule}
- * @see {@link https://meocord.dev/docs/4.1/invoke-and-dispatch | Invoke and dispatch}
+ * @see {@link https://meocord.dev/docs/4.2/invoke-and-dispatch | Invoke and dispatch}
  */
 declare function getResponse(interaction: Interaction): ResponseReport;
 /**
@@ -1982,7 +2318,7 @@ type MockThemeArgs = Partial<RootTheme> extends RootTheme ? [overrides?: RootThe
  * @group Testing
  * @category Mocks
  * @see {@link withTheme}
- * @see {@link https://meocord.dev/docs/4.1/theming | Theming}
+ * @see {@link https://meocord.dev/docs/4.2/theming | Theming}
  */
 declare function createMockTheme(...[overrides]: MockThemeArgs): DeepReadonly<MeoCordTheme>;
 /**
@@ -2011,5 +2347,5 @@ declare function createMockTheme(...[overrides]: MockThemeArgs): DeepReadonly<Me
  */
 declare function withTheme<T>(theme: DeepReadonly<MeoCordTheme> | RootTheme, fn: () => T): T;
 
-export { MeoCordTestingModule, Provider, ProviderToken, TestingModule, TestingModuleBuilder, clearAllMocks, createChatInputOptions, createDiscordError, createExecutionContext, createMock, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMember, createMockMessage, createMockTheme, createMockUser, createModalFields, expectCompleteCatalog, findRouteConflicts, getResponse, inspectHandler, isMockFunction, resetAllMocks, resolveRoute, testCooldownStore, withTheme };
-export type { ChatInputOptions, ComponentCommandType, CooldownStoreSuiteFramework, DeepMocked, DispatchedCall, DispatchedHandler, EmitResult, ExecutionContextOptions, FromAppOptions, HandlerInspection, HandlerName, InspectHandlerOptions, InspectedCooldown, InspectedFilter, InspectedGuard, InspectedInterceptor, InvocationResult, MessageToResolve, Mock, MockGuildOverrides, MockInstance, MockMemberOverrides, MockMessageOverrides, MockProps, MockResult, MockState, MockedFunction, ResolvedRoute, ResponseReport, RouteConflict, TestingModuleInitOptions, TestingModuleOptions };
+export { MeoCordTestingModule, Provider, ProviderToken, TestingModule, TestingModuleBuilder, clearAllMocks, createChatInputOptions, createDiscordError, createExecutionContext, createMock, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMember, createMockMessage, createMockRawMember, createMockTheme, createMockUser, createModalFields, expectCompleteCatalog, findRouteConflicts, getResponse, inspectHandler, isMockFunction, reportAllStartupErrors, resetAllMocks, resolveRoute, testCooldownStore, useMockFn, useStrictMocks, withTheme };
+export type { ChatInputOptions, ComponentCommandType, CooldownStoreSuiteFramework, DeepMocked, DispatchedCall, DispatchedHandler, EmitResult, ExecutionContextOptions, FromAppOptions, HandlerInspection, HandlerName, InspectHandlerOptions, InspectedCooldown, InspectedFilter, InspectedGuard, InspectedInterceptor, InvocationResult, MessageToResolve, Mock, MockFnFactory, MockGuildOverrides, MockInstance, MockMemberOverrides, MockMessageOverrides, MockProps, MockRawMemberOverrides, MockResult, MockSettledResult, MockState, MockedFunction, ResolvedRoute, ResponseReport, RouteConflict, RunnerMock, TestingModuleInitOptions, TestingModuleOptions };