isaacscript-common 21.4.0 → 21.5.0

package/dist/index.d.ts

@@ -1144,22 +1144,6 @@ export declare function characterCanTakeFreeDevilDeals(character: PlayerType): b
  */
 export declare function characterGetsBlackHeartFromEternalHeart(character: PlayerType): boolean;
 
-declare class CharacterHealthConversion extends Feature {
-    private characterHealthReplacementMap;
-    private prePickupCollisionHeart;
-    private postPEffectUpdateReordered;
-    /**
-     * Helper function to make a character that has the same health mechanic as Blue Baby (red heart
-     * containers --> soul hearts) or Dark Judas (red heart containers --> black hearts).
-     *
-     * Call this function once at the beginning of your mod to declare the health conversion type.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.CHARACTER_HEALTH_CONVERSION`.
-     */
-    registerCharacterHealthConversion(playerType: PlayerType, conversionHeartSubType: ConversionHeartSubType): void;
-}
-
 /**
  * Helper function to determine if the specified character starts with an active item.
  *
@@ -1168,32 +1152,6 @@ declare class CharacterHealthConversion extends Feature {
  */
 export declare function characterStartsWithActiveItem(character: PlayerType): boolean;
 
-/** Easily create custom characters that have base stats different from that of Isaac. */
-declare class CharacterStats extends Feature {
-    private charactersStatMap;
-    private evaluateCache;
-    /**
-     * Helper function to manage the stats for a vanilla or custom character. Call this function once
-     * at the beginning of your mod to declare the starting stats.
-     *
-     * You must provide this function with a map of CacheFlag to the default stat amount. For example,
-     * the default amount of damage is 3.5. To make a custom character start with 4.5 damage:
-     *
-     * ```ts
-     * const fooDefaultStats = new Map<CacheFlag, number>([
-     *   [CacheFlag.DAMAGE, 4.5],
-     * ])
-     * registerCharacterStats(PlayerTypeCustom.FOO, fooDefaultStats);
-     * ```
-     *
-     * Note that the format for the `CacheFlag.FIRE_DELAY` value should be in the tears stat format,
-     * not the `MaxFireDelay` format.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CHARACTER_STATS`.
-     */
-    registerCharacterStats(playerType: PlayerType, statMap: Map<CacheFlag, number> | ReadonlyMap<CacheFlag, number>): void;
-}
-
 /**
  * A collection of the four sprites necessary in order to render a charge bar.
  *
@@ -1345,21 +1303,6 @@ export declare type CollectibleIndex = string & {
     readonly __collectibleIndexBrand: symbol;
 };
 
-declare class CollectibleItemPoolType extends Feature {
-    private pickupIndexCreation;
-    private postPickupInitCollectible;
-    /**
-     * Helper function to get the item pool type that a given collectible came from. Since there is no
-     * native method in the API to get this, we listen in the `POST_PICKUP_INIT` callback for
-     * collectibles, use the `ItemPool.GetLastPool` method, and then assume that the collectible
-     * matches.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.COLLECTIBLE_ITEM_POOL_TYPE`.
-     */
-    getCollectibleItemPoolType(collectible: EntityPickup): ItemPoolType;
-}
-
 /** Helper function to check if two collectible sprites have the same sprite sheet loaded. */
 export declare function collectibleSpriteEquals(sprite1: Sprite, sprite2: Sprite): boolean;
 
@@ -1537,356 +1480,6 @@ export declare function countEntities(entityType?: EntityType, variant?: number,
  */
 export declare function countSetBits(n: int): int;
 
-/**
- * The base class for a custom callback. Individual custom callbacks (and validation callbacks) will
- * extend from this class.
- */
-declare abstract class CustomCallback<T extends ModCallbackCustom> extends Feature {
-    private subscriptions;
-    addSubscriber(callbackFunc: AddCallbackParametersCustom[T][0], ...optionalArgs: AllButFirst<AddCallbackParametersCustom[T]>): void;
-    /**
-     * If the submitted function does not match any of the existing subscriptions, this method will do
-     * nothing.
-     */
-    removeSubscriber(callback: AddCallbackParametersCustom[T][0]): void;
-    fire: (...fireArgs: FireArgs<T>) => ReturnType<AddCallbackParametersCustom[T][0]>;
-    /**
-     * This method needs to be overwritten for any callback that has optional filtration arguments.
-     * See "shouldFire.ts" for methods tailored to specific kinds of callbacks.
-     */
-    protected shouldFire: (fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>) => boolean;
-}
-
-declare class CustomGridEntities extends Feature {
-    private runInNFrames;
-    private preUseItemWeNeedToGoDeeper;
-    private postNewRoomReordered;
-    /**
-     * Helper function to spawn a custom grid entity. Custom grid entities are persistent in that they
-     * will reappear if the player leaves and re-enters the room. (It will be manually respawned in
-     * the `POST_NEW_ROOM` callback.)
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
-     *
-     * Custom grid entities are built on top of real grid entities. You can use any existing grid
-     * entity type as a base. For example, if you want to create a custom rock that would be breakable
-     * like a normal rock, then you should specify `GridEntityType.ROCK` as the base grid entity type.
-     *
-     * Once a custom grid entity is spawned, you can take advantage of the custom grid callbacks such
-     * as `POST_GRID_ENTITY_CUSTOM_UPDATE`. Note that the "normal" grid entities callbacks will not
-     * fire for custom entities. For example, if you had a custom grid entity based on
-     * `GridEntityType.ROCK`, and you also had a subscription to the `POST_GRID_ENTITY_UPDATE`
-     * callback, the callback would only fire for normal rocks and not the custom entity.
-     *
-     * Custom grid entities are an IsaacScript feature because the vanilla game does not support any
-     * custom grid entities.
-     *
-     * For example, this would be code to create a custom rock called a "Silver Rock" that produces a
-     * dime when destroyed:
-     *
-     * ```ts
-     * // This is local to the mod and can safely overlap with the values of `GridEntityType` (or
-     * // values chosen by other mods).
-     * const GridEntityTypeCustom = {
-     *   SILVER_ROCK: 0 as GridEntityType,
-     * } as const;
-     *
-     * // This is copied from "gfx/grid/grid_rock.anm2" with some tweaks to make it look special.
-     * const SILVER_ROCK_ANM2_PATH = "gfx/grid/grid_rock_silver.anm2";
-     *
-     * export function silverRockInit(mod: ModUpgraded): void {
-     *   mod.AddCallbackCustom(
-     *     ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN,
-     *     postGridEntityCustomBrokenSilverRock,
-     *     GridEntityTypeCustom.SILVER_ROCK,
-     *   );
-     * }
-     *
-     * function postGridEntityCustomBrokenSilverRock(gridEntity: GridEntity) {
-     *   spawnCoin(CoinSubType.DIME, gridEntity.Position);
-     * }
-     *
-     * export function spawnSilverRock(mod: ModUpgraded, gridIndex: int): GridEntity {
-     *   return mod.spawnCustomGridEntity(
-     *     GridEntityTypeCustom.SILVER_ROCK,
-     *     gridIndex,
-     *     undefined,
-     *     SILVER_ROCK_ANM2_PATH,
-     *     undefined,
-     *     GridEntityType.ROCK,
-     *   );
-     * }
-     * ```
-     *
-     * @param gridEntityTypeCustom An integer that identifies what kind of grid entity you are
-     *                             creating. It should correspond to a local enum value created in
-     *                             your mod. The integer can be any unique value and will not
-     *                             correspond to the actual grid entity type used. (This integer is
-     *                             used in the various custom grid entity callbacks.)
-     * @param gridIndexOrPosition The grid index or position in the room that you want to spawn the
-     *                            grid entity at. If a position is specified, the closest grid index
-     *                            will be used.
-     * @param gridCollisionClass Optional. The collision class that you want the custom grid entity to
-     *                           have. If not specified, the grid collision class from the base grid
-     *                           entity will be used.
-     * @param anm2Path Optional. The path to the ANM2 file to use for the sprite. If not specified,
-     *                 the normal sprite from the base grid entity will be used.
-     * @param defaultAnimation Optional. The name of the animation to play after the sprite is
-     *                         initialized and after the player re-enters a room with this grid entity
-     *                         in it. If not specified, the default animation in the anm2 will be
-     *                         used.
-     * @param baseGridEntityType Optional. The type of the grid entity to use as a "base" for this
-     *                           custom grid entity. Default is `GridEntityType.DECORATION`.
-     * @param baseGridEntityVariant Optional. The variant of the grid entity to use as a "base" for
-     *                              this custom grid entity. Default is 0.
-     */
-    spawnCustomGridEntity(gridEntityTypeCustom: GridEntityType, gridIndexOrPosition: int | Vector, gridCollisionClass?: GridCollisionClass, anm2Path?: string, defaultAnimation?: string, baseGridEntityType?: GridEntityType, baseGridEntityVariant?: number): GridEntity;
-    /**
-     * Helper function to remove a custom grid entity created by the `spawnCustomGrid` function.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
-     *
-     * @param gridIndexOrPositionOrGridEntity You can specify the custom grid entity to remove by
-     *                                providing the grid index, the room position, or the grid entity
-     *                                itself.
-     * @param updateRoom Optional. Whether or not to update the room after the grid entity is removed.
-     *                   Default is true. This is generally a good idea because if the room is not
-     *                   updated, you will be unable to spawn another grid entity on the same tile
-     *                   until a frame has passed. However, doing this is expensive, since it involves
-     *                   a call to `Isaac.GetRoomEntities`, so set it to false if you need to run this
-     *                   function multiple times.
-     * @returns The grid entity that was removed. Returns undefined if no grid entity was found at the
-     *          given location or if the given grid entity was not a custom grid entity.
-     */
-    removeCustomGridEntity(gridIndexOrPositionOrGridEntity: int | Vector | GridEntity, updateRoom?: boolean): GridEntity | undefined;
-    /**
-     * Helper function to get the custom grid entities in the current room. Returns an array of tuples
-     * containing the raw decoration grid entity and the associated entity data.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
-     */
-    getCustomGridEntities(): Array<[
-    gridEntity: GridEntity,
-    data: GridEntityCustomData
-    ]>;
-    /**
-     * Helper function to get the custom `GridEntityType` from a `GridEntity` or grid index. Returns
-     * undefined if the provided `GridEntity` is not a custom grid entity, or if there was not a grid
-     * entity on the provided grid index.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
-     */
-    getCustomGridEntityType(gridEntityOrGridIndex: GridEntity | int): GridEntityType | undefined;
-    /**
-     * Helper function to check if a `GridEntity` is a custom grid entity or if a grid index has a
-     * custom grid entity.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
-     */
-    isCustomGridEntity(gridEntityOrGridIndex: GridEntity | int): boolean;
-}
-
-declare class CustomHotkeys extends Feature {
-    /**
-     * The keys are the keyboard keys that trigger the hotkey. The values are the functions that
-     * contain the arbitrary code to run.
-     */
-    private staticHotkeyFunctionMap;
-    /**
-     * The keys are the functions that determine what the hotkey key is. The values are the functions
-     * that contain the arbitrary code to run.
-     */
-    private dynamicHotkeyFunctionMap;
-    private keyPressedMap;
-    private postRender;
-    private checkIfTriggered;
-    /**
-     * Helper function to run arbitrary code when you press and release a specific keyboard key.
-     *
-     * This can be used to easily set up custom hotkeys to facilitate custom game features or to
-     * assist in debugging.
-     *
-     * Inputs are checked for in the `POST_RENDER` callback.
-     *
-     * This is different from the `setHotkey` function in that the keyboard activation key is not
-     * hardcoded and is instead the return value of a provided function. This is useful for situations
-     * where the key can change (like if end-users can specify a custom hotkey using Mod Config Menu).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_HOTKEYS`.
-     *
-     * @param getKeyFunc The function that returns the key that will trigger the hotkey.
-     * @param triggerFunc A function containing the arbitrary code that you want to execute when the
-     *                    hotkey is triggered.
-     */
-    setConditionalHotkey(getKeyFunc: () => Keyboard | undefined, triggerFunc: () => void): void;
-    /**
-     * Helper function to run arbitrary code when you press and release a specific keyboard key.
-     *
-     * This can be used to easily set up custom hotkeys to facilitate custom game features or to
-     * assist in debugging.
-     *
-     * Inputs are checked for in the `POST_RENDER` callback.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_HOTKEYS`.
-     *
-     * @param keyboard The key that you want to trigger the hotkey.
-     * @param triggerFunc A function containing the arbitrary code that you want to execute when the
-     *                    hotkey is triggered.
-     */
-    setHotkey(keyboard: Keyboard, triggerFunc: () => void): void;
-    /**
-     * Helper function to remove a hotkey created with the `setConditionalHotkey` function.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_HOTKEYS`.
-     *
-     * @param getKeyFunc Equal to the `getKeyFunc` that you passed when initially registering the
-     *                   hotkey.
-     */
-    unsetConditionalHotkey(getKeyFunc: () => Keyboard | undefined): void;
-    /**
-     * Helper function to remove a hotkey created with the `setHotkey` function.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_HOTKEYS`.
-     *
-     * @param keyboard Equal to the keyboard value that you passed when initially registering the
-     *                 hotkey.
-     */
-    unsetHotkey(keyboard: Keyboard): void;
-}
-
-declare class CustomItemPools extends Feature {
-    private customItemPoolMap;
-    private postGameStartedReordered;
-    /**
-     * Helper function to register a custom item pool. Use this function once when your mod first
-     * loads to declare the items that you want to be in the item pools. Then, in the middle of a run,
-     * you can use `getCustomItemPoolCollectible`.
-     *
-     * For example:
-     *
-     * ```ts
-     * const ItemPoolTypeCustom = {
-     *   FOO = 0 as ItemPoolType,
-     * } as const;
-     *
-     * const FOO_ITEM_POOL = [
-     *   [CollectibleType.SAD_ONION, 1],
-     *   [CollectibleType.INNER_EYE, 0.5],
-     * ];
-     *
-     * registerCustomItemPool(ItemPoolTypeCustom.FOO, FOO_ITEM_POOL);
-     * ```
-     *
-     * Note that custom item pools do not currently support partial weight decrementation on sight.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_ITEM_POOLS`.
-     *
-     * @param itemPoolTypeCustom An integer that identifies what kind of item pool you are creating.
-     *                           It should correspond to a local `ItemPoolTypeCustom` enum in your
-     *                           mod. The integer can be any unique value and can safely overlap with
-     *                           the vanilla item pool type values (or values chosen by other mods).
-     * @param collectibles An array of weighted collectible tuples that represent the item pool that
-     *                     you are creating. The first element in he tuple is the `CollectibleType`,
-     *                     and the second element in the tuple is the float that represents the weight
-     *                     of the collectible.
-     */
-    registerCustomItemPool(itemPoolTypeCustom: ItemPoolType, collectibles: WeightedArray<CollectibleType>): void;
-    /**
-     * Helper function to get a new collectible from a custom item pool created with the
-     * `registerCustomItemPool` function. This function has the same format as the
-     * `ItemPool.GetCollectible` method.
-     *
-     * By default, a collectible will not be removed from the pool once it is selected, unless the
-     * `decrease` argument is set to true (similar to how a vanilla item pool works).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_ITEM_POOLS`.
-     *
-     * @param itemPoolTypeCustom An integer representing the custom item pool to use.
-     * @param decrease Optional. Whether or not to remove the selected collectible from the item pool.
-     *                 Default is true.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
-     * @param defaultItem Optional. The collectible to return if the item pool is depleted. Default is
-     *                    `CollectibleType.NULL`.
-     */
-    getCustomItemPoolCollectible(itemPoolTypeCustom: ItemPoolType, decrease?: boolean, seedOrRNG?: Seed | RNG, defaultItem?: CollectibleType): CollectibleType;
-}
-
-declare class CustomPickups extends Feature {
-    /** Indexed by entity ID. */
-    private customPickupFunctionsMap;
-    private prePickupCollision;
-    private postEffectRenderPickupEffect;
-    /**
-     * Helper function to register a custom pickup with the IsaacScript standard library. Use this
-     * feature for custom pickups that are intended to be picked up by the player, like bombs and
-     * keys.
-     *
-     * When IsaacScript detects that a player should be collecting the custom pickup, then the pickup
-     * will be immediately removed, and an effect showing the pickup's respective `Collect` animation
-     * will be spawned. (This emulates how a normal vanilla pickup would work.) After that, the
-     * provided `collectFunc` will be fired. In this function, you will probably want to play a sound
-     * corresponding to what kind of pickup it is (e.g. `SoundEffect.KEY_PICKUP_GAUNTLET`), as well as
-     * do things like adding something to the player's inventory.
-     *
-     * Note that when you specify your custom pickup in the "entities2.xml" file, it should have a
-     * type of "5" and be associated with an anm2 file that has a "Collect" animation.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_PICKUPS`.
-     *
-     * @param pickupVariantCustom The variant for the corresponding custom pickup.
-     * @param subType The sub-type for the corresponding custom pickup.
-     * @param collectFunc The function to run when the player collects this pickup.
-     * @param collisionFunc Optional. The function to run when a player collides with the pickup.
-     *                      Default is a function that always returns true, meaning that the player
-     *                      will always immediately collect the pickup when they collide with it.
-     *                      Specify this function if your pickup should only be able to be collected
-     *                      under certain conditions.
-     */
-    registerCustomPickup(pickupVariantCustom: PickupVariant, subType: int, collectFunc: (this: void, player: EntityPlayer) => void, collisionFunc?: (this: void, player: EntityPlayer) => boolean): void;
-}
-
-declare class CustomRevive extends Feature {
-    v: {
-        run: {
-            state: CustomReviveState;
-            revivalType: number | null;
-            dyingPlayerIndex: PlayerIndex | null;
-        };
-    };
-    private preCustomRevive;
-    private postCustomRevive;
-    private runInNFrames;
-    constructor(preCustomRevive: PreCustomRevive, postCustomRevive: PostCustomRevive, runInNFrames: RunInNFrames);
-    private postRender;
-    private postNewRoomReordered;
-    private postPEffectUpdateReordered;
-    private checkWaitingForItemAnimation;
-    private postPlayerFatalDamage;
-    private preBerserkDeath;
-    /**
-     * The player is about to die, which will immediately delete the save data for the run. To prevent
-     * this from happening, we grant the 1-Up item.
-     */
-    private playerIsAboutToDie;
-    private logStateChanged;
-}
-
-declare enum CustomReviveState {
-    DISABLED = 0,
-    /**
-     * We can't immediately jump to waiting for an item animation because it is possible for a player
-     * to be holding an item above their head as they are dying (e.g. with Razor Blade).
-     */
-    WAITING_FOR_ROOM_TRANSITION = 1,
-    WAITING_FOR_ITEM_ANIMATION = 2
-}
-
 /**
  * An object that represents a possible boss for a custom stage. This can be for a vanilla boss or a
  * custom boss.
@@ -1971,56 +1564,6 @@ export declare interface CustomStageRoomMetadata {
     weight: number;
 }
 
-declare class CustomStages extends Feature {
-    /** Indexed by custom stage name. */
-    private customStagesMap;
-    /** Indexed by room variant. */
-    private customStageCachedRoomData;
-    private customGridEntities;
-    private customTrapdoors;
-    private disableAllSound;
-    private gameReorderedCallbacks;
-    private pause;
-    private runInNFrames;
-    private initCustomStageMetadata;
-    private initRoomTypeMap;
-    private initCustomTrapdoorDestination;
-    private goToCustomStage;
-    private postRender;
-    private postCurseEval;
-    private getShaderParams;
-    private postGridEntityBrokenRockAlt;
-    private postGridEntityInit;
-    private postNewRoomReordered;
-    /** Pick a custom room for each vanilla room. */
-    private setStageRoomsData;
-    /**
-     * Helper function to warp to a custom stage/level.
-     *
-     * Custom stages/levels must first be defined in the "tsconfig.json" file. See the documentation
-     * for more details: https://isaacscript.github.io/main/custom-stages/
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_STAGES`.
-     *
-     * @param name The name of the custom stage, corresponding to what is in the "tsconfig.json" file.
-     * @param firstFloor Optional. Whether to go to the first floor or the second floor. For example,
-     *                   if you have a custom stage emulating Caves, then the first floor would be
-     *                   Caves 1, and the second floor would be Caves 2. Default is true.
-     * @param streakText Optional. Whether to show the streak text at the top of the screen that
-     *                   announces the name of the level. Default is true.
-     * @param verbose Optional. Whether to log additional information about the rooms that are chosen.
-     *                Default is false.
-     */
-    setCustomStage(name: string, firstFloor?: boolean, streakText?: boolean, verbose?: boolean): void;
-    /**
-     * Helper function to disable the custom stage. This is typically called before taking the player
-     * to a vanilla floor.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_STAGES`.
-     */
-    disableCustomStage(): void;
-}
-
 /**
  * A description of a custom stage shadow. (In this context, "shadows" are the outlines from things
  * on the roof. For example, in Basement, a shadow of a sideways V is used, among others.)
@@ -2472,454 +2015,6 @@ export declare interface CustomStageTSConfig {
     };
 }
 
-declare class CustomTrapdoors extends Feature {
-    /** Indexed by custom trapdoor ID. */
-    private destinationFuncMap;
-    /**
-     * In order to represent a black sprite, we just use the first frame of the boss versus screen
-     * animation. However, we must lazy load the sprite in order to prevent issues with mods that
-     * replace the vanilla files. (For some reason, loading the sprites will cause the overwrite to no
-     * longer apply on the second and subsequent runs.)
-     */
-    private blackSprite;
-    private customGridEntities;
-    private disableInputs;
-    private ponyDetection;
-    private roomClearFrame;
-    private runInNFrames;
-    private runNextRoom;
-    private stageHistory;
-    private postRender;
-    private checkAllPlayersJumpComplete;
-    private checkPixelationToBlackComplete;
-    private goToCustomTrapdoorDestination;
-    private getDestinationFunc;
-    private checkSecondPixelationHalfWay;
-    private checkAllPlayersLayingDownComplete;
-    private drawBlackSprite;
-    private postGridEntityCustomUpdateTrapdoor;
-    private checkCustomTrapdoorOpenClose;
-    private shouldTrapdoorOpen;
-    private isPlayerCloseAfterBoss;
-    private checkCustomTrapdoorPlayerTouched;
-    private playerTouchedCustomTrapdoor;
-    private startDelayedJump;
-    private adjustPlayerPositionToTrapdoor;
-    private postPEffectUpdateReordered;
-    private checkJumpComplete;
-    private shouldTrapdoorSpawnOpen;
-    private logStateChanged;
-    /**
-     * Helper function to specify where your custom trapdoor should take the player. Call this once at
-     * the beginning of your mod for each kind of custom trapdoor that you want to have. The provided
-     * `destinationFunc` will be executed when the player jumps into the trapdoor and the pixelation
-     * effect fades to black.
-     *
-     * Registration is needed so that custom trapdoors can be serializable when the player saves and
-     * quits.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_TRAPDOORS`.
-     *
-     * @param destinationName The integer that identifies the type of custom trapdoor. It should
-     *                        correspond to a local `CustomTrapdoorType` enum in your mod. The integer
-     *                        can be any unique value and can safely overlap with values chosen by
-     *                        other mods.
-     * @param destinationFunc A function that takes the player to the destination that you want.
-     *                        Inside this function, use the `setStage` or `setCustomStage` helper
-     *                        functions, or do something completely custom.
-     */
-    registerCustomTrapdoorDestination(destinationName: string, destinationFunc: (destinationName: string | undefined, destinationStage: LevelStage, destinationStageType: StageType) => void): void;
-    /**
-     * Helper function to spawn a trapdoor grid entity that will take a player to a vanilla stage or
-     * custom location.
-     *
-     * - If you want to create a custom trapdoor that goes to a vanilla stage, pass `undefined` for
-     *   the `destinationName` parameter.
-     * - If you want to create a custom trapdoor that takes the player to a custom location, you must
-     *   have registered the corresponding `destinationName` at the beginning of your mod with the
-     *   `registerCustomTrapdoorDestination` function. (This is necessary so that custom trapdoors can
-     *   be serializable when the player saves and quits.)
-     *
-     * Under the hood, the custom trapdoor is represented by a decoration grid entity and is manually
-     * respawned every time the player re-enters the room.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_TRAPDOORS`.
-     *
-     * @param gridIndexOrPosition The location in the room to spawn the trapdoor.
-     * @param destinationName Optional. A string representing the name of the of destination that the
-     *                        custom trapdoor will take the player to. Default is undefined, which
-     *                        will take the player to a vanilla stage.
-     * @param destinationStage Optional. The first argument that will be passed to the
-     *                         `destinationFunc` corresponding to this custom trapdoor. This is
-     *                         essentially metadata for the custom trapdoor. Leave this undefined if
-     *                         your corresponding custom trapdoor function does not care what the
-     *                         destination stage should be. Default is the "normal" next vanilla
-     *                         stage.
-     * @param destinationStageType Optional. The second argument that will be passed to the
-     *                             `destinationFunc` corresponding to this custom trapdoor. This is
-     *                             essentially metadata for the custom trapdoor. Leave this undefined
-     *                             if your corresponding custom trapdoor function does not care what
-     *                             the destination stage type should be. Default is the "normal" next
-     *                             vanilla stage type.
-     * @param anm2Path Optional. The path to the anm2 file to use. By default, the vanilla trapdoor
-     *                 anm2 of "gfx/grid/door_11_trapdoor.anm2" will be used. The specified anm2 file
-     *                 must have animations called "Opened", "Closed", and "Open Animation".
-     * @param spawnOpen Optional. Whether or not to spawn the trapdoor in an open state. By default,
-     *                  behavior will be used that emulates a vanilla trapdoor.
-     */
-    spawnCustomTrapdoor(gridIndexOrPosition: int | Vector, destinationName?: string, destinationStage?: LevelStage, destinationStageType?: StageType, anm2Path?: string, spawnOpen?: boolean): GridEntity;
-}
-
-declare class DebugDisplay extends Feature {
-    private mod;
-    private player;
-    private tear;
-    private familiar;
-    private bomb;
-    private pickup;
-    private slot;
-    private laser;
-    private knife;
-    private projectile;
-    private effect;
-    private npc;
-    private rock;
-    private pit;
-    private spikes;
-    private tnt;
-    private poop;
-    private door;
-    private pressurePlate;
-    /**
-     * If the "togglePlayerDisplay" function is called, text will be drawn on the screen next to each
-     * player. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setPlayerDisplay(textCallback: (player: EntityPlayer) => string): void;
-    /**
-     * If the "toggleTearDisplay" function is called, text will be drawn on the screen next to each
-     * tear. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setTearDisplay(textCallback: (tear: EntityTear) => string): void;
-    /**
-     * If the "toggleFamiliarDisplay" function is called, text will be drawn on the screen next to
-     * each familiar. Use this function to specify a callback function that returns the string that
-     * should be drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setFamiliarDisplay(textCallback: (familiar: EntityFamiliar) => string): void;
-    /**
-     * If the "toggleBombDisplay" function is called, text will be drawn on the screen next to each
-     * bomb. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setBombDisplay(textCallback: (bomb: EntityBomb) => string): void;
-    /**
-     * If the "togglePickupDisplay" function is called, text will be drawn on the screen next to each
-     * pickup. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setPickupDisplay(textCallback: (pickup: EntityPickup) => string): void;
-    /**
-     * If the "toggleSlotDisplay" function is called, text will be drawn on the screen next to each
-     * slot. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setSlotDisplay(textCallback: (slot: Entity) => string): void;
-    /**
-     * If the "toggleLaserDisplay" function is called, text will be drawn on the screen next to each
-     * laser. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setLaserDisplay(textCallback: (laser: EntityLaser) => string): void;
-    /**
-     * If the "toggleKnifeDisplay" function is called, text will be drawn on the screen next to each
-     * knife. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setKnifeDisplay(textCallback: (knife: EntityKnife) => string): void;
-    /**
-     * If the "toggleProjectileDisplay" function is called, text will be drawn on the screen next to
-     * each projectile. Use this function to specify a callback function that returns the string that
-     * should be drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setProjectileDisplay(textCallback: (projectile: EntityProjectile) => string): void;
-    /**
-     * If the "extra console commands" feature is specified, the "effectDisplay" console command will
-     * draw text on the screen next to each effect. Use this function to specify a callback function
-     * that returns the string that should be drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setEffectDisplay(textCallback: (effect: EntityEffect) => string): void;
-    /**
-     * If the "toggleNPCDisplay" function is called, text will be drawn on the screen next to each
-     * NPC. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setNPCDisplay(textCallback: (npc: EntityNPC) => string): void;
-    /**
-     * If the "toggleRockDisplay" function is called, text will be drawn on the screen next to each
-     * rock. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setRockDisplay(textCallback: (rock: GridEntityRock) => string): void;
-    /**
-     * If the "togglePitDisplay" function is called, text will be drawn on the screen next to each
-     * pit. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setPitDisplay(textCallback: (pit: GridEntityPit) => string): void;
-    /**
-     * If the "toggleSpikesDisplay" function is called, text will be drawn on the screen next to each
-     * spikes. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setSpikesDisplay(textCallback: (spikes: GridEntitySpikes) => string): void;
-    /**
-     * If the "toggleTNTDisplay" function is called, text will be drawn on the screen next to each
-     * TNT. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setTNTDisplay(textCallback: (tnt: GridEntityTNT) => string): void;
-    /**
-     * If the "togglePoopDisplay" function is called, text will be drawn on the screen next to each
-     * poop. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setPoopDisplay(textCallback: (poop: GridEntityPoop) => string): void;
-    /**
-     * If the "toggleDoorDisplay" function is called, text will be drawn on the screen next to each
-     * door. Use this function to specify a callback function that returns the string that should be
-     * drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setDoorDisplay(textCallback: (door: GridEntityDoor) => string): void;
-    /**
-     * If the "togglePressurePlateDisplay" function is called, text will be drawn on the screen next
-     * to each pressure plate. Use this function to specify a callback function that returns the
-     * string that should be drawn.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     */
-    setPressurePlateDisplay(textCallback: (pressurePlate: GridEntityPressurePlate) => string): void;
-    private toggleFeature;
-    /**
-     * Toggles the debug display for players, which will draw text on the screen next to each player.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    togglePlayerDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for tears, which will draw text on the screen next to each tear.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`. *
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleTearDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for familiars, which will draw text on the screen next to each
-     * familiar.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleFamiliarDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for bombs, which will draw text on the screen next to each bomb.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleBombDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for pickups, which will draw text on the screen next to each pickup.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    togglePickupDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for slots, which will draw text on the screen next to each slot.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleSlotDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for lasers, which will draw text on the screen next to each laser.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleLaserDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for knives, which will draw text on the screen next to each knife.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleKnifeDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for projectiles, which will draw text on the screen next to each
-     * projectile.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleProjectileDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for effects, which will draw text on the screen next to each effect.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleEffectDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for NPCs, which will draw text on the screen next to each NPC.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleNPCDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for rocks, which will draw text on the screen next to each rock.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleRockDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for pits, which will draw text on the screen next to each pit.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    togglePitDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for spikes, which will draw text on the screen next to each spike.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleSpikesDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for TNT, which will draw text on the screen next to each TNT.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleTNTDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for poops, which will draw text on the screen next to each poop.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    togglePoopDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for doors, which will draw text on the screen next to each door.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    toggleDoorDisplay(force?: boolean): void;
-    /**
-     * Toggles the debug display for pressure plates, which will draw text on the screen next to each
-     * pressure plate.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEBUG_DISPLAY`.
-     *
-     * @param force Optional. A boolean that represents the value to force the display to. For
-     *              example, you can specify true to always make the display turn on, regardless of
-     *              whether or not it is already on.
-     */
-    togglePressurePlateDisplay(force?: boolean): void;
-}
-
 /**
  * `deepCopy` is a semi-generic deep cloner. It will recursively copy all of the values so that none
  * of the nested references remain.
@@ -3123,45 +2218,6 @@ export declare function defaultMapSetPlayer<V>(map: Map<PlayerIndex, V>, player:
  */
 export declare function deleteSetsFromSet<T>(mainSet: Set<T>, ...setsToRemove: Array<Set<T> | ReadonlySet<T>>): void;
 
