isaacscript-common 21.5.0 → 21.5.1

package/dist/{index.d.ts → index.rollup.d.ts}

@@ -1144,6 +1144,22 @@ 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.
  *
@@ -1152,6 +1168,32 @@ export declare function characterGetsBlackHeartFromEternalHeart(character: Playe
  */
 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.
  *
@@ -1303,6 +1345,21 @@ 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;
 
@@ -1480,6 +1537,356 @@ 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(priority: CallbackPriority | int, 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.
@@ -1564,6 +1971,56 @@ 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.)
@@ -2015,6 +2472,454 @@ 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.
@@ -2218,6 +3123,45 @@ 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).
@@ -2278,8 +3222,130 @@ export declare function directionToShootAction(direction: Direction): ButtonActi
 
 export declare function directionToVector(direction: Direction): Readonly<Vector>;
 
-/** 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;
+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;
 
 /**
  * Helper function to check if one or more matching entities exist in the current room. It uses the
@@ -2625,6 +3691,21 @@ 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.
@@ -2642,12 +3723,110 @@ declare type ErrorIsaacAPIClassIsNotSerializable = "Error: Isaac API classes (su
  */
 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;
 
 /**
@@ -2680,6 +3859,8 @@ 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).
  *
@@ -2746,6 +3927,30 @@ 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.
  *
@@ -2769,6 +3974,17 @@ 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. */
@@ -2790,6 +4006,77 @@ 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.
@@ -5481,6 +6768,20 @@ 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.
  *
@@ -5510,6 +6811,47 @@ 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.
  *
@@ -6076,6 +7418,79 @@ 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`).
  *
@@ -6813,6 +8228,61 @@ 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.
@@ -9338,120 +10808,906 @@ export declare enum ModCallbackCustom {
 }
 
 /**
- * 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.
+ * 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).
  *
- * 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.)
+ * 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.
  */
-export declare class ModFeature {
-    private mod;
+declare class ModdedElementDetection extends Feature {
+    private atLeastOneCallbackFired;
+    private postPlayerInit;
+    private errorIfNoCallbacksFired;
     /**
-     * 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.
+     * Returns the first modded collectible type, or undefined if there are no modded collectibles.
      *
-     * 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).
+     * 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).
      *
-     * 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.
+     * 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.
      *
-     * 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.
+     * Equal to `itemConfig.GetCollectibles().Size - 1`. (`Size` includes invalid collectibles, like
+     * 666. We subtract one to account for `CollectibleType.NULL`.)
      *
-     * The function has the following signature:
+     * 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).
      *
-     * ```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;
-     * ```
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
-    protected shouldCallbackMethodsFire: (<T extends boolean>(vanilla: T, modCallback: T extends true ? ModCallback : ModCallbackCustom, ...callbackArgs: unknown[]) => boolean) | null;
+    getLastCollectibleType(): CollectibleType;
     /**
-     * Whether or not the feature has registered its callbacks yet.
+     * Helper function to get an array that represents the all modded collectible types.
      *
-     * This will almost always be equal to true unless you explicitly passed `false` to the second
-     * argument of the constructor.
+     * 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).
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
-    initialized: boolean;
-    constructor(mod: ModUpgraded, init?: boolean);
+    getModdedCollectibleTypes(): CollectibleType[];
     /**
-     * Runs the `Mod.AddCallback` and `ModUpgraded.AddCallbackCustom` methods for all of the decorated
-     * callbacks.
+     * 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).
      *
-     * @param init Optional. Whether to initialize or uninitialize. Default is true.
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
-    init(init?: boolean): void;
+    getNumCollectibleTypes(): int;
     /**
-     * Runs the `Mod.RemoveCallback` and `ModUpgraded.RemoveCallbackCustom` methods for all of the
-     * decorated callbacks.
+     * Unlike vanilla collectible types, modded collectible types are always contiguous.
      *
-     * This is just an alias for `ModFeature.init(false)`.
+     * 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_DETECTION`.
      */
