diff --git a/test/@types/vitest.d.ts b/test/@types/vitest.d.ts
index 77e1b277cda..fbf020b50a4 100644
--- a/test/@types/vitest.d.ts
+++ b/test/@types/vitest.d.ts
@@ -13,6 +13,8 @@ import type { PokemonType } from "#enums/pokemon-type";
 import type { PositionalTagType } from "#enums/positional-tag-type";
 import type { BattleStat, EffectiveStat } from "#enums/stat";
 import type { WeatherType } from "#enums/weather-type";
+import type { Pokemon } from "#field/pokemon";
+import type { GameManager } from "#test/test-utils/game-manager";
 import type { toHaveArenaTagOptions } from "#test/test-utils/matchers/to-have-arena-tag";
 import type { toHaveBattlerTagOptions } from "#test/test-utils/matchers/to-have-battler-tag";
 import type { toHaveEffectiveStatOptions } from "#test/test-utils/matchers/to-have-effective-stat";
@@ -25,189 +27,196 @@ import type { AtLeastOne } from "#types/type-helpers";
 import type { toDmgValue } from "#utils/common";
 import type { expect } from "vitest";
 
+// #region Boilerplate
 declare module "vitest" {
-  interface Assertion<T> {
-    // #region Generic Matchers
-
-    /**
-     * Check whether an array contains EXACTLY the given items (in any order).
-     *
-     * Different from {@linkcode expect.arrayContaining} as the latter only checks for subset equality
-     * (as opposed to full equality).
-     *
-     * @param expected - The expected contents of the array, in any order
-     * @see {@linkcode expect.arrayContaining}
-     */
-    toEqualArrayUnsorted(expected: T[]): void;
-
-    /**
-     * Check whether a {@linkcode Map} contains the given key, disregarding its value.
-     * @param expectedKey - The key whose inclusion is being checked
-     * @privateRemarks
-     * While this functionality _could_ be simulated by writing
-     * `expect(x.get(y)).toBeDefined()` or
-     * `expect(x).toContain[y, expect.anything()]`,
-     * this is still preferred due to being more ergonomic and provides better error messsages.
-     */
-    toHaveKey<E>(expectedKey: E): void;
-
-    // #endregion Generic Matchers
-
-    // #region GameManager Matchers
-
-    /**
-     * Check if the {@linkcode GameManager} has shown the given message at least once in the current test case.
-     * @param expectedMessage - The expected message to be displayed
-     * @remarks
-     * Strings consumed by this function should _always_ be produced by a call to `i18n.t`
-     * to avoid hardcoding text into test files.
-     */
-    toHaveShownMessage(expectedMessage: string): void;
-
-    /**
-     * Check if the currently-running {@linkcode Phase} is of the given type.
-     * @param expectedPhase - The expected {@linkcode PhaseString | name of the phase}
-     */
-    toBeAtPhase(expectedPhase: PhaseString): void;
-    // #endregion GameManager Matchers
-
-    // #region Arena Matchers
-
-    /**
-     * Check whether the current {@linkcode WeatherType} is as expected.
-     * @param expectedWeatherType - The expected {@linkcode WeatherType}
-     */
-    toHaveWeather(expectedWeatherType: WeatherType): void;
-
-    /**
-     * Check whether the current {@linkcode TerrainType} is as expected.
-     * @param expectedTerrainType - The expected {@linkcode TerrainType}
-     */
-    toHaveTerrain(expectedTerrainType: TerrainType): void;
-
-    /**
-     * Check whether the current {@linkcode Arena} contains the given {@linkcode ArenaTag}.
-     * @param expectedTag - A partially-filled {@linkcode ArenaTag} containing the desired properties
-     */
-    toHaveArenaTag<A extends ArenaTagType>(expectedTag: toHaveArenaTagOptions<A>): void;
-    /**
-     * Check whether the current {@linkcode Arena} contains the given {@linkcode ArenaTag}.
-     * @param expectedType - The {@linkcode ArenaTagType} of the desired tag
-     * @param side - The {@linkcode ArenaTagSide | side(s) of the field} the tag should affect; default {@linkcode ArenaTagSide.BOTH}
-     */
-    toHaveArenaTag(expectedType: ArenaTagType, side?: ArenaTagSide): void;
-
-    /**
-     * Check whether the current {@linkcode Arena} contains the given {@linkcode PositionalTag}.
-     * @param expectedTag - A partially-filled `PositionalTag` containing the desired properties
-     */
-    toHavePositionalTag<P extends PositionalTagType>(expectedTag: toHavePositionalTagOptions<P>): void;
-    /**
-     * Check whether the current {@linkcode Arena} contains the given number of {@linkcode PositionalTag}s.
-     * @param expectedType - The {@linkcode PositionalTagType} of the desired tag
-     * @param count - The number of instances of {@linkcode expectedType} that should be active;
-     * defaults to `1` and must be within the range `[0, 4]`
-     */
-    toHavePositionalTag(expectedType: PositionalTagType, count?: number): void;
-
-    // #endregion Arena Matchers
-
-    // #region Pokemon Matchers
-
-    /**
-     * Check whether a {@linkcode Pokemon}'s current typing includes the given types.
-     * @param expectedTypes - The expected {@linkcode PokemonType}s to check against; must have length `>0`
-     * @param options - The {@linkcode toHaveTypesOptions | options} passed to the matcher
-     */
-    toHaveTypes(expectedTypes: PokemonType[], options?: toHaveTypesOptions): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} has used a move matching the given criteria.
-     * @param expectedMove - The {@linkcode MoveId} the Pokemon is expected to have used,
-     * or a partially filled {@linkcode TurnMove} containing the desired properties to check
-     * @param index - The index of the move history entry to check, in order from most recent to least recent; default `0`
-     * @see {@linkcode Pokemon.getLastXMoves}
-     */
-    toHaveUsedMove(expectedMove: MoveId | AtLeastOne<TurnMove>, index?: number): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon}'s effective stat is as expected
-     * (checked after all stat value modifications).
-     * @param stat - The {@linkcode EffectiveStat} to check
-     * @param expectedValue - The expected value of {@linkcode stat}
-     * @param options - The {@linkcode toHaveEffectiveStatOptions | options} passed to the matcher
-     * @remarks
-     * If you want to check the stat **before** modifiers are applied, use {@linkcode Pokemon.getStat} instead.
-     */
-    toHaveEffectiveStat(stat: EffectiveStat, expectedValue: number, options?: toHaveEffectiveStatOptions): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} has a specific {@linkcode StatusEffect | non-volatile status effect}.
-     * @param expectedStatusEffect - The {@linkcode StatusEffect} the Pokemon is expected to have,
-     * or a partially filled {@linkcode Status} containing the desired properties
-     */
-    toHaveStatusEffect(expectedStatusEffect: expectedStatusType): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} has a specific {@linkcode Stat} stage.
-     * @param stat - The {@linkcode BattleStat} to check
-     * @param expectedStage - The expected stat stage value of {@linkcode stat}
-     */
-    toHaveStatStage(stat: BattleStat, expectedStage: number): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} has the given {@linkcode BattlerTag}.
-     * @param expectedTag - A partially-filled {@linkcode BattlerTag} containing the desired properties
-     */
-    toHaveBattlerTag<B extends BattlerTagType>(expectedTag: toHaveBattlerTagOptions<B>): void;
-    /**
-     * Check whether a {@linkcode Pokemon} has the given {@linkcode BattlerTag}.
-     * @param expectedType - The expected {@linkcode BattlerTagType}
-     */
-    toHaveBattlerTag(expectedType: BattlerTagType): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} has applied a specific {@linkcode AbilityId}.
-     * @param expectedAbilityId - The `AbilityId` to check for
-     */
-    toHaveAbilityApplied(expectedAbilityId: AbilityId): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} has a specific amount of {@linkcode Stat.HP | HP}.
-     * @param expectedHp - The expected amount of {@linkcode Stat.HP | HP} to have
-     */
-    toHaveHp(expectedHp: number): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} has taken a specific amount of damage.
-     * @param expectedDamageTaken - The expected amount of damage taken
-     * @param roundDown - Whether to round down `expectedDamageTaken` with {@linkcode toDmgValue}; default `true`
-     */
-    toHaveTakenDamage(expectedDamageTaken: number, roundDown?: boolean): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} is currently fainted (as determined by {@linkcode Pokemon.isFainted}).
-     * @remarks
-     * When checking whether an enemy wild Pokemon is fainted, one must store a reference to it in a variable _before_ the fainting effect occurs.
-     * Otherwise, the Pokemon will be removed from the field and garbage collected.
-     */
-    toHaveFainted(): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} is at full HP.
-     */
-    toHaveFullHp(): void;
-    /**
-     * Check whether a {@linkcode Pokemon} has consumed the given amount of PP for one of its moves.
-     * @param moveId - The {@linkcode MoveId} corresponding to the {@linkcode PokemonMove} that should have consumed PP
-     * @param ppUsed - The numerical amount of PP that should have been consumed,
-     * or `all` to indicate the move should be _out_ of PP
-     * @remarks
-     * If the Pokemon's moveset has been set via {@linkcode Overrides.MOVESET_OVERRIDE}/{@linkcode Overrides.ENEMY_MOVESET_OVERRIDE}
-     * or does not contain exactly one copy of `moveId`, this will fail the test.
-     */
-    toHaveUsedPP(moveId: MoveId, ppUsed: number | "all"): void;
-
-    // #endregion Pokemon Matchers
-  }
+  interface Assertion<T> extends GenericMatchers<T>, GameManagerMatchers<T>, ArenaMatchers<T>, PokemonMatchers<T> {}
 }