-declare class DeployJSONRoom extends Feature {
-    private preventGridEntityRespawn;
-    private spawnCollectible;
-    private spawnAllEntities;
-    private spawnNormalEntityForJSONRoom;
-    /**
-     * Helper function to deconstruct a vanilla room and set up a custom room in its place.
-     * Specifically, this will clear the current room of all entities and grid entities, and then
-     * spawn all of the entries and grid entities in the provided JSON room.
-     *
-     * A JSON room is simply an XML file converted to JSON. You can create JSON rooms by using the
-     * Basement Renovator room editor to create an XML file, and then convert it to JSON using the
-     * `convert-xml-to-json` tool (e.g. `npx convert-xml-to-json my-rooms.xml`).
-     *
-     * This function is meant to be used in the `POST_NEW_ROOM` callback.
-     *
-     * For example:
-     *
-     * ```ts
-     *
-     * import customRooms from "./customRooms.json";
-     *
-     * export function postNewRoom(): void {
-     *   const firstJSONRoom = customRooms.rooms.room[0];
-     *   deployJSONRoom(firstJSONRoom);
-     * }
-     * ```
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DEPLOY_JSON_ROOM`.
-     *
-     * @param jsonRoom The JSON room to deploy.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
-     * @param verbose Optional. If specified, will write entries to the "log.txt" file that describe
-     *                what the function is doing. Default is false.
-     */
-    deployJSONRoom(jsonRoom: JSONRoom | Readonly<JSONRoom>, seedOrRNG?: Seed | RNG, verbose?: boolean): void;
-}
-
 /**
  * Helper function to remove a collectible or trinket that is currently queued to go into a player's
  * inventory (i.e. the item is being held over their head).
@@ -3222,130 +2278,8 @@ export declare function directionToShootAction(direction: Direction): ButtonActi
 
 export declare function directionToVector(direction: Direction): Readonly<Vector>;
 
-declare class DisableAllSound extends Feature {
-    private musicWasEnabled;
-    private postRender;
-    /**
-     * Helper function to stop muting all sound effects and music.
-     *
-     * Use this function to set things back to normal after having used `disableAllSounds`.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DISABLE_ALL_SOUND`.
-     *
-     * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
-     *            that multiple mod features can work in tandem.
-     */
-    enableAllSound(key: string): void;
-    /**
-     * Helper function to disable all sound effects and music (by constantly musting them).
-     *
-     * Use the `enableAllSounds` helper function to set things back to normal.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DISABLE_ALL_SOUND`.
-     *
-     * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
-     *            that multiple mod features can work in tandem.
-     */
-    disableAllSound(key: string): void;
-}
-
-declare class DisableInputs extends Feature {
-    private isActionPressed;
-    private isActionTriggered;
-    private getActionValue;
-    private getReturnValue;
-    /**
-     * Helper function to enable all inputs. Use this function to set things back to normal after
-     * having used one of the other helper functions to disable inputs.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DISABLE_INPUTS`.
-     *
-     * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
-     *            that multiple mod features can work in tandem.
-     */
-    enableAllInputs(key: string): void;
-    /**
-     * Helper function to disable specific inputs, like opening the console.
-     *
-     * This function is variadic, meaning that you can pass as many inputs as you want to disable. (To
-     * disable all inputs, see the `disableAllInputs` function.
-     *
-     * Use the `enableAllInputs` helper function to set things back to normal.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DISABLE_INPUTS`.
-     *
-     * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
-     *            that multiple mod features can work in tandem.
-     * @param buttonActions An array of the actions to action.
-     */
-    disableInputs(key: string, ...buttonActions: ButtonAction[]): void;
-    /**
-     * Helper function to disable all inputs. This is useful because `EntityPlayer.ControlsEnabled`
-     * can be changed by the game under certain conditions.
-     *
-     * Use the `enableAllInputs` helper function to set things back to normal.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DISABLE_INPUTS`.
-     *
-     * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
-     *            that multiple mod features can work in tandem.
-     */
-    disableAllInputs(key: string): void;
-    /**
-     * Helper function to enable all inputs besides the ones provided. This is useful because
-     * `EntityPlayer.ControlsEnabled` can be changed by the game under certain conditions.
-     *
-     * Use the `enableAllInputs` helper function to set things back to normal.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DISABLE_INPUTS`.
-     *
-     * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
-     *            that multiple mod features can work in tandem.
-     * @param blacklist A set of ButtonActions to disallow.
-     */
-    enableAllInputsExceptFor(key: string, blacklist: Set<ButtonAction> | ReadonlySet<ButtonAction>): void;
-    /**
-     * Helper function to disable all inputs besides the ones provided. This is useful because
-     * `EntityPlayer.ControlsEnabled` can be changed by the game under certain conditions.
-     *
-     * Use the `enableAllInputs` helper function to set things back to normal.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DISABLE_INPUTS`.
-     *
-     * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
-     *            that multiple mod features can work in tandem.
-     * @param whitelist A set of ButtonActions to allow.
-     */
-    disableAllInputsExceptFor(key: string, whitelist: Set<ButtonAction> | ReadonlySet<ButtonAction>): void;
-    /**
-     * Helper function to disable only the inputs used for moving the character (or moving the cursor
-     * in the UI). This is useful because `EntityPlayer.ControlsEnabled` can be changed by the game
-     * under certain conditions.
-     *
-     * Use the `enableAllInputs` helper function to set things back to normal.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DISABLE_INPUTS`.
-     *
-     * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
-     *            that multiple mod features can work in tandem.
-     */
-    disableMovementInputs(key: string): void;
-    /**
-     * Helper function to disable only the inputs used for shooting tears. This is useful because
-     * `EntityPlayer.ControlsEnabled` can be changed by the game under certain conditions.
-     *
-     * Use the `enableAllInputs` helper function to set things back to normal.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.DISABLE_INPUTS`.
-     *
-     * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
-     *            that multiple mod features can work in tandem.
-     */
-    disableShootingInputs(key: string): void;
-}
-
-/** This is also the distance that a player spawns from the door that they enter a room from. */
-export declare const DISTANCE_OF_GRID_TILE = 40;
+/** This is also the distance that a player spawns from the door that they enter a room from. */
+export declare const DISTANCE_OF_GRID_TILE = 40;
 
 /**
  * Helper function to check if one or more matching entities exist in the current room. It uses the
@@ -3691,21 +2625,6 @@ export declare function eRange(start: int, end?: int, increment?: number): int[]
 
 declare type ErrorIsaacAPIClassIsNotSerializable = "Error: Isaac API classes (such as e.g. `Entity` or `RoomConfig`) are not serializable. For more information, see: https://isaacscript.github.io/main/gotchas#isaac-api-classes-are-not-serializable";
 
-declare class EsauJrDetection extends Feature {
-    v: {
-        run: {
-            usedEsauJrFrame: number | null;
-            usedEsauJrControllerIndex: ControllerIndex | null;
-            usedEsauJrAtLeastOnce: boolean;
-        };
-    };
-    private postEsauJr;
-    private postFirstEsauJr;
-    constructor(postEsauJr: PostEsauJr, postFirstEsauJr: PostFirstEsauJr);
-    private postUpdate;
-    private useItemEsauJr;
-}
-
 /**
  * These are a collection of functions for non-TypeScript users so that they can access some of
  * useful methods offered on the `Array` class in the JavaScript standard library.
@@ -3723,110 +2642,12 @@ declare class EsauJrDetection extends Feature {
  */
 export declare function every<T>(array: T[], func: (value: T, index: number, array: T[]) => boolean): boolean;
 