-    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;
+    getNumModdedCollectibleTypes(): int;
     /**
-     * Registers a function to be executed when an in-game event happens.
+     * Returns the first modded trinket type, or undefined if there are no modded trinkets.
      *
-     * 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.
+     * 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`.
      */
-    AddCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, ...args: AddCallbackParametersCustom[T]): void;
+    getFirstModdedTrinketType(): TrinketType | undefined;
     /**
-     * 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.
+     * 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`.
+     */
+    getLastTrinketType(): TrinketType;
+    /**
+     * 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.
+     *
+     * 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`.
+     */
+    getModdedTrinketTypes(): TrinketType[];
+    /**
+     * 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`.
+     */
+    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: ModUpgraded, 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 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;
+    /**
+     * 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;
+    /**
+     * 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.
      */
     AddPriorityCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, priority: CallbackPriority | int, ...args: AddCallbackParametersCustom[T]): void;
     /**
@@ -9490,6 +11746,22 @@ export declare class ModUpgraded implements Mod {
     private initOptionalFeature;
 }
 
+/**
+ * `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.
+ *
+ * This type is in the private directory because if it was exported, it would cause all of the
+ * internal feature classes to populate the auto-complete of end-user mods (which should never be
+ * directly imported by end-users).
+ */
+declare type ModUpgradedWithFeatures<T extends readonly ISCFeature[] = []> = ModUpgraded & ISCFeaturesToKeys<T>;
+
 export declare const MOVEMENT_ACTIONS_SET: ReadonlySet<ButtonAction>;
 
 /**
@@ -9604,6 +11876,23 @@ 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;
@@ -9691,6 +11980,8 @@ 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.
@@ -9711,6 +12002,76 @@ export declare function parseEntityID(entityID: string): [entityType: EntityType
  */
 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];
+}
+
 export declare type PickingUpItem = PickingUpItemNull | PickingUpItemCollectible | PickingUpItemTrinket;
 
 /** Part of `PickingUpItem`. */
@@ -9755,6 +12116,45 @@ 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>;
 
@@ -9776,6 +12176,53 @@ 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;
@@ -9839,6 +12286,62 @@ 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;
@@ -9856,12 +12359,268 @@ 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;
 
@@ -10563,6 +13322,24 @@ 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;
@@ -10598,6 +13375,57 @@ export declare function roomExists(roomGridIndex: int): boolean;
  */
 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
@@ -10622,6 +13450,151 @@ export declare function round(num: float, numDecimalPlaces?: number): float;
  */
 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;
+}
+
 /**
  * Run the suite of tests that prove that the "merge" function works properly.
  *
@@ -10629,6 +13602,21 @@ export declare function runDeepCopyTests(): void;
  */
 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.
@@ -10668,6 +13656,241 @@ 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;
 
 /**
@@ -11133,6 +14356,41 @@ 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.
  *
@@ -11158,6 +14416,28 @@ 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 {
     /**
@@ -11177,6 +14457,34 @@ 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
@@ -11335,6 +14643,54 @@ 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.
  *
@@ -11526,6 +14882,103 @@ 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;
 
@@ -11606,6 +15059,55 @@ 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
@@ -11614,6 +15116,19 @@ export declare function spriteEquals(sprite1: Sprite, sprite2: Sprite, layerID:
  */
 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;
 
@@ -11693,6 +15208,16 @@ 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.
  *
@@ -11704,6 +15229,40 @@ 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;
 
 /**
@@ -11834,6 +15393,36 @@ 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 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.
+ * @beta A dummy field used to hide this function from `api-extractor`.
+ */
+export declare function upgradeMod<T extends readonly ISCFeature[] = never[]>(modVanilla: Mod, features?: ISCFeatureTuple<T>, debug?: boolean, timeThreshold?: float): ModUpgradedWithFeatures<T>;
+
 /** Helper type to match all of the uppercase keys of an object. */
 export declare type UppercaseKeys<T> = StartsWithUppercase<keyof T>;