+
+// #endregion Boilerplate
+
+// #region Generic Matchers
+interface GenericMatchers<T> {
+  /**
+   * Check whether an array contains EXACTLY the given items (in any order).
+   *
+   * Different from {@linkcode expect.arrayContaining} as the latter only checks for subset equality
+   * (as opposed to full equality).
+   *
+   * @param expected - The expected contents of the array, in any order
+   * @see {@linkcode expect.arrayContaining}
+   */
+  toEqualArrayUnsorted(expected: T extends (infer U)[] ? U[] : never): void;
+
+  /**
+   * Check whether a {@linkcode Map} contains the given key, disregarding its value.
+   * @param expectedKey - The key whose inclusion is being checked
+   * @privateRemarks
+   * While this functionality _could_ be simulated by writing
+   * `expect(x.get(y)).toBeDefined()` or
+   * `expect(x).toContain[y, expect.anything()]`,
+   * this is still preferred due to being more ergonomic and provides better error messsages.
+   */
+  toHaveKey(expectedKey: T extends Map<infer K, unknown> ? K : never): void;
+}
+// #endregion Generic Matchers
+
+// #region GameManager Matchers
+interface GameManagerMatchers<_T> {
+  /**
+   * Check if the {@linkcode GameManager} has shown the given message at least once in the current test case.
+   * @param expectedMessage - The expected message to be displayed
+   * @remarks
+   * Strings consumed by this function should _always_ be produced by a call to `i18n.t`
+   * to avoid hardcoding text into test files.
+   */
+  toHaveShownMessage(expectedMessage: string): void;
+
+  /**
+   * Check if the currently-running {@linkcode Phase} is of the given type.
+   * @param expectedPhase - The expected {@linkcode PhaseString | name of the phase}
+   */
+  toBeAtPhase(expectedPhase: PhaseString): void;
+}
+
+// #endregion GameManager Matchers
+
+// #region Arena Matchers
+interface ArenaMatchers<_T> {
+  /**
+   * Check whether the current {@linkcode WeatherType} is as expected.
+   * @param expectedWeatherType - The expected {@linkcode WeatherType}
+   */
+  toHaveWeather(expectedWeatherType: WeatherType): void;
+
+  /**
+   * Check whether the current {@linkcode TerrainType} is as expected.
+   * @param expectedTerrainType - The expected {@linkcode TerrainType}
+   */
+  toHaveTerrain(expectedTerrainType: TerrainType): void;
+
+  /**
+   * Check whether the current {@linkcode Arena} contains the given {@linkcode ArenaTag}.
+   * @param expectedTag - A partially-filled {@linkcode ArenaTag} containing the desired properties
+   */
+  toHaveArenaTag<A extends ArenaTagType>(expectedTag: toHaveArenaTagOptions<A>): void;
+  /**
+   * Check whether the current {@linkcode Arena} contains the given {@linkcode ArenaTag}.
+   * @param expectedType - The {@linkcode ArenaTagType} of the desired tag
+   * @param side - The {@linkcode ArenaTagSide | side(s) of the field} the tag should affect; default {@linkcode ArenaTagSide.BOTH}
+   */
+  toHaveArenaTag(expectedType: ArenaTagType, side?: ArenaTagSide): void;
+
+  /**
+   * Check whether the current {@linkcode Arena} contains the given {@linkcode PositionalTag}.
+   * @param expectedTag - A partially-filled `PositionalTag` containing the desired properties
+   */
+  toHavePositionalTag<P extends PositionalTagType>(expectedTag: toHavePositionalTagOptions<P>): void;
+  /**
+   * Check whether the current {@linkcode Arena} contains the given number of {@linkcode PositionalTag}s.
+   * @param expectedType - The {@linkcode PositionalTagType} of the desired tag
+   * @param count - The number of instances of {@linkcode expectedType} that should be active;
+   * defaults to `1` and must be within the range `[0, 4]`
+   */
+  toHavePositionalTag(expectedType: PositionalTagType, count?: number): void;
+}
+// #endregion Arena Matchers
+
+// #region Pokemon Matchers
+interface PokemonMatchers<_T> {
+  /**
+   * Check whether a {@linkcode Pokemon}'s current typing includes the given types.
+   * @param expectedTypes - The expected {@linkcode PokemonType}s to check against; must have length `>0`
+   * @param options - The {@linkcode toHaveTypesOptions | options} passed to the matcher
+   */
+  toHaveTypes(expectedTypes: PokemonType[], options?: toHaveTypesOptions): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} has used a move matching the given criteria.
+   * @param expectedMove - The {@linkcode MoveId} the Pokemon is expected to have used,
+   * or a partially filled {@linkcode TurnMove} containing the desired properties to check
+   * @param index - The index of the move history entry to check, in order from most recent to least recent; default `0`
+   * @see {@linkcode Pokemon.getLastXMoves}
+   */
+  toHaveUsedMove(expectedMove: MoveId | AtLeastOne<TurnMove>, index?: number): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon}'s effective stat is as expected
+   * (checked after all stat value modifications).
+   * @param stat - The {@linkcode EffectiveStat} to check
+   * @param expectedValue - The expected value of {@linkcode stat}
+   * @param options - The {@linkcode toHaveEffectiveStatOptions | options} passed to the matcher
+   * @remarks
+   * If you want to check the stat **before** modifiers are applied, use {@linkcode Pokemon.getStat} instead.
+   */
+  toHaveEffectiveStat(stat: EffectiveStat, expectedValue: number, options?: toHaveEffectiveStatOptions): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} has a specific {@linkcode StatusEffect | non-volatile status effect}.
+   * @param expectedStatusEffect - The {@linkcode StatusEffect} the Pokemon is expected to have,
+   * or a partially filled {@linkcode Status} containing the desired properties
+   */
+  toHaveStatusEffect(expectedStatusEffect: expectedStatusType): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} has a specific {@linkcode Stat} stage.
+   * @param stat - The {@linkcode BattleStat} to check
+   * @param expectedStage - The expected stat stage value of {@linkcode stat}
+   */
+  toHaveStatStage(stat: BattleStat, expectedStage: number): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} has the given {@linkcode BattlerTag}.
+   * @param expectedTag - A partially-filled {@linkcode BattlerTag} containing the desired properties
+   */
+  toHaveBattlerTag<B extends BattlerTagType>(expectedTag: toHaveBattlerTagOptions<B>): void;
+  /**
+   * Check whether a {@linkcode Pokemon} has the given {@linkcode BattlerTag}.
+   * @param expectedType - The expected {@linkcode BattlerTagType}
+   */
+  toHaveBattlerTag(expectedType: BattlerTagType): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} has applied a specific {@linkcode AbilityId}.
+   * @param expectedAbilityId - The `AbilityId` to check for
+   */
+  toHaveAbilityApplied(expectedAbilityId: AbilityId): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} has a specific amount of {@linkcode Stat.HP | HP}.
+   * @param expectedHp - The expected amount of {@linkcode Stat.HP | HP} to have
+   */
+  toHaveHp(expectedHp: number): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} has taken a specific amount of damage.
+   * @param expectedDamageTaken - The expected amount of damage taken
+   * @param roundDown - Whether to round down `expectedDamageTaken` with {@linkcode toDmgValue}; default `true`
+   */
+  toHaveTakenDamage(expectedDamageTaken: number, roundDown?: boolean): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} is currently fainted (as determined by {@linkcode Pokemon.isFainted}).
+   * @remarks
+   * When checking whether an enemy wild Pokemon is fainted, one must store a reference to it in a variable _before_ the fainting effect occurs.
+   * Otherwise, the Pokemon will be removed from the field and garbage collected.
+   */
+  toHaveFainted(): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} is at full HP.
+   */
+  toHaveFullHp(): void;
+
+  /**
+   * Check whether a {@linkcode Pokemon} has consumed the given amount of PP for one of its moves.
+   * @param moveId - The {@linkcode MoveId} corresponding to the {@linkcode PokemonMove} that should have consumed PP
+   * @param ppUsed - The numerical amount of PP that should have been consumed,
+   * or `all` to indicate the move should be _out_ of PP
+   * @remarks
+   * If the Pokemon's moveset has been set via {@linkcode Overrides.MOVESET_OVERRIDE}/{@linkcode Overrides.ENEMY_MOVESET_OVERRIDE}
+   * or does not contain exactly one copy of `moveId`, this will fail the test.
+   */
+  toHaveUsedPP(moveId: MoveId, ppUsed: number | "all"): void;
+}
+
+// #endregion Pokemon Matchers
diff --git a/test/test-utils/matchers/to-have-terrain.ts b/test/test-utils/matchers/to-have-terrain.ts
index f951abed0b3..9b6939168f0 100644
--- a/test/test-utils/matchers/to-have-terrain.ts
+++ b/test/test-utils/matchers/to-have-terrain.ts
@@ -8,8 +8,8 @@ import { isGameManagerInstance, receivedStr } from "#test/test-utils/test-utils"
 import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 
 /**
- * Matcher that checks if the {@linkcode TerrainType} is as expected
- * @param received - The object to check. Should be an instance of {@linkcode GameManager}.
+ * Matcher that checks if the current {@linkcode TerrainType} is as expected.
+ * @param received - The object to check. Should be the current {@linkcode GameManager}.
  * @param expectedTerrainType - The expected {@linkcode TerrainType}, or {@linkcode TerrainType.NONE} if no terrain should be active
  * @returns Whether the matcher passed
  */
diff --git a/test/test-utils/matchers/to-have-weather.ts b/test/test-utils/matchers/to-have-weather.ts
index ffb1e0aad97..7604cd5f890 100644
--- a/test/test-utils/matchers/to-have-weather.ts
+++ b/test/test-utils/matchers/to-have-weather.ts
@@ -8,8 +8,8 @@ import { toTitleCase } from "#utils/strings";
 import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 
 /**
- * Matcher that checks if the {@linkcode WeatherType} is as expected
- * @param received - The object to check. Expects an instance of {@linkcode GameManager}.
+ * Matcher that checks if the current {@linkcode WeatherType} is as expected.
+ * @param received - The object to check. Should be the current {@linkcode GameManager}
  * @param expectedWeatherType - The expected {@linkcode WeatherType}
  * @returns Whether the matcher passed
  */