-declare class ExtraConsoleCommands extends Feature {
-    private commandFunctionMap;
-    private postUpdate;
-    private evaluateCacheDamage;
-    private evaluateCacheFireDelay;
-    private evaluateCacheSpeed;
-    private evaluateCacheFlying;
-    private postCurseEval;
-    private executeCmd;
-    private postFireTear;
-    private entityTakeDmgPlayer;
-    /**
-     * Helper function to add a custom console command.
-     *
-     * The standard library comes with many existing console commands that are useful for debugging,
-     * but you can also add your own commands that are useful for your particular mod. It's easier to
-     * add commands to the existing command system than to add your own logic manually to the
-     * `EXECUTE_CMD` callback.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.EXTRA_CONSOLE_COMMANDS`.
-     */
-    addConsoleCommand(commandName: string, commandFunction: (params: string) => void): void;
-    /**
-     * Helper function to remove a custom console command.
-     *
-     * The standard library comes with many existing console commands that are useful for debugging.
-     * If you want to disable one of them, use this function.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.EXTRA_CONSOLE_COMMANDS`.
-     */
-    removeConsoleCommand(commandName: string): void;
-}
-
 /**
  * A function that creates the default value for your `DefaultMap`. For example, if it was a
  * `DefaultMap` containing maps, the factory function would be: `() => new Map()`
  */
 export declare type FactoryFunction<V, Args extends unknown[]> = (...args: Args) => V;
 
-declare class FadeInRemover extends Feature {
-    private enabled;
-    private postGameStarted;
-    /**
-     * Removes the fade-in that occurs at the beginning of a run. If this behavior is desired, call
-     * this function once at the beginning of your mod.
-     *
-     * This is useful for debugging, when you are resetting the game often.
-     *
-     * You can restore the vanilla behavior with the `restoreFadeIn` function.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.FADE_IN_REMOVER`.
-     */
-    removeFadeIn(): void;
-    /**
-     * Disables the fade-in remover. Only useful if you have previously called the `removeFadeIn`
-     * function.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.FADE_IN_REMOVER`.
-     */
-    restoreFadeIn(): void;
-}
-
-declare class FastReset extends Feature {
-    private enabled;
-    private postRender;
-    /**
-     * Enables the fast-reset feature, which allows you to restart the game instantaneously. If this
-     * behavior is desired, call this function once at the beginning of your mod.
-     *
-     * This is useful for debugging, when you are resetting the game often.
-     *
-     * You can disable the fast-reset feature with the `disableFastReset` function.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.FAST_RESET`.
-     */
-    enableFastReset(): void;
-    /**
-     * Disables the fast-reset feature. Only useful if you have previously called the
-     * `enableFastReset` function.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.FAST_RESET`.
-     */
-    disableFastReset(): void;
-}
-
-/**
- * The IsaacScript standard library contains many optional features, such as the ability to create
- * custom pickups. All features are optional and are only initialized when needed. This class
- * contains elements to facilitate that.
- *
- * Additionally, all custom callbacks extend from this class.
- */
-declare abstract class Feature {
-    /**
-     * All features should only be instantiated once and are passed around to other features using
-     * dependency injection. We provide a run-time check in order to prevent the bug of any feature
-     * accidentally being instantiated twice.
-     */
-    private static constructedClassNames;
-    constructor();
-}
-
 export declare function fillLevelWithRedRooms(): void;
 
 /**
@@ -3859,8 +2680,6 @@ export declare function find<T>(array: T[], func: (value: T, index: number, arra
  */
 export declare function findFreePosition(startingPosition: Vector, avoidActiveEntities?: boolean, minimumDistance?: float): Vector;
 
-declare type FireArgs<T extends ModCallbackCustom> = Parameters<AddCallbackParametersCustom[T][0]>;
-
 /**
  * Helper function to make an NPC fire one or more projectiles. Returns the fired projectile(s).
  *
@@ -3927,30 +2746,6 @@ export declare const FIRST_STAGE = LevelStage.BASEMENT_1;
 /** Equal to `TrinketType.SWALLOWED_PENNY`. */
 export declare const FIRST_TRINKET_TYPE = TrinketType.SWALLOWED_PENNY;
 
-declare class FlipDetection extends Feature {
-    v: {
-        run: {
-            /** We don't consider the case of a multiplayer game with more than one Tainted Lazarus. */
-            usedFlipAtLeastOnce: boolean;
-        };
-    };
-    private postFlip;
-    private postFirstFlip;
-    constructor(postFlip: PostFlip, postFirstFlip: PostFirstFlip);
-    private useItemFlip;
-}
-
-declare class FlyingDetection extends Feature {
-    private moddedElementSets;
-    /**
-     * Helper function to see if the player currently has flying from a temporary effect such as
-     * Hanged Man, Bat Wing, and so on.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.FLYING_DETECTION`.
-     */
-    hasFlyingTemporaryEffect(player: EntityPlayer): boolean;
-}
-
 /**
  * An object containing all 7 vanilla fonts that are pre-loaded and ready to use.
  *
@@ -3974,17 +2769,6 @@ export declare const fonts: {
  */
 export declare function forEach<T>(array: T[], func: (value: T, index: number, array: T[]) => void): void;
 
-declare class ForgottenSwitch extends Feature {
-    private pressInput;
-    /**
-     * When used on The Forgotten, switches to The Soul. When used on The Soul, switches to The
-     * Forgotten. This takes 1 game frame to take effect.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.FORGOTTEN_SWITCH`.
-     */
-    forgottenSwitch(player: EntityPlayer): void;
-}
-
 declare type FunctionIsNotSerializable = "Error: Functions are not serializable. For more information, see: https://isaacscript.github.io/main/gotchas#functions-are-not-serializable";
 
 /** Helper type to represent a tuple containing the name of a function and the function itself. */
@@ -4006,77 +2790,6 @@ export declare const GAME_FRAMES_PER_MINUTE: number;
 /** Game frames are what is returned by the `Game.GetFrameCount` method. */
 export declare const GAME_FRAMES_PER_SECOND = 30;
 
-/**
- * By default, callbacks fire in the following order:
- * - `POST_NEW_ROOM` --> `POST_NEW_LEVEL` --> `POST_GAME_STARTED`
- *
- * It is easier to write mod code if the callbacks run in a more logical order:
- * - `POST_GAME_STARTED` --> `POST_NEW_LEVEL` --> `POST_NEW_ROOM`
- *
- * `isaacscript-common` provides three new callbacks that change the order to this:
- * - `POST_GAME_STARTED_REORDERED`
- * - `POST_NEW_LEVEL_REORDERED`
- * - `POST_NEW_ROOM_REORDERED`
- *
- * Additionally, there are some helper functions listed below that can deal with some edge cases
- * that you may run into with these callbacks.
- */
-declare class GameReorderedCallbacks extends Feature {
-    private currentStage;
-    private currentStageType;
-    private usedGlowingHourGlass;
-    private forceNewLevel;
-    private forceNewRoom;
-    private postGameStartedReordered;
-    private postNewLevelReordered;
-    private postNewRoomReordered;
-    private postGameStartedReorderedLast;
-    private useItemGlowingHourGlass;
-    private postGameStarted;
-    private postNewLevel;
-    private postNewRoom;
-    private recordCurrentStage;
-    /**
-     * Helper function to tell the `POST_NEW_LEVEL_REORDERED` callback that it should always fire on
-     * the next `POST_NEW_LEVEL`.
-     *
-     * If some specific cases, mods can change the current level during run initialization on the 0th
-     * frame. (For example, if you had a mod that made the player start the run in Caves instead of
-     * Basement.) However, due to how the callback reordering works, the `POST_NEW_LEVEL_REORDERED`
-     * callback will never fire on the 0th frame. To get around this, call this function before
-     * changing levels to temporarily force the callback to fire.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.GAME_REORDERED_CALLBACKS`.
-     */
-    forceNewLevelCallback(): void;
-    /**
-     * Helper function to tell the `POST_NEW_ROOM_REORDERED` callback that it should always fire on
-     * the next `POST_NEW_ROOM`.
-     *
-     * If some specific cases, mods can change the current room during run initialization on the 0th
-     * frame. (For example, if you had a mod that made the player start the Treasure Room of Basement
-     * 1 instead of the normal starting room.) However, due to how the callback reordering works, the
-     * `POST_NEW_ROOM_REORDERED` callback will never fire on the 0th frame. To get around this, call
-     * this function before changing rooms to temporarily force the callback to fire.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.GAME_REORDERED_CALLBACKS`.
-     */
-    forceNewRoomCallback(): void;
-    /**
-     * Helper function to manually set the variables that the reordered callback logic uses to track
-     * the current stage and stage type.
-     *
-     * This is useful because if the stage is changed with the `Game.SetStage` method (or the
-     * `setStage` helper function), the reordered callbacks will stop working.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.GAME_REORDERED_CALLBACKS`.
-     */
-    reorderedCallbacksSetStage(stage: LevelStage, stageType: StageType): void;
-}
-
 /**
  * Helper function to find the active slot that the player has the corresponding collectible type
  * in. Returns undefined if the player does not have the collectible in any active slot.
@@ -6768,20 +5481,6 @@ export declare const GRID_INDEX_CENTER_OF_1X1_ROOM = 67;
  */
 export declare function gridCoordinatesToWorldPosition(x: int, y: int): Vector;
 
-declare class GridEntityCollisionDetection extends Feature {
-    v: {
-        room: {
-            /** Indexed by grid entity pointer hash. */
-            collidingEntitiesMap: DefaultMap<PtrHash, Set<PtrHash>, []>;
-        };
-    };
-    private postGridEntityCollision;
-    private postGridEntityCustomCollision;
-    private customGridEntities;
-    constructor(postGridEntityCollision: PostGridEntityCollision, postGridEntityCustomCollision: PostGridEntityCustomCollision, customGridEntities: CustomGridEntities);
-    private postUpdate;
-}
-
 /**
  * This is meta-data that describes a custom grid entity.
  *
@@ -6811,47 +5510,6 @@ export declare type GridEntityID = string & {
     readonly __gridEntityIDBrand: symbol;
 };
 
-declare class GridEntityRenderDetection extends Feature {
-    private postGridEntityRender;
-    private postGridEntityCustomRender;
-    private customGridEntities;
-    constructor(postGridEntityRender: PostGridEntityRender, postGridEntityCustomRender: PostGridEntityCustomRender, customGridEntities: CustomGridEntities);
-    private postRender;
-}
-
-declare type GridEntityTuple = [
-gridEntityType: GridEntityType,
-variant: int,
-state: int
-];
-
-declare class GridEntityUpdateDetection extends Feature {
-    v: {
-        room: {
-            /** Indexed by grid index. */
-            initializedGridEntities: Map<number, GridEntityTuple>;
-        };
-    };
-    private postGridEntityInit;
-    private postGridEntityCustomInit;
-    private postGridEntityUpdate;
-    private postGridEntityCustomUpdate;
-    private postGridEntityRemove;
-    private postGridEntityCustomRemove;
-    private postGridEntityStateChanged;
-    private postGridEntityCustomStateChanged;
-    private postGridEntityBroken;
-    private postGridEntityCustomBroken;
-    private customGridEntities;
-    constructor(postGridEntityInit: PostGridEntityInit, postGridEntityCustomInit: PostGridEntityCustomInit, postGridEntityUpdate: PostGridEntityUpdate, postGridEntityCustomUpdate: PostGridEntityCustomUpdate, postGridEntityRemove: PostGridEntityRemove, postGridEntityCustomRemove: PostGridEntityCustomRemove, postGridEntityStateChanged: PostGridEntityStateChanged, postGridEntityCustomStateChanged: PostGridEntityCustomStateChanged, postGridEntityBroken: PostGridEntityBroken, postGridEntityCustomBroken: PostGridEntityCustomBroken, customGridEntities: CustomGridEntities);
-    private postUpdate;
-    private checkGridEntitiesRemoved;
-    private checkGridEntityStateChanged;
-    private checkNewGridEntity;
-    private updateTupleInMap;
-    private postNewRoomReordered;
-}
-
 /**
  * Helper function to convert a grid index to a grid position.
  *
@@ -7418,79 +6076,6 @@ export declare enum ISCFeature {
     TAINTED_LAZARUS_PLAYERS = 53
 }
 
-/**
- * We want to only extract the class public methods, so we omit the keys of the `Feature` base
- * class.
- */
-declare type ISCFeaturesToKeys<T extends readonly ISCFeature[]> = Omit<TupleToIntersection<ISCFeatureTupleToClassTuple<Writeable<T>>>, keyof Feature>;
-
-declare interface ISCFeatureToClass {
-    [ISCFeature.CUSTOM_REVIVE]: CustomRevive;
-    [ISCFeature.ESAU_JR_DETECTION]: EsauJrDetection;
-    [ISCFeature.FLIP_DETECTION]: FlipDetection;
-    [ISCFeature.GRID_ENTITY_COLLISION_DETECTION]: GridEntityCollisionDetection;
-    [ISCFeature.GRID_ENTITY_RENDER_DETECTION]: GridEntityRenderDetection;
-    [ISCFeature.GRID_ENTITY_UPDATE_DETECTION]: GridEntityUpdateDetection;
-    [ISCFeature.GAME_REORDERED_CALLBACKS]: GameReorderedCallbacks;
-    [ISCFeature.ITEM_PICKUP_DETECTION]: ItemPickupDetection;
-    [ISCFeature.PLAYER_COLLECTIBLE_DETECTION]: PlayerCollectibleDetection;
-    [ISCFeature.PLAYER_REORDERED_CALLBACKS]: PlayerReorderedCallbacks;
-    [ISCFeature.SLOT_DESTROYED_DETECTION]: SlotDestroyedDetection;
-    [ISCFeature.SLOT_RENDER_DETECTION]: SlotRenderDetection;
-    [ISCFeature.SLOT_UPDATE_DETECTION]: SlotUpdateDetection;
-    [ISCFeature.CHARACTER_HEALTH_CONVERSION]: CharacterHealthConversion;
-    [ISCFeature.CHARACTER_STATS]: CharacterStats;
-    [ISCFeature.COLLECTIBLE_ITEM_POOL_TYPE]: CollectibleItemPoolType;
-    [ISCFeature.CUSTOM_GRID_ENTITIES]: CustomGridEntities;
-    [ISCFeature.CUSTOM_ITEM_POOLS]: CustomItemPools;
-    [ISCFeature.CUSTOM_HOTKEYS]: CustomHotkeys;
-    [ISCFeature.CUSTOM_PICKUPS]: CustomPickups;
-    [ISCFeature.CUSTOM_STAGES]: CustomStages;
-    [ISCFeature.CUSTOM_TRAPDOORS]: CustomTrapdoors;
-    [ISCFeature.DEBUG_DISPLAY]: DebugDisplay;
-    [ISCFeature.DEPLOY_JSON_ROOM]: DeployJSONRoom;
-    [ISCFeature.DISABLE_ALL_SOUND]: DisableAllSound;
-    [ISCFeature.DISABLE_INPUTS]: DisableInputs;
-    [ISCFeature.FADE_IN_REMOVER]: FadeInRemover;
-    [ISCFeature.FAST_RESET]: FastReset;
-    [ISCFeature.FLYING_DETECTION]: FlyingDetection;
-    [ISCFeature.FORGOTTEN_SWITCH]: ForgottenSwitch;
-    [ISCFeature.EXTRA_CONSOLE_COMMANDS]: ExtraConsoleCommands;
-    [ISCFeature.ITEM_POOL_DETECTION]: ItemPoolDetection;
-    [ISCFeature.MODDED_ELEMENT_DETECTION]: ModdedElementDetection;
-    [ISCFeature.MODDED_ELEMENT_SETS]: ModdedElementSets;
-    [ISCFeature.NO_SIREN_STEAL]: NoSirenSteal;
-    [ISCFeature.PAUSE]: Pause;
-    [ISCFeature.PERSISTENT_ENTITIES]: PersistentEntities;
-    [ISCFeature.PICKUP_INDEX_CREATION]: PickupIndexCreation;
-    [ISCFeature.PLAYER_INVENTORY]: PlayerInventory;
-    [ISCFeature.PONY_DETECTION]: PonyDetection;
-    [ISCFeature.PRESS_INPUT]: PressInput;
-    [ISCFeature.PREVENT_CHILD_ENTITIES]: PreventChildEntities;
-    [ISCFeature.PREVENT_COLLECTIBLE_ROTATION]: PreventCollectibleRotation;
-    [ISCFeature.PREVENT_GRID_ENTITY_RESPAWN]: PreventGridEntityRespawn;
-    [ISCFeature.ROOM_CLEAR_FRAME]: RoomClearFrame;
-    [ISCFeature.ROOM_HISTORY]: RoomHistory;
-    [ISCFeature.RUN_IN_N_FRAMES]: RunInNFrames;
-    [ISCFeature.RUN_NEXT_ROOM]: RunNextRoom;
-    [ISCFeature.SAVE_DATA_MANAGER]: SaveDataManager;
-    [ISCFeature.SPAWN_ALT_ROCK_REWARDS]: SpawnRockAltRewards;
-    [ISCFeature.SPAWN_COLLECTIBLE]: SpawnCollectible;
-    [ISCFeature.STAGE_HISTORY]: StageHistory;
-    [ISCFeature.START_AMBUSH]: StartAmbush;
-    [ISCFeature.TAINTED_LAZARUS_PLAYERS]: TaintedLazarusPlayers;
-}
-
-declare type ISCFeatureTuple<T extends readonly ISCFeature[]> = ISCFeature extends T["length"] ? 'The list of features must be a tuple. Use the "as const" assertion when declaring the array.' : T;
-
-/**
- * We need to use the `PublicInterface` helper type because an intersection of two classes with the
- * same private fields will cause a `never` type.
- */
-declare type ISCFeatureTupleToClassTuple<T extends ISCFeature[]> = {
-    [Key in keyof T]: PublicInterface<ISCFeatureToClass[T[Key]]>;
-};
-
 /**
  * Helper function to check if a player is a specific character (i.e. `PlayerType`).
  *
@@ -8228,61 +6813,6 @@ export declare function isVector(object: unknown): object is Vector;
  */
 export declare const itemConfig: ItemConfig;
 
-declare class ItemPickupDetection extends Feature {
-    v: {
-        run: {
-            playersPickingUpItemMap: DefaultMap<PlayerIndex, PickingUpItem, []>;
-        };
-    };
-    private postItemPickup;
-    private preItemPickup;
-    constructor(postItemPickup: PostItemPickup, preItemPickup: PreItemPickup);
-    private postPEffectUpdateReordered;
-    private queueEmpty;
-    private queueNotEmpty;
-}
-
-declare class ItemPoolDetection extends Feature {
-    private moddedElementSets;
-    /**
-     * Helper function to get the remaining collectibles in a given item pool. This function is
-     * expensive, so only use it in situations where the lag is acceptable.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ITEM_POOL_DETECTION`.
-     */
-    getCollectiblesInItemPool(itemPoolType: ItemPoolType): CollectibleType[];
-    /**
-     * Helper function to see if the given collectible is still present in the given item pool.
-     *
-     * If the collectible is non-offensive, any Tainted Losts will be temporarily changed to Isaac and
-     * then changed back. (This is because Tainted Lost is not able to retrieve non-offensive
-     * collectibles from item pools).
-     *
-     * Under the hood, this function works by using the `ItemPool.AddRoomBlacklist` method to
-     * blacklist every collectible except for the one provided.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ITEM_POOL_DETECTION`.
-     */
-    isCollectibleInItemPool(collectibleType: CollectibleType, itemPoolType: ItemPoolType): boolean;
-    /**
-     * Helper function to see if the given collectible is unlocked on the current save file. This
-     * requires providing the corresponding item pool that the collectible is normally located in.
-     *
-     * - If any player currently has the collectible, then it is assumed to be unlocked. (This is
-     *   because in almost all cases, when a collectible is added to a player's inventory, it is
-     *   subsequently removed from all pools.)
-     * - If the collectible is located in more than one item pool, then any item pool can be provided.
-     * - If the collectible is not located in any item pools, then this function will always return
-     *   false.
-     * - If the collectible is non-offensive, any Tainted Losts will be temporarily changed to Isaac
-     *   and then changed back. (This is because Tainted Lost is not able to retrieve non-offensive
-     *   collectibles from item pools).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ITEM_POOL_DETECTION`.
-     */
-    isCollectibleUnlocked(collectibleType: CollectibleType, itemPoolType: ItemPoolType): boolean;
-}
-
 /**
  * Helper function to iterate over a table deterministically. This is useful because by default, the
  * `pairs` function will return the keys of a Lua table in a random order.
@@ -10808,943 +9338,138 @@ export declare enum ModCallbackCustom {
 }
 
 /**
- * Mods can add extra things to the game (e.g. collectibles, trinkets, and so on). Since mods load
- * in alphabetical order, the total number of things can't be properly be known until at least one
- * callback fires (which indicates that all mods have been loaded).
+ * Helper class for mods that want to represent their individual features as classes. Extend your
+ * mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
+ * that automatically subscribe to callbacks.
+ *
+ * When instantiating a mod feature class, you must pass your upgraded mod as the first argument to
+ * the constructor.
+ *
+ * If your feature has variables that are managed by the save data manager, you need to explicitly
+ * register them with the save data manager yourself in your class constructor. (It can't be
+ * automatically done because parent classes don't have access to child class properties.)
+ *
+ * In almost all cases, you will want the callback functions to be immediately subscribed after
+ * instantiating the class. However, if this is not the case, you can pass `false` as the optional
+ * second argument to the constructor.
  *
- * This feature gates all such functions behind a callback check. Subsequently, these functions will
- * throw a runtime error if they are called in the menu, before any callbacks have occurred. This
- * ensures that the proper values are always returned and allows you to get immediate feedback if
- * you accidentally access them from the menu.
+ * If your mod feature has a property called `v`, it will be assumed that these are variables that
+ * should be managed by the save data manager. Subsequently, they will automatically be registered
+ * with the save data manager upon initialization. Unfortunately, due to technical limitations with
+ * classes, this registration will only occur if you initialize the class with the `init` boolean
+ * argument set to false, and then explicitly call the `ModFeature.init` method yourself after the
+ * class is constructed. (This is because the parent class does not have access to the child's
+ * properties upon first construction.)
  */
-declare class ModdedElementDetection extends Feature {
-    private atLeastOneCallbackFired;
-    private postPlayerInit;
-    private errorIfNoCallbacksFired;
+export declare class ModFeature {
+    private mod;
     /**
-     * Returns the first modded collectible type, or undefined if there are no modded collectibles.
+     * An optional method that allows for conditional callback execution. If specified, any class
+     * method that is annotated with a `@Callback` or `@CallbackCustom` decorator will only be fired
+     * if the executed conditional function returns true.
      *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
+     * This property is used to easily turn entire mod features on and off (rather than repeating
+     * conditional logic and early returning at the beginning of every callback function).
      *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getFirstModdedCollectibleType(): CollectibleType | undefined;
-    /**
-     * Will change depending on how many modded collectibles there are.
+     * Since the specific information for the firing callback is passed as arguments into the
+     * conditional method, you can also write logic that would only apply to a specific type of
+     * callback.
      *
-     * Equal to `itemConfig.GetCollectibles().Size - 1`. (`Size` includes invalid collectibles, like
-     * 666. We subtract one to account for `CollectibleType.NULL`.)
+     * By default, this is set to null, which means that all callback methods will fire
+     * unconditionally. Override this property in your class if you need to use it.
      *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
+     * The function has the following signature:
      *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+     * ```ts
+     * <T extends boolean>(
+     *   vanilla: T, // Whether or not this is a vanilla or custom callback.
+     *   modCallback: T extends true ? ModCallback : ModCallbackCustom,
+     *   ...callbackArgs: unknown[] // This would be e.g. `pickup: EntityPickup` for the `POST_PICKUP_INIT` callback.
+     * ) => boolean;
+     * ```
      */
-    getLastCollectibleType(): CollectibleType;
+    protected shouldCallbackMethodsFire: (<T extends boolean>(vanilla: T, modCallback: T extends true ? ModCallback : ModCallbackCustom, ...callbackArgs: unknown[]) => boolean) | null;
     /**
-     * Helper function to get an array that represents the all modded collectible types.
-     *
-     * Returns an empty array if there are no modded collectible types.
-     *
-     * This function is only useful when building collectible type objects. For most purposes, you
-     * should use the `getModdedCollectibleArray` or `getModdedCollectibleSet` helper function
-     * instead.
-     *
-     * (This function is named differently from the `getVanillaCollectibleTypeRange` function because
-     * all modded collectible types are contiguous. Thus, each value represents a real
-     * `CollectibleType`.)
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
+     * Whether or not the feature has registered its callbacks yet.
      *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+     * This will almost always be equal to true unless you explicitly passed `false` to the second
+     * argument of the constructor.
      */
-    getModdedCollectibleTypes(): CollectibleType[];
+    initialized: boolean;
+    constructor(mod: ModUpgraded, init?: boolean);
     /**
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
+     * Runs the `Mod.AddCallback` and `ModUpgraded.AddCallbackCustom` methods for all of the decorated
+     * callbacks.
      *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+     * @param init Optional. Whether to initialize or uninitialize. Default is true.
      */
-    getNumCollectibleTypes(): int;
+    init(init?: boolean): void;
     /**
-     * Unlike vanilla collectible types, modded collectible types are always contiguous.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
+     * Runs the `Mod.RemoveCallback` and `ModUpgraded.RemoveCallbackCustom` methods for all of the
+     * decorated callbacks.
      *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+     * This is just an alias for `ModFeature.init(false)`.
      */
-    getNumModdedCollectibleTypes(): int;
+    uninit(): void;
+}
+
+/**
+ * `isaacscript-common` has many custom callbacks that you can use in your mods. Instead of
+ * hijacking the vanilla `Mod` object, we provide a `ModUpgraded` object for you to use, which
+ * extends the base class and adds a new method of `AddCallbackCustom`.
+ *
+ * To upgrade your mod, use the `upgradeMod` helper function.
+ *
+ * By specifying one or more optional features when upgrading your mod, you will get a version of
+ * `ModUpgraded` that has extra methods corresponding to the features that were specified. (This
+ * corresponds to the internal-type `ModUpgradedWithFeatures` type, which extends `ModUpgraded`.)
+ */
+export declare class ModUpgraded implements Mod {
+    Name: string;
+    /** We store a copy of the original mod object so that we can re-implement its functions. */
+    private mod;
+    private debug;
+    private timeThreshold;
+    private callbacks;
+    private features;
+    constructor(mod: Mod, debug: boolean, timeThreshold?: float);
+    AddCallback<T extends ModCallback | string>(modCallback: T, ...args: T extends ModCallback ? AddCallbackParameters[T] : unknown[]): void;
+    AddPriorityCallback<T extends ModCallback | string>(modCallback: T, priority: CallbackPriority | int, ...args: T extends ModCallback ? AddCallbackParameters[T] : unknown[]): void;
+    HasData(): boolean;
+    LoadData(): string;
+    RemoveCallback<T extends ModCallback>(modCallback: T, callback: AddCallbackParameters[T][0]): void;
+    RemoveData(): void;
+    SaveData(data: string): void;
     /**
-     * Returns the first modded trinket type, or undefined if there are no modded trinkets.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
+     * Registers a function to be executed when an in-game event happens.
      *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+     * This method is specifically for events that are provided by the IsaacScript standard library.
+     * For example, the `ModCallbackCustom.POST_BOMB_EXPLODE` event corresponds to when a bomb
+     * explodes.
      */
-    getFirstModdedTrinketType(): TrinketType | undefined;
+    AddCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, ...args: AddCallbackParametersCustom[T]): void;
     /**
-     * Will change depending on how many modded trinkets there are.
-     *
-     * This is equal to the number of trinket types, since all trinket types are contiguous (unlike
-     * collectibles).
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+     * The same as the `ModUpgraded.AddCallbackCustom` method, but allows setting a custom priority.
+     * By default, callbacks are added with a priority of 0, so this allows you to add early or late
+     * callbacks as necessary. See the `CallbackPriority` enum.
      */
-    getLastTrinketType(): TrinketType;
+    AddPriorityCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, priority: CallbackPriority | int, ...args: AddCallbackParametersCustom[T]): void;
     /**
-     * Helper function to get an array that represents every modded trinket type.
-     *
-     * Returns an empty array if there are no modded trinket types.
-     *
-     * This function is only useful when building collectible type objects. For most purposes, you
-     * should use the `getModdedCollectibleArray` or `getModdedCollectibleSet` helper function
-     * instead.
+     * Unregisters a function that was previously registered with the `AddCallbackCustom` method.
      *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
+     * This method is specifically for events that are provided by the IsaacScript standard library.
+     * For example, the `ModCallbackCustom.POST_BOMB_EXPLODE` event corresponds to when a bomb
+     * explodes.
      *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+     * This method does not care about the tertiary argument. In other words, regardless of the
+     * conditions of how you registered the callback, it will be removed.
      */
-    getModdedTrinketTypes(): TrinketType[];
+    RemoveCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, callback: AddCallbackParametersCustom[T][0]): void;
     /**
-     * Will change depending on how many modded trinkets there are.
-     *
-     * Equal to `itemConfig.GetTrinkets().Size - 1`. (We subtract one to account for
-     * `TrinketType.NULL`.)
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+     * Logs every custom callback or extra feature that is currently enabled. Useful for debugging or
+     * profiling.
      */
-    getNumTrinketTypes(): int;
-    /**
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getNumModdedTrinketTypes(): int;
-    /**
-     * Helper function to get an array that contains every trinket type.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getTrinketTypes(): TrinketType[];
-    /**
-     * Helper function to get an array with every valid card sub-type. This includes modded cards.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getAllCardTypes(): CardType[];
-    /**
-     * Returns the first modded card sub-type, or undefined if there are no modded cards.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getFirstModdedCardType(): CardType | undefined;
-    /**
-     * Will change depending on how many modded cards there are.
-     *
-     * This is equal to the number of cards, since all card sub-types are contiguous (unlike
-     * collectibles).
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getLastCardType(): CardType;
-    /**
-     * Helper function to get an array with every modded card sub-type.
-     *
-     * Returns an empty array if there are no modded cards.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getModdedCardTypes(): CardType[];
-    /**
-     * Will change depending on how many modded cards there are.
-     *
-     * Equal to `itemConfig.GetCards().Size - 1`. (We subtract one to account for `Card.NULL`.)
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getNumCardTypes(): int;
-    /**
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getNumModdedCardTypes(): int;
-    /**
-     * Helper function to get an array with every valid pill effect. This includes modded pill
-     * effects.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all pill effects will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getAllPillEffects(): PillEffect[];
-    /**
-     * Returns the first modded pill effect, or undefined if there are no modded pill effects.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all pill effects will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getFirstModdedPillEffect(): PillEffect | undefined;
-    /**
-     * Will change depending on how many modded pill effects there are.
-     *
-     * This is equal to the number of pill effects, since all pill effects are contiguous (unlike
-     * collectibles).
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all pill effects will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getLastPillEffect(): PillEffect;
-    /**
-     * Helper function to get an array with every modded pill effect.
-     *
-     * Returns an empty array if there are no modded pill effects.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all pill effects will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getModdedPillEffects(): PillEffect[];
-    /**
-     * Will change depending on how many modded pill effects there are.
-     *
-     * Equal to `itemConfig.GetPillEffects().Size`. (We do not have to subtract one, because the first
-     * pill effect has an ID of 0 and there is no `PillEffect.NULL`.)
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all pill effects will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getNumPillEffects(): int;
-    /**
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all pill effects will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getNumModdedPillEffects(): int;
-}
-
-declare class ModdedElementSets extends Feature {
-    private allCollectibleTypesArray;
-    private allCollectibleTypesSet;
-    private vanillaCollectibleTypesArray;
-    private vanillaCollectibleTypesSet;
-    private moddedCollectibleTypesArray;
-    private moddedCollectibleTypesSet;
-    private allTrinketTypesArray;
-    private allTrinketTypesSet;
-    private vanillaTrinketTypesArray;
-    private vanillaTrinketTypesSet;
-    private moddedTrinketTypesArray;
-    private moddedTrinketTypesSet;
-    private allCardTypesArray;
-    private allCardTypesSet;
-    private vanillaCardTypesArray;
-    private vanillaCardTypesSet;
-    private moddedCardTypesArray;
-    private moddedCardTypesSet;
-    private tagToCollectibleTypesMap;
-    private cacheFlagToCollectibleTypesMap;
-    private cacheFlagToTrinketTypesMap;
-    private flyingCollectibleTypesSet;
-    private permanentFlyingCollectibleTypesSet;
-    private flyingTrinketTypesSet;
-    private edenActiveCollectibleTypesSet;
-    private edenPassiveCollectibleTypesSet;
-    private itemConfigCardTypeToCardTypeMap;
-    /**
-     * The set of cards that are not:
-     *
-     * - ItemConfigCardType.RUNE
-     * - ItemConfigCardType.SPECIAL_OBJECT
-     */
-    private cardSet;
-    private moddedElementDetection;
-    private lazyInitVanillaCollectibleTypes;
-    private lazyInitModdedCollectibleTypes;
-    private lazyInitVanillaTrinketTypes;
-    private lazyInitModdedTrinketTypes;
-    private lazyInitVanillaCardTypes;
-    private lazyInitModdedCardTypes;
-    private lazyInitTagToCollectibleTypesMap;
-    private lazyInitCacheFlagToCollectibleTypesMap;
-    private lazyInitCacheFlagToTrinketTypesMap;
-    private lazyInitFlyingCollectibleTypesSet;
-    private lazyInitFlyingTrinketTypesSet;
-    private lazyInitEdenCollectibleTypesSet;
-    private lazyInitCardTypes;
-    /**
-     * Returns an array containing every valid card type in the game, including modded cards.
-     *
-     * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
-     * use the `getCardSet` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getCardArray(): readonly CardType[];
-    /**
-     * Returns a set containing every valid card type in the game, including modded cards.
-     *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
-     * use the `getCardArray` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getCardSet(): ReadonlySet<CardType>;
-    /**
-     * Helper function to get a set of card types matching the `ItemConfigCardType`.
-     *
-     * This function is variadic, meaning that you can you can specify N card types to get a set
-     * containing cards that match any of the specified types.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getCardTypesOfType(...itemConfigCardTypes: ItemConfigCardType[]): Set<CardType>;
-    /**
-     * Returns an array containing every valid collectible type in the game, including modded
-     * collectibles.
-     *
-     * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
-     * then use the `getCollectibleSet` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getCollectibleArray(): readonly CollectibleType[];
-    /**
-     * Returns a set containing every valid collectible type in the game, including modded
-     * collectibles.
-     *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
-     * then use the `getCollectibleArray` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getCollectibleSet(): ReadonlySet<CollectibleType>;
-    /**
-     * Helper function to get all of the collectible types in the game that count towards a particular
-     * transformation.
-     *
-     * For example, to get all of the collectible types that count towards Guppy:
-     *
-     * ```ts
-     * const guppyCollectibleTypes = getCollectiblesForTransformation(PlayerForm.GUPPY);
-     * ```
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getCollectiblesForTransformation(playerForm: PlayerForm): ReadonlySet<CollectibleType>;
-    /**
-     * Returns a set containing every collectible type with the given cache flag, including modded
-     * collectibles.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getCollectiblesWithCacheFlag(cacheFlag: CacheFlag): ReadonlySet<CollectibleType>;
-    /**
-     * Returns a set containing every collectible type with the given tag.
-     *
-     * For example, to get all of the collectible types that count as offensive for the purposes of
-     * Tainted Lost:
-     *
-     * ```ts
-     * const offensiveCollectibleTypes = getCollectibleTypesWithTag(ItemConfigTag.OFFENSIVE);
-     * ```
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getCollectiblesWithTag(itemConfigTag: ItemConfigTag): ReadonlySet<CollectibleType>;
-    /**
-     * Returns a set containing every valid passive item that can be randomly granted to Eden as a
-     * starting item.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getEdenActiveCollectibles(): ReadonlySet<CollectibleType>;
-    /**
-     * Returns a set containing every valid passive item that can be randomly granted to Eden as a
-     * starting item.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getEdenPassiveCollectibles(): ReadonlySet<CollectibleType>;
-    /**
-     * Returns a set of all of the collectibles that grant flight. This is derived from collectibles
-     * that have `CacheFlag.FLYING` set in the "items.xml" file.
-     *
-     * Collectibles that only grant flight conditionally are manually pruned. Collectibles such as
-     * Empty Vessel should be checked for via the `hasFlyingTemporaryEffect` function.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     *
-     * @param pruneConditionalItems Whether or not collectibles that only grant flight conditionally
-     *                              should be included in the set (like Empty Vessel).
-     */
-    getFlyingCollectibles(pruneConditionalItems: boolean): ReadonlySet<CollectibleType>;
-    /**
-     * Returns a set of all of the trinkets that grant flight. (All trinkets that grant flight do so
-     * conditionally, like Bat Wing and Azazel's Stump.)
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getFlyingTrinkets(): ReadonlySet<TrinketType>;
-    /**
-     * Returns an array containing every modded card type in the game.
-     *
-     * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
-     * use the `getModdedCardSet` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getModdedCardArray(): readonly CardType[];
-    /**
-     * Returns a set containing every modded card type in the game.
-     *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
-     * use the `getModdedCardArray` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getModdedCardSet(): ReadonlySet<CardType>;
-    /**
-     * Returns an array containing every modded collectible type in the game.
-     *
-     * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
-     * then use the `getModdedCollectibleSet` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getModdedCollectibleArray(): readonly CollectibleType[];
-    /**
-     * Returns a set containing every modded collectible type in the game.
-     *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
-     * then use the `getModdedCollectibleArray` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getModdedCollectibleSet(): ReadonlySet<CollectibleType>;
-    /**
-     * Returns an array containing every modded trinket type in the game.
-     *
-     * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
-     * then use the `getModdedTrinketSet` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getModdedTrinketArray(): readonly TrinketType[];
-    /**
-     * Returns a set containing every modded trinket type in the game.
-     *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
-     * then use the `getModdedTrinketArray` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getModdedTrinketSet(): ReadonlySet<TrinketType>;
-    /**
-     * Iterates over every item in the game and returns a map containing the number of each item that
-     * the player has.
-     *
-     * Note that this will filter out non-real collectibles like Lilith's Incubus.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getPlayerCollectibleMap(player: EntityPlayer): Map<CollectibleType, int>;
-    /**
-     * Returns an array containing every collectible type that the player has that matches the
-     * provided `CacheFlag`.
-     *
-     * For example, if the cache flag is `CacheFlag.FLYING`, and the player has one Lord of the Pit
-     * and two Dead Doves, then this function would return:
-     *
-     * ```ts
-     * [
-     *   CollectibleType.LORD_OF_THE_PIT,
-     *   CollectibleType.DEAD_DOVE,
-     *   CollectibleType.DEAD_DOVE,
-     * ]
-     * ```
-     *
-     * Note that this array will not include collectibles that the player does not really have, like
-     * Lilith's Incubus.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getPlayerCollectiblesWithCacheFlag(player: EntityPlayer, cacheFlag: CacheFlag): CollectibleType[];
-    /**
-     * Returns the number of items that a player has towards a particular transformation.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getPlayerCollectiblesWithTag(player: EntityPlayer, itemConfigTag: ItemConfigTag): CollectibleType[];
-    /**
-     * Returns the number of items that a player has towards a particular transformation.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getPlayerCollectiblesForTransformation(player: EntityPlayer, playerForm: PlayerForm): CollectibleType[];
-    /**
-     * Returns a map containing every trinket type that the player has that matches the provided
-     * `CacheFlag`. The values of the map correspond to the multiplier for that trinket.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getPlayerTrinketsWithCacheFlag(player: EntityPlayer, cacheFlag: CacheFlag): Map<TrinketType, int>;
-    /**
-     * Has an equal chance of returning any card (e.g. Fool, Reverse Fool, Wild Card, etc.).
-     *
-     * This will not return:
-     * - any runes
-     * - any objects like Dice Shard
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     *
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
-     * @param exceptions Optional. An array of cards to not select.
-     */
-    getRandomCard(seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
-    /**
-     * Helper function to get a random card type that matches the provided `ItemConfigCardType`.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     *
-     * @param itemConfigCardType The item config card type that represents the pool of cards to select
-     *                           from.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
-     * @param exceptions Optional. An array of cards to not select.
-     */
-    getRandomCardTypeOfType(itemConfigCardType: ItemConfigCardType, seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
-    /**
-     * Has an equal chance of returning any rune (e.g. Rune of Hagalaz, Blank Rune, Black Rune, Soul
-     * of Isaac, etc.). This will never return a Rune Shard.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     *
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
-     * @param exceptions Optional. An array of runes to not select.
-     */
-    getRandomRune(seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
-    /**
-     * Returns a random active collectible type that that is a valid starting item for Eden.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     *
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
-     * @param exceptions Optional. An array of runes to not select.
-     */
-    getRandomEdenActiveCollectible(seedOrRNG?: Seed | RNG, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
-    /**
-     * Returns a random passive collectible type that that is a valid starting item for Eden.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     *
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
-     * @param exceptions Optional. An array of runes to not select.
-     */
-    getRandomEdenPassiveCollectible(seedOrRNG?: Seed | RNG, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
-    /**
-     * Returns an array containing every modded trinket type in the game.
-     *
-     * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
-     * then use the `getModdedTrinketSet` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getTrinketArray(): readonly TrinketType[];
-    /**
-     * Returns a set containing every modded trinket type in the game.
-     *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
-     * then use the `getModdedTrinketArray` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getTrinketSet(): ReadonlySet<TrinketType>;
-    /**
-     * Returns a set containing every trinket type with the given cache flag, including modded
-     * trinkets.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getTrinketsWithCacheFlag(cacheFlag: CacheFlag): ReadonlySet<TrinketType>;
-    /**
-     * Returns an array containing every valid vanilla card type in the game.
-     *
-     * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
-     * use the `getVanillaCardSet` helper function instead.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getVanillaCardArray(): readonly CardType[];
-    /**
-     * Returns a set containing every valid vanilla card type in the game.
-     *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
-     * use the `getVanillaCardArray` helper function instead.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getVanillaCardSet(): ReadonlySet<CardType>;
-    /**
-     * Returns an array containing every valid vanilla collectible type in the game.
-     *
-     * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
-     * then use the `getVanillaCollectibleSet` helper function instead.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getVanillaCollectibleArray(): readonly CollectibleType[];
-    /**
-     * Returns a set containing every valid vanilla collectible type in the game.
-     *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
-     * then use the `getVanillaCollectibleArray` helper function instead.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getVanillaCollectibleSet(): ReadonlySet<CollectibleType>;
-    /**
-     * Returns an array containing every valid vanilla trinket type in the game.
-     *
-     * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
-     * then use the `getVanillaTrinketSet` helper function instead.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getVanillaTrinketArray(): readonly TrinketType[];
-    /**
-     * Returns a set containing every valid vanilla trinket type in the game.
-     *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
-     * then use the `getVanillaTrinketArray` helper function instead.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getVanillaTrinketSet(): ReadonlySet<TrinketType>;
-}
-
-/**
- * Helper class for mods that want to represent their individual features as classes. Extend your
- * mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
- * that automatically subscribe to callbacks.
- *
- * When instantiating a mod feature class, you must pass your upgraded mod as the first argument to
- * the constructor.
- *
- * If your feature has variables that are managed by the save data manager, you need to explicitly
- * register them with the save data manager yourself in your class constructor. (It can't be
- * automatically done because parent classes don't have access to child class properties.)
- *
- * In almost all cases, you will want the callback functions to be immediately subscribed after
- * instantiating the class. However, if this is not the case, you can pass `false` as the optional
- * second argument to the constructor.
- *
- * If your mod feature has a property called `v`, it will be assumed that these are variables that
- * should be managed by the save data manager. Subsequently, they will automatically be registered
- * with the save data manager upon initialization. Unfortunately, due to technical limitations with
- * classes, this registration will only occur if you initialize the class with the `init` boolean
- * argument set to false, and then explicitly call the `ModFeature.init` method yourself after the
- * class is constructed. (This is because the parent class does not have access to the child's
- * properties upon first construction.)
- */
-export declare class ModFeature {
-    private mod;
-    /**
-     * An optional method that allows for conditional callback execution. If specified, any class
-     * method that is annotated with a `@Callback` or `@CallbackCustom` decorator will only be fired
-     * if the executed conditional function returns true.
-     *
-     * This property is used to easily turn entire mod features on and off (rather than repeating
-     * conditional logic and early returning at the beginning of every callback function).
-     *
-     * Since the specific information for the firing callback is passed as arguments into the
-     * conditional method, you can also write logic that would only apply to a specific type of
-     * callback.
-     *
-     * By default, this is set to null, which means that all callback methods will fire
-     * unconditionally. Override this property in your class if you need to use it.
-     *
-     * The function has the following signature:
-     *
-     * ```ts
-     * <T extends boolean>(
-     *   vanilla: T, // Whether or not this is a vanilla or custom callback.
-     *   modCallback: T extends true ? ModCallback : ModCallbackCustom,
-     *   ...callbackArgs: unknown[] // This would be e.g. `pickup: EntityPickup` for the `POST_PICKUP_INIT` callback.
-     * ) => boolean;
-     * ```
-     */
-    protected shouldCallbackMethodsFire: (<T extends boolean>(vanilla: T, modCallback: T extends true ? ModCallback : ModCallbackCustom, ...callbackArgs: unknown[]) => boolean) | null;
-    /**
-     * Whether or not the feature has registered its callbacks yet.
-     *
-     * This will almost always be equal to true unless you explicitly passed `false` to the second
-     * argument of the constructor.
-     */
-    initialized: boolean;
-    constructor(mod: ModUpgradedBase, init?: boolean);
-    /**
-     * Runs the `Mod.AddCallback` and `ModUpgraded.AddCallbackCustom` methods for all of the decorated
-     * callbacks.
-     *
-     * @param init Optional. Whether to initialize or uninitialize. Default is true.
-     */
-    init(init?: boolean): void;
-    /**
-     * Runs the `Mod.RemoveCallback` and `ModUpgraded.RemoveCallbackCustom` methods for all of the
-     * decorated callbacks.
-     *
-     * This is just an alias for `ModFeature.init(false)`.
-     */
-    uninit(): void;
-}
-
-/**
- * `isaacscript-common` has many custom callbacks that you can use in your mods. Instead of
- * hijacking the vanilla `Mod` object, we provide a `ModUpgraded` object for you to use, which
- * extends the base class and adds a new method of `AddCallbackCustom`.
- *
- * To upgrade your mod, use the `upgradeMod` helper function.
- *
- * By specifying one or more optional features, end-users will get a version of `ModUpgraded` that
- * has extra methods corresponding to the features that were specified.
- */
-export declare type ModUpgraded<T extends readonly ISCFeature[] = []> = ModUpgradedBase & ISCFeaturesToKeys<T>;
-
-/**
- * `isaacscript-common` has many custom callbacks that you can use in your mods. Instead of
- * hijacking the vanilla `Mod` object, we provide a `ModUpgraded` object for you to use, which
- * extends the base class and adds a new method of `AddCallbackCustom`.
- *
- * To upgrade your mod, use the `upgradeMod` helper function.
- *
- * `ModUpgradedBase` provides the core functionality of the `ModUpgraded` class. (It does not
- * include the methods for the individual ISC features.)
- */
-export declare class ModUpgradedBase implements Mod {
-    Name: string;
-    /** We store a copy of the original mod object so that we can re-implement its functions. */
-    private mod;
-    private debug;
-    private timeThreshold;
-    private callbacks;
-    private features;
-    constructor(mod: Mod, debug: boolean, timeThreshold?: float);
-    /**
-     * Registers a function to be executed when an in-game event happens. For example, the
-     * `ModCallback.POST_UPDATE` event corresponds to being executed once at the end of every game
-     * logic frame.
-     */
-    AddCallback<T extends ModCallback | string>(modCallback: T, ...args: T extends ModCallback ? AddCallbackParameters[T] : unknown[]): void;
-    AddPriorityCallback<T extends ModCallback | string>(modCallback: T, priority: CallbackPriority | int, ...args: T extends ModCallback ? AddCallbackParameters[T] : unknown[]): void;
-    /** Returns whether or not a corresponding "save#.dat" file exists for the current mod. */
-    HasData(): boolean;
-    /**
-     * Returns a string containing all of the data inside of the corresponding "save#.dat" file for
-     * this mod.
-     */
-    LoadData(): string;
-    /**
-     * Unregisters a function that was previously registered with the `AddCallback` method.
-     *
-     * This method does not care about the tertiary argument. In other words, regardless of the
-     * conditions of how you registered the callback, it will be removed.
-     */
-    RemoveCallback<T extends ModCallback>(modCallback: T, callback: AddCallbackParameters[T][0]): void;
-    /** Deletes the corresponding "save#.dat" file for this mod, if it exists. */
-    RemoveData(): void;
-    /**
-     * Creates or updates the corresponding "save#.dat" file for this mod with the provided string.
-     */
-    SaveData(data: string): void;
-    /**
-     * Registers a function to be executed when an in-game event happens. This method is specifically
-     * for events that are provided by the IsaacScript standard library. For example, the
-     * `ModCallbackCustom.POST_BOMB_EXPLODE` event corresponds to when a bomb explodes.
-     */
-    AddCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, ...args: AddCallbackParametersCustom[T]): void;
-    /**
-     * Unregisters a function that was previously registered with the `AddCallbackCustom` method.
-     *
-     * This method does not care about the tertiary argument. In other words, regardless of the
-     * conditions of how you registered the callback, it will be removed.
-     */
-    RemoveCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, callback: AddCallbackParametersCustom[T][0]): void;
-    /**
-     * Logs every custom callback or extra feature that is currently enabled. Useful for debugging or
-     * profiling.
-     */
-    logUsedFeatures(): void;
+    logUsedFeatures(): void;
     /**
      * This is used to initialize both custom callbacks and "extra features".
      *
@@ -11763,11 +9488,6 @@ export declare class ModUpgradedBase implements Mod {
      * don't have access to it.
      */
     private initOptionalFeature;
-    /**
-     * This is mostly the same as the `AddCustomCallback` method, but we initialize the custom
-     * callback without actually registering a subscription.
-     */
-    private initCustomCallbackEarly;
 }
 
 export declare const MOVEMENT_ACTIONS_SET: ReadonlySet<ButtonAction>;
@@ -11884,23 +9604,6 @@ export declare function newTSTLClass(oldClass: TSTLClass): TSTLClass;
  */
 export declare function nextSeed(seed: Seed): Seed;
 
-declare class NoSirenSteal extends Feature {
-    private postNPCInitSirenHelper;
-    private checkReturnFamiliarToPlayer;
-    private blacklistEntryExists;
-    /**
-     * Blacklists a familiar from being stolen by The Siren boss. This should be called once at the
-     * beginning of every run.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.NO_SIREN_STEAL`.
-     *
-     * @param familiarVariant The familiar variant to blacklist.
-     * @param familiarSubType The sub-type to blacklist. Optional. The default is to blacklist all
-     *                        sub-types of the given variant.
-     */
-    setFamiliarNoSirenSteal(familiarVariant: FamiliarVariant, familiarSubType?: int): void;
-}
-
 export declare const NUM_DIMENSIONS: number;
 
 export declare const NUM_NORMAL_PILL_COLORS: number;
@@ -11988,8 +9691,6 @@ export declare function openAllDoors(): void;
  */
 export declare function openDoorFast(door: GridEntityDoor): void;
 
-declare type OptionalArgs<T extends ModCallbackCustom> = AllButFirst<AddCallbackParametersCustom[T]>;
-
 /**
  * Helper function to parse a string that contains an entity type, a variant, and a sub-type,
  * separated by periods.
@@ -12003,82 +9704,12 @@ export declare function parseEntityID(entityID: string): [entityType: EntityType
 /**
  * Helper function to parse a string that contains an entity type and a variant separated by a
  * period.
- *
- * For example, passing "45.0" would return an array of [45, 0].
- *
- * Returns undefined if the string cannot be parsed.
- */
-export declare function parseEntityTypeVariantString(entityTypeVariantString: string): [entityType: EntityType, variant: int] | undefined;
-
-declare class Pause extends Feature {
-    private disableInputs;
-    private postUpdate;
-    private stopTearsAndProjectilesFromMoving;
-    private inputActionGetActionValue;
-    isPaused(): boolean;
-    /**
-     * Helper function to emulate what happens when the player pauses the game. Use the `unpause`
-     * function to return things back to normal.
-     *
-     * Under the hood, this function:
-     * - uses the Pause collectible on every game frame
-     * - disables any player inputs (except for `ButtonAction.MENU_CONFIRM` and
-     *   `ButtonAction.CONSOLE`)
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.PAUSE`.
-     */
-    pause(): void;
-    /**
-     * Helper function to put things back to normal after the `pause` function was used.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.PAUSE`.
-     */
-    unpause(): void;
-}
-
-declare class PersistentEntities extends Feature {
-    private roomHistory;
-    private postEntityRemove;
-    /**
-     * The persistent entity is despawning because the player is in the process of leaving the room.
-     * Keep track of the position for later.
-     */
-    private trackDespawningPickupPosition;
-    private postNewRoomReordered;
-    private spawnAndTrack;
-    /**
-     * Helper function to stop an entity spawned with the `spawnPersistentEntity` helper function from
-     * respawning.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.PERSISTENT_ENTITIES`.
-     *
-     * @param persistentEntityIndex The index that was returned by the `spawnPersistentEntity`
-     *                              function.
-     * @param removeEntity Optional. True by default. Set to false if you want to stop an entity from
-     *                     being persistent but you don't want to actually remove the
-     *                     currently-spawned entity from the room.
-     */
-    removePersistentEntity(persistentEntityIndex: int, removeEntity?: boolean): void;
-    /**
-     * Helper function to spawn an entity that will have persistence similar to a pickup.
-     *
-     * By default, as soon as you leave a room, any spawned entities will be despawned and will not
-     * return if the player revisits the room. This means that if you want to have an entity like a
-     * pickup, you have to manually respawn it when the player re-enters the room. Use this helper
-     * function to avoid having to do any tracking on your own.
-     *
-     * Conventionally, the word "persistent" refers to `EntityFlag.FLAG_PERSISTENT`, which is used on
-     * e.g. familiars to make them appear in every room. On the other hand, pickups are also
-     * persistent, but they are not present in every room, only one specific room. This function
-     * spawns entities like pickups, not familiars.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.PERSISTENT_ENTITIES`.
-     *
-     * @returns A tuple containing the entity and the persistent entity index. You can use the index
-     *          with the `removePersistentEntity` function.
-     */
-    spawnPersistentEntity(entityType: EntityType, variant: int, subType: int, position: Vector): [Entity, int];
-}
+ *
+ * For example, passing "45.0" would return an array of [45, 0].
+ *
+ * Returns undefined if the string cannot be parsed.
+ */
+export declare function parseEntityTypeVariantString(entityTypeVariantString: string): [entityType: EntityType, variant: int] | undefined;
 
 export declare type PickingUpItem = PickingUpItemNull | PickingUpItemCollectible | PickingUpItemTrinket;
 
@@ -12124,45 +9755,6 @@ export declare type PickupIndex = int & {
     readonly __pickupIndexBrand: symbol;
 };
 
-declare class PickupIndexCreation extends Feature {
-    private roomHistory;
-    private saveDataManager;
-    private postPickupInit;
-    private setPickupIndex;
-    private getPickupIndexFromPreviousData;
-    private postEntityRemovePickup;
-    private checkDespawningFromPlayerLeavingRoom;
-    /**
-     * This is a pickup that is despawning because the player is in the process of leaving the room.
-     * Keep track of the metadata for later.
-     */
-    private trackDespawningPickupMetadata;
-    /**
-     * If the despawning pickup was in a Treasure Room or Boss Room, then it is possible that the
-     * pickup could re-appear during The Ascent. If this is the case, we store the metadata on a
-     * separate map to reference later.
-     */
-    private getPickupDataMapForCurrentRoom;
-    private getPostAscentPickupIndex;
-    /**
-     * Mods often have to track variables relating to a pickups. Finding an index for these kinds of
-     * data structures is difficult, since pickups are respawned every time a player re-enters a room,
-     * so the `PtrHash` will change.
-     *
-     * Use this function to get a unique index for a pickup to use in these data structures.
-     *
-     * Specifically, `PickupIndex` is a number that represents the spawn order of the pickup on the
-     * current run. For example, the first pickup spawned will have an index of 1, the second one will
-     * have an index of 2, and so on.
-     *
-     * Tracking pickups requires stateful tracking, so using pickup indexes requires an upgraded mod.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.PICKUP_INDEX_CREATION`.
-     */
-    getPickupIndex(pickup: EntityPickup): PickupIndex;
-}
-
 /** Maps pill effect names to the values of the `PillEffect` enum. */
 export declare const PILL_NAME_TO_EFFECT_MAP: ReadonlyMap<string, PillEffect>;
 
@@ -12184,53 +9776,6 @@ export declare function playChargeSoundEffect(player: EntityPlayer, activeSlot?:
  */
 export declare function playerAddCollectible(player: EntityPlayer, ...collectibleTypes: CollectibleType[]): void;
 
-declare class PlayerCollectibleDetection extends Feature {
-    v: {
-        run: {
-            playersCollectibleCount: DefaultMap<PlayerIndex, number, []>;
-            playersCollectibleMap: DefaultMap<PlayerIndex, Map<CollectibleType, number>, []>;
-            playersActiveItemMap: DefaultMap<PlayerIndex, Map<ActiveSlot, CollectibleType>, []>;
-        };
-    };
-    private postPlayerCollectibleAdded;
-    private postPlayerCollectibleRemoved;
-    private moddedElementSets;
-    private runInNFrames;
-    constructor(postPlayerCollectibleAdded: PostPlayerCollectibleAdded, postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved, moddedElementSets: ModdedElementSets, runInNFrames: RunInNFrames);
-    /**
-     * This is called when the collectible count changes and in situations where the entire build is
-     * rerolled.
-     *
-     * Since getting a new player collectible map is expensive, we want to only run this function when
-     * necessary, and not on e.g. every frame. Unfortunately, this has the side effect of missing out
-     * on collectible changes from mods that add and remove a collectible on the same frame.
-     *
-     * @param player The player to update.
-     * @param numCollectiblesChanged Pass undefined for situations where the entire build was
-     *                               rerolled.
-     */
-    private updateCollectibleMapAndFire;
-    private useItemD4;
-    /** We need to handle the case of Tainted Eden taking damage. */
-    private entityTakeDmgPlayer;
-    /**
-     * We need to handle TMTRAINER collectibles, since they do not cause the player's collectible
-     * count to change.
-     */
-    private postItemPickup;
-    private postPEffectUpdateReordered;
-    /**
-     * Checking for collectible count will work to detect when a player swaps their active item for
-     * another active item. This is because the collectible count will decrement by 1 when the item is
-     * swapped onto the pedestal and the hold animation begins, and increment by 1 when the item is
-     * dequeued and the hold animation ends.
-     *
-     * However, we also want to explicitly check for the case where a mod swaps in a custom active
-     * collectible on the same frame, since doing so is cheap.
-     */
-    private checkActiveItemsChanged;
-}
-
 export declare function playerConvertBlackHeartsToSoulHearts(player: EntityPlayer): void;
 
 export declare function playerConvertSoulHeartsToBlackHearts(player: EntityPlayer): void;
@@ -12294,62 +9839,6 @@ export declare type PlayerIndex = int & {
     readonly __playerIndexBrand: symbol;
 };
 
-declare class PlayerInventory extends Feature {
-    private postCollectibleAdded;
-    private postCollectibleRemoved;
-    /**
-     * Helper function to get all of the collectibles that the player has gotten so far on this run,
-     * in order.
-     *
-     * In the case of inventory initialization or the case where the player rerolls their build in the
-     * middle of the run (e.g. with D4), the order of the inventory will not correspond to the order
-     * that the items were actually given to the player. In this case, the inventory will be in the
-     * order of the lowest `CollectibleType` to the highest.
-     *
-     * Under the hood, the inventory tracking works by tracking the number of collectibles that a
-     * player has on every frame. Thus, in a situation where a collectible was both added and removed
-     * to the player on the same frame, the amount of total collectibles would stay the same, and the
-     * inventory would not be updated. In vanilla, this situation would never happen, but another mod
-     * might do this for some reason. (With that said, the next time that a collectible is normally
-     * added or removed, it would trigger a re-scan, and the previous changes would be picked up.)
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.PLAYER_INVENTORY`.
-     *
-     * @param player The player to get the inventory for.
-     * @param includeActiveCollectibles Optional. If true, will include all active collectibles.
-     *                                Default is true.
-     */
-    getPlayerInventory(player: EntityPlayer, includeActiveCollectibles?: boolean): CollectibleType[];
-    /**
-     * Helper function to get the last passive collectible that the player picked up. In most cases,
-     * this will be the passive that is removed when the player would use Clicker.
-     *
-     * Returns undefined if the player does not have any passive collectibles.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.PLAYER_INVENTORY`.
-     */
-    getPlayerLastPassiveCollectible(player: EntityPlayer): CollectibleType | undefined;
-}
-
-declare class PlayerReorderedCallbacks extends Feature {
-    v: {
-        run: {
-            postGameStartedFiredOnThisRun: boolean;
-            postPEffectUpdateQueue: PlayerIndex[];
-            postPlayerUpdateQueue: PlayerIndex[];
-            postPlayerRenderQueue: PlayerIndex[];
-        };
-    };
-    private postPEffectUpdateReordered;
-    private postPlayerRenderReordered;
-    private postPlayerUpdateReordered;
-    constructor(postPEffectUpdateReordered: PostPEffectUpdateReordered, postPlayerRenderReordered: PostPlayerRenderReordered, postPlayerUpdateReordered: PostPlayerUpdateReordered);
-    private postPEffectUpdate;
-    private postPlayerUpdate;
-    private postPlayerRender;
-    private postGameStartedReorderedLast;
-}
-
 /** This is used by the `getPocketItems` and related helper functions. */
 export declare interface PocketItemDescription {
     slot: PocketItemSlot;
@@ -12367,268 +9856,12 @@ export declare enum PocketItemType {
     UNDETERMINABLE = 5
 }
 
-declare class PonyDetection extends Feature {
-    private postPEffectUpdateReordered;
-    /**
-     * Helper function to see if the player is under the effects of A Pony or White Pony charge.
-     * Detecting this is difficult, as the temporary effect will disappear upon entering a new room.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.PONY_DETECTION`.
-     */
-    isPlayerUsingPony(player: EntityPlayer): boolean;
-    /**
-     * Helper function to see if any player is under the effects of A Pony or White Pony charge.
-     * Detecting this is difficult, as the temporary effect will disappear upon entering a new room.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.PONY_DETECTION`.
-     */
-    anyPlayerUsingPony(): boolean;
-}
-
 /**
  * These are the possible types that player stats can be. For example, `EntityPlayer.Damage` is of
  * type `float`, `EntityPlayer.CanFly` is of type `boolean`, and so on.
  */
 export declare type PossibleStatType = number | boolean | BitFlags<TearFlag> | Color | Vector;
 
-declare class PostCustomRevive extends CustomCallback<ModCallbackCustom.POST_CUSTOM_REVIVE> {
-    constructor();
-    protected shouldFire: (fireArgs: [player: EntityPlayer, revivalType: number], optionalArgs: OptionalArgs<T>) => boolean;
-}
-
-declare class PostEsauJr extends CustomCallback<ModCallbackCustom.POST_ESAU_JR> {
-    constructor();
-}
-
-declare class PostFirstEsauJr extends CustomCallback<ModCallbackCustom.POST_FIRST_ESAU_JR> {
-    constructor();
-}
-
-declare class PostFirstFlip extends CustomCallback<ModCallbackCustom.POST_FIRST_FLIP> {
-    constructor();
-}
-
-declare class PostFlip extends CustomCallback<ModCallbackCustom.POST_FLIP> {
-    constructor();
-}
-
-declare class PostGridEntityBroken extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_BROKEN> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntity;
-}
-
-declare class PostGridEntityCollision extends CustomCallback<T_2> {
-    constructor();
-    protected shouldFire: (fireArgs: [gridEntity: GridEntity, entity: Entity], optionalArgs: [gridEntityType?: GridEntityType | undefined, gridEntityVariant?: number | undefined, entityType?: EntityType | undefined, entityVariant?: number | undefined, entitySubType?: number | undefined]) => boolean;
-}
-
-declare class PostGridEntityCustomBroken extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntityCustom;
-}
-
-declare class PostGridEntityCustomCollision extends CustomCallback<T_3> {
-    constructor();
-    protected shouldFire: (fireArgs: [gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType, entity: Entity], optionalArgs: [gridEntityTypeCustom?: GridEntityType | undefined, entityType?: EntityType | undefined, entityVariant?: number | undefined, entitySubType?: number | undefined]) => boolean;
-}
-
-declare class PostGridEntityCustomInit extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_INIT> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntityCustom;
-}
-
-declare class PostGridEntityCustomRemove extends CustomCallback<T_5> {
-    constructor();
-    protected shouldFire: (fireArgs: [gridIndex: number, gridEntityTypeCustom: GridEntityType], optionalArgs: OptionalArgs<T_5>) => boolean;
-}
-
-declare class PostGridEntityCustomRender extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_RENDER> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntityCustom;
-}
-
-declare class PostGridEntityCustomStateChanged extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntityCustom;
-}
-
-declare class PostGridEntityCustomUpdate extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntityCustom;
-}
-
-declare class PostGridEntityInit extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_INIT> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntity;
-}
-
-declare class PostGridEntityRemove extends CustomCallback<T_4> {
-    constructor();
-    protected shouldFire: (fireArgs: [gridIndex: number, gridEntityType: GridEntityType, variant: number], optionalArgs: [gridEntityType?: GridEntityType | undefined, variant?: number | undefined]) => boolean;
-}
-
-declare class PostGridEntityRender extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_RENDER> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntity;
-}
-
-declare class PostGridEntityStateChanged extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_STATE_CHANGED> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntity;
-}
-
-declare class PostGridEntityUpdate extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_UPDATE> {
-    constructor();
-    protected shouldFire: typeof shouldFireGridEntity;
-}
-
-declare class PostItemPickup extends CustomCallback<ModCallbackCustom.POST_ITEM_PICKUP> {
-    constructor();
-    protected shouldFire: typeof shouldFireItemPickup;
-}
-
-declare class PostPEffectUpdateReordered extends CustomCallback<ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED> {
-    constructor();
-    protected shouldFire: typeof shouldFirePlayer;
-}
-
-declare class PostPlayerCollectibleAdded extends CustomCallback<ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED> {
-    constructor();
-    protected shouldFire: typeof shouldFireCollectibleType;
-}
-
-declare class PostPlayerCollectibleRemoved extends CustomCallback<ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED> {
-    constructor();
-    protected shouldFire: typeof shouldFireCollectibleType;
-}
-
-declare class PostPlayerRenderReordered extends CustomCallback<ModCallbackCustom.POST_PLAYER_RENDER_REORDERED> {
-    constructor();
-    protected shouldFire: typeof shouldFirePlayer;
-}
-
-declare class PostPlayerUpdateReordered extends CustomCallback<ModCallbackCustom.POST_PLAYER_UPDATE_REORDERED> {
-    constructor();
-    protected shouldFire: typeof shouldFirePlayer;
-}
-
-declare class PostSlotAnimationChanged extends CustomCallback<ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED> {
-    constructor();
-    protected shouldFire: typeof shouldFireSlot;
-}
-
-declare class PostSlotDestroyed extends CustomCallback<ModCallbackCustom.POST_SLOT_DESTROYED> {
-    constructor();
-    protected shouldFire: typeof shouldFireSlot;
-}
-
-declare class PostSlotInit extends CustomCallback<ModCallbackCustom.POST_SLOT_INIT> {
-    constructor();
-    protected shouldFire: typeof shouldFireSlot;
-}
-
-declare class PostSlotRender extends CustomCallback<ModCallbackCustom.POST_SLOT_RENDER> {
-    constructor();
-    protected shouldFire: typeof shouldFireSlot;
-}
-
-declare class PostSlotUpdate extends CustomCallback<ModCallbackCustom.POST_SLOT_UPDATE> {
-    constructor();
-    protected shouldFire: typeof shouldFireSlot;
-}
-
-declare class PreCustomRevive extends CustomCallback<ModCallbackCustom.PRE_CUSTOM_REVIVE> {
-    constructor();
-    protected shouldFire: typeof shouldFirePlayer;
-}
-
-declare class PreItemPickup extends CustomCallback<ModCallbackCustom.PRE_ITEM_PICKUP> {
-    constructor();
-    protected shouldFire: typeof shouldFireItemPickup;
-}
-
-declare class PressInput extends Feature {
-    private isActionTriggered;
-    /**
-     * Helper function to press an arbitrary `ButtonAction` on the next possible input poll. In most
-     * cases, this will be equivalent to if the first player pressed the corresponding input. It
-     * usually takes 1 frame for the input to take effect.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.PRESS_INPUT`.
-     */
-    pressInput(player: EntityPlayer, buttonAction: ButtonAction): void;
-}
-
-declare class PreventChildEntities extends Feature {
-    private postNPCInit;
-    /**
-     * Helper function to prevent an entity from spawning any other entities. Meant to be used on NPCs
-     * like Squirts. This behavior will only last for the current room.
-     *
-     * Under the hood, this function will remove any new NPCs spawned that have a
-     * `Entity.SpawnerEntity` or `Entity.Parent` value that matches the provided entity. (They are
-     * removed during the `POST_NPC_INIT` callback specifically.)
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.PREVENT_CHILD_ENTITIES`.
-     */
-    preventChildEntities(entity: Entity): void;
-}
-
-declare class PreventCollectibleRotation extends Feature {
-    private useCardSoulOfIsaac;
-    private postPickupUpdateCollectible;
-    private checkCollectibleRotated;
-    /**
-     * Helper function to prevent a collectible from being affected by Tainted Isaac's rotation
-     * mechanic. (This mechanic also happens from Glitched Crown and Binge Eater.) This is useful
-     * because quest items that are manually spawned by mods will be automatically be affected by this
-     * mechanic.
-     *
-     * It is required to pass the intended collectible type to this function since it is possible for
-     * collectibles to rotate on the first frame that they are spawned.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.PREVENT_COLLECTIBLE_ROTATION`.
-     */
-    preventCollectibleRotation(collectible: EntityPickup, collectibleType: CollectibleType): void;
-}
-
-declare class PreventGridEntityRespawn extends Feature {
-    private runInNFrames;
-    private preUseItemWeNeedToGoDeeper;
-    private postNewRoomReordered;
-    /**
-     * Every time we re-enter the room, the sprites for all of the decorations will come back, so we
-     * have to remove them again.
-     */
-    private setDecorationsInvisible;
-    /**
-     * Helper function to prevent any removed grid entities from respawning if the player re-enters
-     * the current room.
-     *
-     * This is accomplished by spawning a new grid entity on every tile that does not already have a
-     * grid entity. This will force the game to spawn the new grid entity instead of the old one. The
-     * natural grid entity to choose for this purpose is a decoration, since it is non-interacting.
-     * Then, the decorations are made invisible and any shovel uses are intercepted to avoid creating
-     * a crawl space (instead of a trapdoor).
-     *
-     * Another option besides decorations would be to use a pressure plates with a state of 1, which
-     * is a state that is normally unused by the game and makes it invisible & persistent. However,
-     * pickups will not be able to spawn on pressure plates, which lead to various bugs (e.g. pickups
-     * spawning on top of pits). Thus, using a decoration is preferable.
-     *
-     * Yet another option to accomplish this would be to replace the room data with that of an empty
-     * room. However, the room data must exactly match the room type, the room shape, and the doors,
-     * so this is not possible to do in a robust way without adding empty rooms to the mod's `content`
-     * folder to draw the data from.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.PREVENT_GRID_ENTITY_RESPAWN`.
-     */
-    preventGridEntityRespawn(): void;
-}
-
 /** Helper function to print whether something was enabled or disabled to the in-game console. */
 export declare function printEnabled(enabled: boolean, description: string): void;
 
@@ -13330,24 +10563,6 @@ export declare enum RockAltType {
 /** Maps room names to the values of the `RoomType` enum. */
 export declare const ROOM_NAME_TO_TYPE_MAP: ReadonlyMap<string, RoomType>;
 
-declare class RoomClearFrame extends Feature {
-    private postRoomClearChangedTrue;
-    /**
-     * Helper function to get the game frame (i.e. `Game.GetFrameCount`) of the last time that this
-     * room was cleared. Returns undefined if the room has never been cleared.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_CLEAR_FRAME`.
-     */
-    getRoomClearGameFrame(): int | undefined;
-    /**
-     * Helper function to get the room frame (i.e. `Room.GetFrameCount`) of the last time that this
-     * room was cleared. Returns undefined if the room has never been cleared.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_CLEAR_FRAME`.
-     */
-    getRoomClearRoomFrame(): int | undefined;
-}
-
 /** This is used by the room history feature of the standard library. */
 export declare interface RoomDescription {
     startSeedString: string;
@@ -13370,238 +10585,42 @@ export declare interface RoomDescription {
  */
 export declare function roomExists(roomGridIndex: int): boolean;
 
-/**
- * Helper function to get the coordinates of a given grid index. The floor is represented by a 13x13
- * grid.
- *
- * - Since the starting room is in the center, the starting room grid index of 84 is equal to
- *   coordinates of (6, 6).
- * - The top-left grid index of 0 is equal to coordinates of: (12, 0)
- * - The top-right grid index of 12 is equal to coordinates of: (0, 0)
- * - The bottom-left grid index of 156 is equal to coordinates of: (0, 12)
- * - The bottom-right grid index of 168 is equal to coordinates of: (12, 12)
- */
-export declare function roomGridIndexToXY(roomGridIndex: int): [x: int, y: int];
-
-declare class RoomHistory extends Feature {
-    private postNewRoomEarly;
-    /**
-     * Helper function to get the total number of rooms that the player has entered thus far on the
-     * run. (Re-entering the same room will increment the number returned.)
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
-     */
-    getNumRoomsEntered(): int;
-    /**
-     * Helper function to get information about all of the rooms that a player has visited thus far on
-     * this run.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
-     */
-    getRoomHistory(): ReadonlyArray<Readonly<RoomDescription>>;
-    /**
-     * Helper function to get information about the room that was previously visited.
-     *
-     * In the special case of only one room having been visited thus far (i.e. the starting room of
-     * the run), the starting room will be returned.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
-     */
-    getPreviousRoomDescription(): Readonly<RoomDescription>;
-    /**
-     * Helper function to get information about the most recent room that is stored in the room
-     * history array.
-     *
-     * This is useful in the `POST_ENTITY_REMOVE` callback; see the `isLeavingRoom` function.
-     *
-     * Note that this function can return undefined in the case where it is called on the first room
-     * of the run.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
-     */
-    getLatestRoomDescription(): Readonly<RoomDescription> | undefined;
-    /**
-     * Helper function to detect if the game is in the state where the room index has changed to a new
-     * room, but the entities from the previous room are currently in the process of despawning. (At
-     * this point, the `POST_NEW_ROOM` callback and the `POST_NEW_ROOM_EARLY` callback will not have
-     * fired yet, and there will not be an entry in the room history array for the current room.)
-     *
-     * This function is intended to be used in the `POST_ENTITY_REMOVE` callback to detect when an
-     * entity is despawning.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
-     */
-    isLeavingRoom(): boolean;
-}
-
-/**
- * If the `Room.Update` method is called in a `POST_NEW_ROOM` callback, then some entities will
- * slide around (such as the player). Since those entity velocities are already at zero, setting
- * them to zero will have no effect. Thus, a generic solution is to record all of the entity
- * positions/velocities before updating the room, and then restore those positions/velocities.
- */
-export declare function roomUpdateSafe(): void;
-
-/**
- * If rounding fails, this function returns 0.
- * From: http://lua-users.org/wiki/SimpleRound
- *
- * @param num The number to round.
- * @param numDecimalPlaces Optional. Default is 0.
- */
-export declare function round(num: float, numDecimalPlaces?: number): float;
-
-/**
- * Run the suite of tests that prove that the "deepCopy" helper function works properly.
- *
- * This function is only useful if you are troubleshooting the "deepCopy" function.
- */
-export declare function runDeepCopyTests(): void;
-
-declare class RunInNFrames extends Feature {
-    vConditionalFunc: () => boolean;
-    private roomHistory;
-    private postUpdate;
-    private postRender;
-    /**
-     * Helper function to restart on the next render frame. Useful because it is impossible to restart
-     * the game inside of the `POST_NEW_ROOM`, `POST_NEW_LEVEL`, or `POST_GAME_STARTED` callbacks when
-     * a run is first starting.
-     *
-     * You can optionally specify a `PlayerType` to restart the game as that character.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
-     */
-    restartNextRenderFrame(character?: PlayerType): void;
-    /**
-     * Supply a function to run N game frames from now in the `POST_UPDATE` callback.
-     *
-     * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a
-     * similar way.
-     *
-     * Note that this function will not handle saving and quitting. If a player saving and quitting
-     * before the deferred function fires would cause a bug in your mod, then you should handle
-     * deferred functions manually using serializable data.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
-     *
-     * @param func The function to run.
-     * @param gameFrames The amount of game frames to wait before running the function.
-     * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
-     *                            room is loaded in the interim. Default is false.
-     */
-    runInNGameFrames(func: () => void, gameFrames: int, cancelIfRoomChanges?: boolean): void;
-    /**
-     * Supply a function to run N render frames from now in the `POST_RENDER` callback.
-     *
-     * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a
-     * similar way.
-     *
-     * Note that this function will not handle saving and quitting. If a player saving and quitting
-     * before the deferred function fires would cause a bug in your mod, then you should handle
-     * deferred functions manually using serializable data.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
-     *
-     * @param func The function to run.
-     * @param renderFrames The amount of render frames to wait before running the function.
-     * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
-     *                            room is loaded in the interim. Default is false.
-     */
-    runInNRenderFrames(func: () => void, renderFrames: int, cancelIfRoomChanges?: boolean): void;
-    /**
-     * Supply a function to run on the next `POST_UPDATE` callback.
-     *
-     * For example:
-     *
-     * ```ts
-     * const NUM_EXPLODER_EXPLOSIONS = 5;
-     *
-     * function useItemExploder(player: EntityPlayer) {
-     *   playSound("exploderBegin");
-     *   explode(player, NUM_EXPLODER_EXPLOSIONS);
-     * }
-     *
-     * function explode(player: EntityPlayer, numFramesLeft: int) {
-     *   Isaac.Explode(player, undefined, 1);
-     *   numFramesLeft -= 1;
-     *   if (numFramesLeft === 0) {
-     *     runNextFrame(() => {
-     *       explode(player, numFramesLeft);
-     *     });
-     *   }
-     * }
-     * ```
-     *
-     * Note that this function will not handle saving and quitting. If a player saving and quitting
-     * before the deferred function fires would cause a bug in your mod, then you should handle
-     * deferred functions manually using serializable data.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
-     *
-     * @param func The function to run.
-     * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
-     *                            room is loaded in the interim. Default is false.
-     */
-    runNextGameFrame(func: () => void, cancelIfRoomChanges?: boolean): void;
-    /**
-     * Supply a function to run on the next `POST_RENDER` callback.
-     *
-     * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a
-     * similar way.
-     *
-     * Note that this function will not handle saving and quitting.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
-     *
-     * @param func The function to run.
-     * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
-     *                            room is loaded in the interim. Default is false.
-     */
-    runNextRenderFrame(func: () => void, cancelIfRoomChanges?: boolean): void;
-    /**
-     * Supply a function to be repeatedly run on an interval of N game frames in the `POST_UPDATE`
-     * callback. The function will continue to be fired until `false` is returned from the function.
-     *
-     * This is similar to the `setInterval` vanilla JavaScript function, except there is no
-     * corresponding `clearInterval` function. (Instead, the return value from the supplied function
-     * is used to stop the interval.)
-     *
-     * Note that this function will not handle saving and quitting. You must manually restart any
-     * intervals if the player saves and quits in the middle of a run.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
-     *
-     * @param func The function to repeatedly run on an interval.
-     * @param gameFrames The amount of game frames to wait between each run.
-     * @param runImmediately Whether or not to execute the function right now before waiting for the
-     *                       interval.
-     * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
-     *                            room is loaded in the interim. Default is false.
-     */
-    setIntervalGameFrames(func: () => boolean, gameFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
-    /**
-     * Supply a function to be repeatedly run on an interval of N render frames in the `POST_RENDER`
-     * callback. The function will continue to be fired until `false` is returned from the function.
-     *
-     * This is similar to the `setInterval` vanilla JavaScript function, except there is no
-     * corresponding `clearInterval` function. (Instead, the return value from the supplied function
-     * is used to stop the interval.)
-     *
-     * Note that this function will not handle saving and quitting. You must manually restart any
-     * intervals if the player saves and quits in the middle of a run.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
-     *
-     * @param func The function to repeatedly run on an interval.
-     * @param renderFrames The amount of game frames to wait between each run.
-     * @param runImmediately Whether or not to execute the function right now before waiting for the
-     *                       interval.
-     * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
-     *                            room is loaded in the interim. Default is false.
-     */
-    setIntervalRenderFrames(func: () => boolean, renderFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
-}
+/**
+ * Helper function to get the coordinates of a given grid index. The floor is represented by a 13x13
+ * grid.
+ *
+ * - Since the starting room is in the center, the starting room grid index of 84 is equal to
+ *   coordinates of (6, 6).
+ * - The top-left grid index of 0 is equal to coordinates of: (12, 0)
+ * - The top-right grid index of 12 is equal to coordinates of: (0, 0)
+ * - The bottom-left grid index of 156 is equal to coordinates of: (0, 12)
+ * - The bottom-right grid index of 168 is equal to coordinates of: (12, 12)
+ */
+export declare function roomGridIndexToXY(roomGridIndex: int): [x: int, y: int];
+
+/**
+ * If the `Room.Update` method is called in a `POST_NEW_ROOM` callback, then some entities will
+ * slide around (such as the player). Since those entity velocities are already at zero, setting
+ * them to zero will have no effect. Thus, a generic solution is to record all of the entity
+ * positions/velocities before updating the room, and then restore those positions/velocities.
+ */
+export declare function roomUpdateSafe(): void;
+
+/**
+ * If rounding fails, this function returns 0.
+ * From: http://lua-users.org/wiki/SimpleRound
+ *
+ * @param num The number to round.
+ * @param numDecimalPlaces Optional. Default is 0.
+ */
+export declare function round(num: float, numDecimalPlaces?: number): float;
+
+/**
+ * Run the suite of tests that prove that the "deepCopy" helper function works properly.
+ *
+ * This function is only useful if you are troubleshooting the "deepCopy" function.
+ */
+export declare function runDeepCopyTests(): void;
 
 /**
  * Run the suite of tests that prove that the "merge" function works properly.
@@ -13610,21 +10629,6 @@ declare class RunInNFrames extends Feature {
  */
 export declare function runMergeTests(): void;
 
-declare class RunNextRoom extends Feature {
-    vConditionalFunc: () => boolean;
-    private postNewRoomReordered;
-    /**
-     * Supply a function to run on the next `POST_NEW_ROOM` callback.
-     *
-     * Note that this function will not handle saving and quitting. If a player saving and quitting
-     * before the deferred function fires would cause a bug in your mod, then you should handle
-     * deferred functions manually using serializable data.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_NEXT_ROOM`.
-     */
-    runNextRoom(func: () => void): void;
-}
-
 /**
  * This is the format of the object that you give to the save data manager. It will contains all of
  * the variables for the particular mod feature.
@@ -13664,241 +10668,6 @@ export declare enum SaveDataKey {
     ROOM = "room"
 }
 
-declare class SaveDataManager extends Feature {
-    /**
-     * We store a local reference to the mod object so that we can access the corresponding methods
-     * that read and write to the "save#.dat" file.
-     */
-    private mod;
-    /**
-     * The save data map is indexed by subscriber name. We use Lua tables instead of TypeScriptToLua
-     * Maps for the master map so that we can access the variables via the in-game console when
-     * debugging. (TSTL Maps don't expose the map keys as normal keys.)
-     */
-    private saveDataMap;
-    /**
-     * When mod feature data is initialized, we copy the initial values into a separate map so that we
-     * can restore them later on.
-     */
-    private saveDataDefaultsMap;
-    /**
-     * Each mod feature can optionally provide a function that can control whether or not the save
-     * data is written to disk.
-     */
-    private saveDataConditionalFuncMap;
-    /**
-     * We backup some save data keys on every new room for the purposes of restoring it when Glowing
-     * Hour Glass is used.
-     *
-     * Note that the save data is backed up in serialized form so that we can use the `merge` function
-     * to restore it.
-     */
-    private saveDataGlowingHourGlassMap;
-    /**
-     * End-users can register their classes with the save data manager for proper serialization when
-     * contained in nested maps, sets, and arrays.
-     */
-    private classConstructors;
-    private loadedDataOnThisRun;
-    private restoreGlowingHourGlassDataOnNextRoom;
-    private postUseItemGlowingHourGlass;
-    private postPlayerInit;
-    private preGameExit;
-    private postNewLevel;
-    private postNewRoomEarly;
-    /**
-     * This is the entry point to the save data manager, a system which provides two major features:
-     *
-     * 1. Automatic resetting of variables on a new run, on a new level, or on a new room (as
-     *    desired).
-     * 2. Automatic saving and loading of all tracked data to the "save#.dat" file.
-     *
-     * You feed this function with an object containing your variables, and then it will automatically
-     * manage them for you. (See below for an example.)
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
-     * (Upgrade your mod before registering any of your own callbacks so that the save data manager
-     * will run before any of your code does.)
-     *
-     * The save data manager is meant to be called once for each feature of your mod. In other words,
-     * you should not put all of the data for your mod on the same object. Instead, scope your
-     * variables locally to a single file that contains a mod feature, and then call this function to
-     * register them. For example:
-     *
-     * ```ts
-     * // In file: feature1.ts
-     * import { saveDataManager } from "isaacscript-common";
-     *
-     * // Declare local variables for this file or feature.
-     * const v = {
-     *   // These variables are never reset; manage them yourself at will.
-     *   persistent: {
-     *     foo1: 0,
-     *   },
-     *
-     *   // These variables are reset at the beginning of every run.
-     *   run: {
-     *     foo2: 0,
-     *   },
-     *
-     *   // These variables are reset at the beginning of every level.
-     *   level: {
-     *     foo3: 0,
-     *   },
-     *
-     *   // These variables are reset at the beginning of every room.
-     *   room: {
-     *     foo4: 0,
-     *   },
-     * };
-     * // Every child object is optional; only create the ones that you need.
-     *
-     * // Register the variables with the save data manager. (We need to provide a string key that
-     * // matches the name of this file.)
-     * function feature1Init() {
-     *   saveDataManager("feature1", v);
-     * }
-     *
-     * // Elsewhere in the file, use your variables.
-     * function feature1Function() {
-     *   if (v.run.foo1 > 0) {
-     *     // Insert code here.
-     *   }
-     * }
-     * ```
-     *
-     * - Save data is loaded from disk in the `POST_PLAYER_INIT` callback (i.e. the first callback
-     *   that can possibly run).
-     * - Save data is recorded to disk in the `PRE_GAME_EXIT` callback.
-     *
-     * You can use many different variable types on your variable object, but not everything is
-     * supported. For the specific things that are supported, see the documentation for the `deepCopy`
-     * helper function.
-     *
-     * If you want the save data manager to load data before the `POST_PLAYER_INIT` callback (i.e. in
-     * the main menu), then you should explicitly call the `saveDataManagerLoad` function. (The save
-     * data manager cannot do this on its own because it cannot know when your mod features are
-     * finished initializing.)
-     *
-     * Some features may have variables that need to be automatically reset per run/level, but not
-     * saved to disk on game exit. (For example, if they contain functions or other non-serializable
-     * data.) For these cases, set the second argument to `false`.
-     *
-     * Note that when the player uses Glowing Hourglass, the save data manager will automatically
-     * restore any variables on a "run" or "level" object with a backup that was created when the room
-     * was entered. Thus, you should not have to explicitly program support for Glowing Hourglass into
-     * your mod features that use the save data manager. If this is undesired for your specific
-     * use-case, then add a key of `__ignoreGlowingHourGlass: true` to your "run" or "level" object.
-     *
-     * @param key The name of the file or feature that is submitting data to be managed by the save
-     *            data manager. The save data manager will throw an error if the key is already
-     *            registered. Note that you can also pass a TSTL class instead of a string and the
-     *            save data manager will use the name of the class as the key.
-     * @param v An object that corresponds to the `SaveData` interface. The object is conventionally
-     *          called "v" for brevity. ("v" is short for "local variables").
-     * @param conditionalFunc Optional. A function to run to check if this save data should be written
-     *                        to disk. Default is `() => true`, meaning that this save data will
-     *                        always be written to disk. Use a conditional function for the situations
-     *                        when the local variables are for a feature that the end-user can
-     *                        disable. (If the feature is disabled, then there would be no point in
-     *                        writing any of the variables to the "save#.dat" file.) You can also
-     *                        specify `false` to this argument in order to completely disable saving
-     *                        data. (Specifying `false` will allow you to use non-serializable objects
-     *                        in your save data, such as `EntityPtr`.
-     */
-    saveDataManager<Persistent, Run, Level>(key: string | object, v: SaveData<Persistent, Run, Level>, conditionalFunc?: () => boolean): void;
-    saveDataManager(key: string | object, v: SaveData, conditionalFunc: false): void;
-    /**
-     * Recursively traverses an object, collecting all of the class constructors that it encounters.
-     */
-    private storeClassConstructorsFromObject;
-    /**
-     * The save data manager will automatically load variables from disk at the appropriate times
-     * (i.e. when a new run is started). Use this function to explicitly force the save data manager
-     * to load all of its variables from disk immediately.
-     *
-     * Obviously, doing this will overwrite the current data, so using this function can potentially
-     * result in lost state.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
-     */
-    saveDataManagerLoad(): void;
-    /**
-     * The save data manager will automatically save variables to disk at the appropriate times (i.e.
-     * when the run is exited). Use this function to explicitly force the save data manager to write
-     * all of its variables to disk immediately.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
-     */
-    saveDataManagerSave(): void;
-    /**
-     * Sets the global variable of "g" equal to all of the save data variables for this mod.
-     *
-     * This can make debugging easier, as you can access the variables from the game's debug console.
-     * e.g. `l print(g.feature1.run.foo)`
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
-     */
-    saveDataManagerSetGlobal(): void;
-    /**
-     * By default, the save data manager will not be able to serialize/deserialize classes that are
-     * nested inside of maps, sets, and arrays, because it does not have access to the corresponding
-     * class constructor. If you want to use nested classes in this way, then use this function to
-     * register the class constructor with the save data manager. Once registered, the save data
-     * manager will automatically run the constructor when deserializing (in addition to copying over
-     * the data fields).
-     *
-     * This function is variadic, which means you can pass as many classes as you want to register.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
-     */
-    saveDataManagerRegisterClass(...tstlClasses: AnyClass[]): void;
-    /**
-     * Removes a previously registered key from the save data manager. This is the opposite of the
-     * "saveDataManager" method.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
-     */
-    saveDataManagerRemove(key: string): void;
-    /**
-     * The save data manager will automatically reset variables at the appropriate times, like when a
-     * player enters a new room. Use this function to explicitly force the save data manager to reset
-     * a specific variable group.
-     *
-     * For example:
-     *
-     * ```ts
-     * const v = {
-     *   room: {
-     *     foo: 123,
-     *   },
-     * };
-     *
-     * mod.saveDataManager("file1", v);
-     *
-     * // Then, later on, to explicit reset all of the "room" variables:
-     * mod.saveDataManagerReset("file1", "room");
-     * ```
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
-     */
-    saveDataManagerReset(key: string, childObjectKey: SaveDataKey): void;
-    /**
-     * Helper function to check to see if the game is in the menu, as far as the save data manager is
-     * concerned. This function will return true when the game is first opened until the
-     * `POST_PLAYER_INIT` callback fires. It will also return true in between the `PRE_GAME_EXIT`
-     * callback firing and the `POST_PLAYER_INIT` callback firing.
-     *
-     * This function is useful because the `POST_ENTITY_REMOVE` callback fires after the
-     * `PRE_GAME_EXIT` callback. Thus, if save data needs to be updated from the `POST_ENTITY_REMOVE`
-     * callback and the player is in the process of saving and quitting, the feature will have to
-     * explicitly call the `saveDataManagerSave` function.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
-     */
-    saveDataManagerInMenu(): boolean;
-}
-
 export declare const SECOND_IN_MILLISECONDS = 1000;
 
 /**
@@ -14364,41 +11133,6 @@ export declare const sfxManager: SFXManager;
 
 export declare const SHOOTING_ACTIONS_SET: ReadonlySet<ButtonAction>;
 
-declare function shouldFireCollectibleType(fireArgs: [player: EntityPlayer, collectibleType: CollectibleType], optionalArgs: [collectibleType?: CollectibleType]): boolean;
-
-declare function shouldFireGridEntity(fireArgs: [gridEntity: GridEntity] | [gridEntity: GridEntity, oldState: int, newState: int], optionalArgs: [gridEntityType?: GridEntityType, variant?: int]): boolean;
-
-declare function shouldFireGridEntityCustom(fireArgs: [gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType] | [
-gridEntity: GridEntity,
-gridEntityTypeCustom: GridEntityType,
-oldState: int,
-newState: int
-], optionalArgs: [gridEntityTypeCustom?: GridEntityType]): boolean;
-
-declare function shouldFireItemPickup(fireArgs: [player: EntityPlayer, pickingUpItem: PickingUpItem], optionalArgs: [itemType?: ItemType, subType?: int]): boolean;
-
-declare function shouldFirePlayer(fireArgs: [player: EntityPlayer] | [player: EntityPlayer, numSacrifices: int] | [player: EntityPlayer, collectible: EntityPickupCollectible] | [player: EntityPlayer, oldCharacter: PlayerType, newCharacter: PlayerType] | [
-player: EntityPlayer,
-healthType: HealthType,
-difference: int,
-oldValue: int,
-newValue: int
-] | [
-player: EntityPlayer,
-amount: float,
-damageFlags: BitFlags<DamageFlag>,
-source: EntityRef,
-countdownFrames: int
-] | [
-player: EntityPlayer,
-statType: StatType,
-difference: int,
-oldValue: PossibleStatType,
-newValue: PossibleStatType
-], optionalArgs: [playerVariant?: PlayerVariant, character?: PlayerType]): boolean;
-
-declare function shouldFireSlot(fireArgs: [slot: EntitySlot] | [slot: EntitySlot, player: EntityPlayer] | [slot: EntitySlot, slotDestructionType: SlotDestructionType] | [slot: EntitySlot, previousAnimation: string, currentAnimation: string], optionalArgs: [slotVariant?: SlotVariant, subType?: int]): boolean;
-
 /**
  * Shallow copies and shuffles the array using the Fisher-Yates algorithm. Returns the copied array.
  *
@@ -14424,28 +11158,6 @@ export declare function shuffleArrayInPlace<T>(array: T[], seedOrRNG?: Seed | RN
 /** @returns 1 if n is positive, -1 if n is negative, or 0 if n is 0. */
 export declare function sign(n: number): int;
 
-declare class SlotDestroyedDetection extends Feature {
-    v: {
-        room: {
-            destroyedSlotSet: Set<PtrHash>;
-        };
-    };
-    private postSlotDestroyed;
-    private roomHistory;
-    constructor(postSlotDestroyed: PostSlotDestroyed, roomHistory: RoomHistory);
-    private postEntityRemoveSlot;
-    private postEntityRemoveSlotMachine;
-    private postEntityRemoveBeggar;
-    private postSlotUpdate;
-    /**
-     * Slots normally have an entity collision class of `EntityCollisionClass.ALL` (4) and a grid
-     * collision class of `EntityGridCollisionClass.NONE` (0). When they are destroyed with a bomb,
-     * the entity collision class stays the same, but the grid collision class switches to
-     * `EntityGridCollisionClass.GROUND` (5).
-     */
-    private checkDestroyedFromCollisionClass;
-}
-
 /** This is used in the `POST_SLOT_DESTROYED` custom callback. */
 export declare enum SlotDestructionType {
     /**
@@ -14465,34 +11177,6 @@ export declare enum SlotDestructionType {
     COLLECTIBLE_PAYOUT = 1
 }
 
-declare class SlotRenderDetection extends Feature {
-    v: {
-        room: {
-            slotAnimations: DefaultMap<PtrHash, string, [slot: Entity]>;
-            brokenSlots: Set<PtrHash>;
-        };
-    };
-    private postSlotRender;
-    private postSlotAnimationChanged;
-    constructor(postSlotRender: PostSlotRender, postSlotAnimationChanged: PostSlotAnimationChanged);
-    private postRender;
-    private checkSlotAnimationChanged;
-}
-
-declare class SlotUpdateDetection extends Feature {
-    v: {
-        room: {
-            initializedSlots: Set<PtrHash>;
-        };
-    };
-    private postSlotInit;
-    private postSlotUpdate;
-    constructor(postSlotInit: PostSlotInit, postSlotUpdate: PostSlotUpdate);
-    private postUpdate;
-    private postNewRoomReordered;
-    private checkNewEntity;
-}
-
 /**
  * Helper function to smelt a trinket. Before smelting, this function will automatically remove the
  * trinkets that the player is holding, if any, and then give them back after the new trinket is
@@ -14527,6 +11211,45 @@ export declare function smeltTrinkets(player: EntityPlayer, ...trinketTypes: Tri
  */
 export declare function some<T>(array: T[], func: (value: T, index: number, array: T[]) => boolean): boolean;
 
+/**
+ * Helper function to sort an array of objects by one of the object keys.
+ *
+ * For example:
+ *
+ * ```ts
+ * const myArray = [
+ *   {
+ *     name: "alice",
+ *     age: 30,
+ *   },
+ *   {
+ *     name: "bob",
+ *     age: 20,
+ *   },
+ * ];
+ * myArray.sort(sortObjectArrayByKey("age"));
+ * ```
+ */
+export declare function sortObjectArrayByKey(key: string): (a: unknown, b: unknown) => -1 | 0 | 1;
+
+/**
+ * Helper function to sort a two-dimensional array by the first element.
+ *
+ * For example:
+ *
+ * ```ts
+ * const myArray = [[1, 2], [2, 3], [3, 4]];
+ * myArray.sort(twoDimensionalSort);
+ * ```
+ *
+ * This function also properly handles when the array elements are strings or numbers (instead of
+ * another array).
+ *
+ * From:
+ * https://stackoverflow.com/questions/16096872/how-to-sort-2-dimensional-array-by-column-value
+ */
+export declare function sortTwoDimensionalArray<T>(a: T[], b: T[]): -1 | 0 | 1;
+
 export declare type SoulHeartType = HeartSubType.SOUL | HeartSubType.BLACK | HeartSubType.BONE;
 
 /**
@@ -14612,54 +11335,6 @@ export declare function spawnCoin(coinSubType: CoinSubType, positionOrGridIndex:
  */
 export declare function spawnCoinWithSeed(coinSubType: CoinSubType, positionOrGridIndex: Vector | int, seedOrRNG: Seed | RNG, velocity?: Vector, spawner?: Entity | undefined): EntityPickupCoin;
 
-declare class SpawnCollectible extends Feature {
-    private preventCollectibleRotation;
-    /**
-     * Helper function to spawn a collectible.
-     *
-     * Use this instead of the `Game.Spawn` method because it handles the cases of Tainted Keeper
-     * collectibles costing coins and preventing quest items from being rotated by Tainted Isaac's
-     * rotation mechanic.
-     *
-     * If you do not need to handle quest items being rotated (i.e. the collectible is guaranteed not
-     * to be a quest item), then you can use the `spawnCollectibleUnsafe` helper function instead
-     * (which does not require an upgraded mod).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SPAWN_COLLECTIBLE`.
-     *
-     * @param collectibleType The collectible type to spawn.
-     * @param positionOrGridIndex The position or grid index to spawn the collectible at.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
-     * @param options Optional. Set to true to make the collectible a "There's Options" style
-     *                collectible. Default is false.
-     * @param forceFreeItem Optional. Set to true to disable the logic that gives the item a price for
-     *                      Tainted Keeper. Default is false.
-     * @param spawner Optional.
-     */
-    spawnCollectible(collectibleType: CollectibleType, positionOrGridIndex: Vector | int, seedOrRNG?: Seed | RNG, options?: boolean, forceFreeItem?: boolean, spawner?: Entity): EntityPickupCollectible;
-    /**
-     * Helper function to spawn a collectible from a specific item pool.
-     *
-     * Use this instead of the `Game.Spawn` method because it handles the cases of Tainted Keeper
-     * collectibles costing coins and preventing quest items from being rotated by Tainted Isaac's
-     * rotation mechanic.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.SPAWN_COLLECTIBLE`.
-     *
-     * @param itemPoolType The item pool to draw the collectible type from.
-     * @param positionOrGridIndex The position or grid index to spawn the collectible at.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
-     * @param options Optional. Set to true to make the collectible a "There's Options" style
-     *                collectible. Default is false.
-     * @param forceFreeItem Optional. Set to true to disable the logic that gives the item a price for
-     *                      Tainted Keeper. Default is false.
-     * @param spawner Optional.
-     */
-    spawnCollectibleFromPool(itemPoolType: ItemPoolType, positionOrGridIndex: Vector | int, seedOrRNG?: Seed | RNG, options?: boolean, forceFreeItem?: boolean, spawner?: Entity): EntityPickupCollectible;
-}
-
 /**
  * Helper function to spawn a collectible.
  *
@@ -14851,103 +11526,6 @@ export declare function spawnProjectileWithSeed(projectileVariant: ProjectileVar
 /** Helper function to spawn a `GridEntityType.ROCK` (2). */
 export declare function spawnRock(gridIndexOrPosition: int | Vector): GridEntityRock | undefined;
 
-declare class SpawnRockAltRewards extends Feature {
-    private itemPoolDetection;
-    /**
-     * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
-     * breaks.
-     *
-     * Most of the time, this function will do nothing, similar to how most of the time, when an
-     * individual urn is destroyed, nothing will spawn.
-     *
-     * Note that in vanilla, trinkets will not spawn if they have already been removed from the
-     * trinket pool. This function cannot replicate that behavior because there is no way to check to
-     * see if a trinket is still in the pool. Thus, it will always have a chance to spawn the
-     * respective trinket
-     * (e.g. Swallowed Penny from urns).
-     *
-     * When filled buckets are destroyed, 6 projectiles will always spawn in a random pattern (in
-     * addition to any other rewards that are spawned). This function does not account for this, so if
-     * you want to specifically emulate destroying a filled bucket, you have to account for the
-     * projectiles yourself.
-     *
-     * The logic in this function is based on the rewards listed on the wiki:
-     * https://bindingofisaacrebirth.fandom.com/wiki/Rocks
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.SPAWN_ALT_ROCK_REWARDS`.
-     *
-     * @param positionOrGridIndex The position or grid index to spawn the reward.
-     * @param rockAltType The type of reward to spawn. For example, `RockAltType.URN` will have a
-     *                    chance at spawning coins and spiders.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`. Normally,
-     *                  you should pass the `InitSeed` of the grid entity that was broken.
-     * @returns Whether or not this function spawned something.
-     */
-    spawnRockAltReward(positionOrGridIndex: Vector | int, rockAltType: RockAltType, seedOrRNG?: Seed | RNG): boolean;
-    /**
-     * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
-     * breaks of `RockAltType.URN`.
-     *
-     * For more information, see the documentation for the `spawnRockAltReward` function.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.SPAWN_ALT_ROCK_REWARDS`.
-     */
-    spawnRockAltRewardUrn(position: Vector, rng: RNG): boolean;
-    /**
-     * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
-     * breaks of `RockAltType.MUSHROOM`.
-     *
-     * For more information, see the documentation for the `spawnRockAltReward` function.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.SPAWN_ALT_ROCK_REWARDS`.
-     */
-    spawnRockAltRewardMushroom(position: Vector, rng: RNG): boolean;
-    /**
-     * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
-     * breaks of `RockAltType.SKULL`.
-     *
-     * For more information, see the documentation for the `spawnRockAltReward` function.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.SPAWN_ALT_ROCK_REWARDS`.
-     */
-    spawnRockAltRewardSkull(position: Vector, rng: RNG): boolean;
-    /**
-     * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
-     * breaks of `RockAltType.POLYP`.
-     *
-     * For more information, see the documentation for the `spawnRockAltReward` function.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.SPAWN_ALT_ROCK_REWARDS`.
-     */
-    spawnRockAltRewardPolyp(position: Vector, rng: RNG): boolean;
-    /**
-     * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
-     * breaks of `RockAltType.BUCKET_DOWNPOUR`.
-     *
-     * For more information, see the documentation for the `spawnRockAltReward` function.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.SPAWN_ALT_ROCK_REWARDS`.
-     */
-    spawnRockAltRewardBucketDownpour(position: Vector, rng: RNG): boolean;
-    /**
-     * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
-     * breaks of `RockAltType.BUCKET_DROSS`.
-     *
-     * For more information, see the documentation for the `spawnRockAltReward` function.
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.SPAWN_ALT_ROCK_REWARDS`.
-     */
-    spawnRockAltRewardBucketDross(position: Vector, rng: RNG): boolean;
-}
-
 /** Helper function to spawn a `GridEntityType.ROCK` (2) with a specific variant. */
 export declare function spawnRockWithVariant(rockVariant: RockVariant, gridIndexOrPosition: int | Vector): GridEntityRock | undefined;
 
@@ -15028,55 +11606,6 @@ export declare function spawnWithSeed(entityType: EntityType, variant: int, subT
  */
 export declare function spriteEquals(sprite1: Sprite, sprite2: Sprite, layerID: int, xStart: int, xFinish: int, xIncrement: int, yStart: int, yFinish: int, yIncrement: int): boolean;
 
-declare class StageHistory extends Feature {
-    private postNewLevelReordered;
-    /**
-     * Helper function to get the stage type that a trapdoor or heaven door would take the player to,
-     * based on the current stage, room, and game state flags.
-     *
-     * This function accounts for the previous floors that a player has visited thus far on the run so
-     * that the next stage type can be properly calculated on The Ascent (which makes it unlike the
-     * `getNextStageType` function).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.STAGE_HISTORY`.
-     *
-     * @param upwards Whether or not the player should go up to Cathedral in the case of being on Womb
-     *                2. Default is false.
-     */
-    getNextStageTypeWithHistory(upwards?: boolean): StageType;
-    /**
-     * Helper function to get the stage that a trapdoor or heaven door would take the player to, based
-     * on the current stage, room, and game state flags.
-     *
-     * This function accounts for the previous floors that a player has visited thus far on the run so
-     * that the next stage can be properly calculated on The Ascent (which makes it unlike the
-     * `getNextStage` function).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.STAGE_HISTORY`.
-     */
-    getNextStageWithHistory(): LevelStage;
-    /**
-     * Helper function to get all of the stages that a player has visited thus far on this run.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.STAGE_HISTORY`.
-     */
-    getStageHistory(): ReadonlyArray<[
-    stage: LevelStage,
-    stageType: StageType
-    ]>;
-    /**
-     * Helper function to check if a player has previous visited a particular stage (or stage + stage
-     * type combination) on this run.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.STAGE_HISTORY`.
-     *
-     * @param stage The stage to check for.
-     * @param stageType Optional. If provided, will check for a specific stage and stage type
-     *                  combination.
-     */
-    hasVisitedStage(stage: LevelStage, stageType?: StageType): boolean;
-}
-
 /**
  * Helper function to convert a numerical `StageType` into the letter suffix supplied to the "stage"
  * console command. For example, `StageType.REPENTANCE` is the stage type for Downpour, and the
@@ -15085,19 +11614,6 @@ declare class StageHistory extends Feature {
  */
 export declare function stageTypeToLetter(stageType: StageType): string;
 
-declare class StartAmbush extends Feature {
-    private runInNFrames;
-    /**
-     * Helper function to start a Challenge Room or the Boss Rush.
-     *
-     * Specifically, this is performed by spawning a sack on top of the player, waiting a game frame,
-     * and then removing the sack and the pickups that the sack dropped.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.START_AMBUSH`.
-     */
-    startAmbush(): void;
-}
-
 /** Helper type to ensure that the given string starts with an lowercase letter. */
 export declare type StartsWithLowercase<S> = S extends string ? Extract<S, Uncapitalize<S>> : never;
 
@@ -15177,16 +11693,6 @@ export declare function sumSet(set: Set<number> | ReadonlySet<number>): number;
  */
 export declare function swapArrayElements<T>(array: T[], i: number, j: number): void;
 
-declare type T = ModCallbackCustom.POST_CUSTOM_REVIVE;
-
-declare type T_2 = ModCallbackCustom.POST_GRID_ENTITY_COLLISION;
-
-declare type T_3 = ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_COLLISION;
-
-declare type T_4 = ModCallbackCustom.POST_GRID_ENTITY_REMOVE;
-
-declare type T_5 = ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_REMOVE;
-
 /**
  * Helper function to check if a Lua table has all of the provided keys.
  *
@@ -15198,40 +11704,6 @@ export declare function tableHasKeys(luaMap: LuaMap<AnyNotNil, unknown>, ...keys
 /** After taking damage, `EntityPlayer.SamsonBerserkCharge` is incremented by this amount. */
 export declare const TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE = 10000;
 
-/**
- * This feature provides a way for end-users to get the `EntityPlayer` object for the other Tainted
- * Lazarus.
- */
-declare class TaintedLazarusPlayers extends Feature {
-    vConditionalFunc: () => boolean;
-    private postPlayerInit;
-    /**
-     * Indexes are the `PtrHash`, values are the `EntityPtr` of the *other* Lazarus.
-     *
-     * When starting a run, the `POST_PLAYER_INIT` callback will fire first for Dead Tainted Lazarus,
-     * then for Tainted Lazarus. When continuing a run, the `POST_PLAYER_INIT` callback will fire
-     * first for the character that is currently active. Thus, since the order of the characters is
-     * not certain, we insert each of their pointers into a queue, and then only populate the map when
-     * we have one Tainted Lazarus and one Dead Tainted Lazarus.
-     */
-    private checkDequeue;
-    /**
-     * Helper function to get the other version of Tainted Lazarus.
-     *
-     * - On Tainted Lazarus, returns the player object for Dead Tainted Lazarus.
-     * - On Dead Tainted Lazarus, returns the player object for Tainted Lazarus.
-     * - Returns undefined if player object retrieval failed for any reason.
-     *
-     * If you call the `EntityPlayer.Exists` method on the returned object, it will return false.
-     * However, you can still call the other methods like you normally would (e.g.
-     * `EntityPlayer.AddCollectible`).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.CHARACTER_HEALTH_CONVERSION`.
-     */
-    getTaintedLazarusSubPlayer(player: EntityPlayer): EntityPlayer | undefined;
-}
-
 export declare function tanh(x: number): number;
 
 /**
@@ -15353,21 +11825,6 @@ infer F,
 /** Helper type to convert a tuple to a union. */
 export declare type TupleToUnion<T extends unknown[]> = T[number];
 
-/**
- * Helper function to sort a two-dimensional array by the first element.
- *
- * For example:
- *
- * ```ts
- * const myArray = [[1, 2], [2, 3], [3, 4]];
- * myArray.sort(twoDimensionalSort);
- * ```
- *
- * From:
- * https://stackoverflow.com/questions/16096872/how-to-sort-2-dimensional-array-by-column-value
- */
-export declare function twoDimensionalSort<T>(array1: T[], array2: T[]): -1 | 0 | 1;
-
 /**
  * This is the number of draw coordinates that each heart spans on the UI in the upper left hand
  * corner.
@@ -15377,43 +11834,6 @@ export declare const UI_HEART_WIDTH = 12;
 /** Helper type to convert a union to an intersection. */
 export declare type UnionToIntersection<U> = (U extends U ? (u: U) => 0 : never) extends (i: infer I) => 0 ? Extract<I, U> : never;
 
-/**
- * Use this function to enable the custom callbacks and other optional features provided by
- * `isaacscript-common`.
- *
- * For example:
- *
- * ```ts
- * const modVanilla = RegisterMod("My Mod", 1);
- * const mod = upgradeMod(modVanilla);
- *
- * // Subscribe to vanilla callbacks.
- * mod.AddCallback(ModCallback.POST_UPDATE, postUpdate);
- *
- * // Subscribe to custom callbacks.
- * mod.AddCallbackCustom(ModCallbackCustom.POST_ITEM_PICKUP, postItemPickup);
- * ```
- *
- * @param modVanilla The mod object returned by the `RegisterMod` function.
- * @param features Optional. An array containing the optional standard library features that you
- *                 want to enable, if any. Default is an empty array.
- * @param customCallbacksUsed Optional. An array containing the custom callbacks that you will be
- *                            subscribing to after you upgrade your mod. Specifying this will
- *                            immediately initialize the callbacks (as opposed to lazy-initializing
- *                            them when you first subscribe to the callback). This is only necessary
- *                            if you the order of callback firing is important for your mod. (For
- *                            example, you may want the `POST_NEW_ROOM` part of the
- *                            `POST_GRID_ENTITY_INIT` callback to fire before your own
- *                            `POST_NEW_ROOM` callbacks.)
- * @param debug Optional. Whether to log additional output when a callback is fired. Default is
- *              false.
- * @param timeThreshold Optional. If provided, will only log callbacks that take longer than the
- *                      specified number of seconds (if the "--luadebug" launch flag is turned on)
- *                      or milliseconds (if the "--luadebug" launch flag is turned off).
- * @returns The upgraded mod object.
- */
-export declare function upgradeMod<T extends readonly ISCFeature[] = never[]>(modVanilla: Mod, features?: ISCFeatureTuple<T>, customCallbacksUsed?: ModCallbackCustom[] | readonly ModCallbackCustom[], debug?: boolean, timeThreshold?: float): ModUpgraded<T>;
-
 /** Helper type to match all of the uppercase keys of an object. */
 export declare type UppercaseKeys<T> = StartsWithUppercase<keyof T>;