isaacscript-common 14.0.0 → 14.1.0

package/dist/index.d.ts

@@ -208,22 +208,168 @@ declare interface AddCallbackParametersCustom2 {
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
+    [ModCallbackCustom2.POST_CUSTOM_REVIVE]: [
+    callback: (player: EntityPlayer, revivalType: int) => void,
+    revivalType?: int
+    ];
+    [ModCallbackCustom2.POST_DICE_ROOM_ACTIVATED]: [
+    callback: (player: EntityPlayer, diceFloorSubType: DiceFloorSubType) => void,
+    diceFloorSubType?: DiceFloorSubType
+    ];
+    [ModCallbackCustom2.POST_DOOR_RENDER]: [
+    callback: (door: GridEntityDoor) => void,
+    doorVariant?: DoorVariant
+    ];
+    [ModCallbackCustom2.POST_DOOR_UPDATE]: [
+    callback: (door: GridEntityDoor) => void,
+    doorVariant?: DoorVariant
+    ];
+    [ModCallbackCustom2.POST_EFFECT_INIT_LATE]: [
+    callback: (effect: EntityEffect) => void,
+    effectVariant?: EffectVariant
+    ];
+    [ModCallbackCustom2.POST_EFFECT_STATE_CHANGED]: [
+    callback: (effect: EntityEffect, previousState: int, currentState: int) => void,
+    effectVariant?: EffectVariant
+    ];
+    [ModCallbackCustom2.POST_ESAU_JR]: [callback: (player: EntityPlayer) => void];
+    [ModCallbackCustom2.POST_FAMILIAR_INIT_LATE]: [
+    callback: (familiar: EntityFamiliar) => void,
+    familiarVariant?: FamiliarVariant
+    ];
+    [ModCallbackCustom2.POST_FAMILIAR_STATE_CHANGED]: [
+    callback: (familiar: EntityFamiliar, previousState: int, currentState: int) => void,
+    familiarVariant?: FamiliarVariant
+    ];
+    [ModCallbackCustom2.POST_FIRST_ESAU_JR]: [
+    callback: (player: EntityPlayer) => void
+    ];
+    [ModCallbackCustom2.POST_FIRST_FLIP]: [
+    callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void
+    ];
+    [ModCallbackCustom2.POST_FLIP]: [
+    callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void
+    ];
+    [ModCallbackCustom2.POST_GAME_STARTED_REORDERED]: [
+    callback: (isContinued: boolean) => void
+    ];
+    [ModCallbackCustom2.POST_GAME_STARTED_REORDERED_LAST]: [
+    callback: (isContinued: boolean) => void
+    ];
+    [ModCallbackCustom2.POST_GREED_MODE_WAVE]: [
+    callback: (oldWave: int, newWave: int) => void
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_BROKEN]: [
+    callback: (gridEntity: GridEntity) => void,
+    gridEntityType?: GridEntityType,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_COLLISION]: [
+    callback: (gridEntity: GridEntity, entity: Entity) => void,
+    gridEntityType?: GridEntityType,
+    gridEntityVariant?: int,
+    entityType?: EntityType,
+    entityVariant?: int
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_BROKEN]: [
+    callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
+    gridEntityTypeCustom?: GridEntityType
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_COLLISION]: [
+    callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType, entity: Entity) => void,
+    gridEntityTypeCustom?: GridEntityType,
+    entityType?: EntityType,
+    entityVariant?: int
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_INIT]: [
+    callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
+    gridEntityTypeCustom?: GridEntityType
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_REMOVE]: [
+    callback: (gridIndex: int, gridEntityTypeCustom: GridEntityType) => void,
+    gridEntityTypeCustom?: GridEntityType
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED]: [
+    callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType, oldState: int, newState: int) => void,
+    gridEntityTypeCustom?: GridEntityType
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_UPDATE]: [
+    callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
+    gridEntityTypeCustom?: GridEntityType
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_INIT]: [
+    callback: (gridEntity: GridEntity) => void,
+    gridEntityType?: GridEntityType,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_REMOVE]: [
+    callback: (gridIndex: int, gridEntityType: GridEntityType, variant: int) => void,
+    gridEntityType?: GridEntityType,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_STATE_CHANGED]: [
+    callback: (gridEntity: GridEntity, oldState: int, newState: int) => void,
+    gridEntityType?: GridEntityType,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_UPDATE]: [
+    callback: (gridEntity: GridEntity) => void,
+    gridEntityType?: GridEntityType,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_HOLY_MANTLE_REMOVED]: [
+    callback: (player: EntityPlayer, oldNumHolyMantles: int, newNumHolyMantles: int) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
+    [ModCallbackCustom2.POST_NEW_LEVEL_REORDERED]: [callback: () => void];
     [ModCallbackCustom2.POST_KNIFE_INIT_LATE]: [
     callback: (knife: EntityKnife) => void,
     knifeVariant?: KnifeVariant
     ];
     [ModCallbackCustom2.POST_NEW_ROOM_EARLY]: [callback: () => void];
+    [ModCallbackCustom2.POST_NEW_ROOM_REORDERED]: [callback: () => void];
+    [ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED]: [
+    callback: (player: EntityPlayer) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
     [ModCallbackCustom2.POST_PIT_RENDER]: [
     callback: (pit: GridEntityPit) => void,
     pitVariant?: PitVariant
     ];
+    [ModCallbackCustom2.POST_PLAYER_FATAL_DAMAGE]: [
+    callback: (player: EntityPlayer, amount: float, damageFlags: BitFlags<DamageFlag>, source: EntityRef, countdownFrames: int) => boolean | undefined,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
+    [ModCallbackCustom2.POST_PLAYER_RENDER_REORDERED]: [
+    callback: (player: EntityPlayer) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
+    [ModCallbackCustom2.POST_PLAYER_UPDATE_REORDERED]: [
+    callback: (player: EntityPlayer) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
     [ModCallbackCustom2.POST_ROOM_CLEAR_CHANGED]: [
     callback: (roomClear: boolean) => void,
     roomClear?: boolean
     ];
     [ModCallbackCustom2.POST_SPIKES_RENDER]: [
     callback: (spikes: GridEntitySpikes) => void,
-    gridEntityVariant?: int
+    variant?: int
+    ];
+    [ModCallbackCustom2.PRE_BERSERK_DEATH]: [
+    callback: (player: EntityPlayer) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
+    [ModCallbackCustom2.PRE_CUSTOM_REVIVE]: [
+    callback: (player: EntityPlayer) => int | undefined,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
     ];
 }
 
@@ -239,14 +385,14 @@ declare interface AddCallbackParametersCustom2 {
  * - AAA Battery
  *
  * @param player The player to grant the charges to.
- * @param activeSlot The slot to grant the charges to.
+ * @param activeSlot Optional. The slot to grant the charges to. Default is `ActiveSlot.PRIMARY`.
  * @param numCharges Optional. The amount of charges to grant. Default is 1.
  * @param playSoundEffect Optional. Whether to play a charge-related sound effect. Default is true.
  * @returns The amount of charges that were actually granted. For example, if the active item was
  *          only one away from a full charge, but the `numCharges` provided to this function was 2,
  *          then this function would return 1.
  */
-export declare function addCharge(player: EntityPlayer, activeSlot: ActiveSlot, numCharges?: number, playSoundEffect?: boolean): int;
+export declare function addCharge(player: EntityPlayer, activeSlot?: ActiveSlot, numCharges?: number, playSoundEffect?: boolean): int;
 
 export declare function addCollectibleCostume(player: EntityPlayer, collectibleType: CollectibleType): void;
 
@@ -335,13 +481,14 @@ export declare function addRoomClearCharges(bigRoomDoubleCharge?: boolean): void
  * - Not charging active items with `chargetype="special"`
  *
  * @param player The player to grant the charges to.
- * @param activeSlot The active item slot to grant the charges to.
+ * @param activeSlot Optional. The active item slot to grant the charges to. Default is
+ *                   `ActiveSlot.PRIMARY`.
  * @param bigRoomDoubleCharge Optional. If set to false, it will treat the current room as a 1x1
  *                            room for the purposes of calculating how much charge to grant. Default
  *                            is true.
  * @param playSoundEffect Optional. Whether to play a charge-related sound effect. Default is true.
  */
-export declare function addRoomClearChargeToSlot(player: EntityPlayer, activeSlot: ActiveSlot, bigRoomDoubleCharge?: boolean, playSoundEffect?: boolean): void;
+export declare function addRoomClearChargeToSlot(player: EntityPlayer, activeSlot?: ActiveSlot, bigRoomDoubleCharge?: boolean, playSoundEffect?: boolean): void;
 
 /**
  * Helper function to add a `DisplayFlag` to a particular room's minimap display flags (e.g. whether
@@ -386,6 +533,18 @@ export declare const ALL_DISPLAY_FLAGS: BitFlags<number & {
     readonly __displayFlagBrand: symbol;
 }>;
 
+export declare type AllButFirst<T extends unknown[]> = T extends [
+unknown,
+...infer Tail
+] ? Tail : unknown[];
+
+declare type AllButFirst_2<T extends unknown[]> = T extends [
+unknown,
+...infer Tail
+] ? Tail : unknown[];
+
+export declare type AllButLast<T extends unknown[]> = T extends [...infer Head, unknown] ? Head : unknown[];
+
 /** This is used by the `POST_AMBUSH_STARTED` and `POST_AMBUSH_FINISHED` custom callbacks. */
 export declare enum AmbushType {
     CHALLENGE_ROOM = 0,
@@ -665,6 +824,37 @@ export declare function calculateStageType(stage: LevelStage): StageType;
  */
 export declare function calculateStageTypeRepentance(stage: LevelStage): StageType;
 
+/**
+ * A decorator function that signifies that the decorated class method should be automatically
+ * registered with `Mod.AddCallback`.
+ */
+export declare function Callback<T extends ModCallback>(modCallback: T, ...optionalArgs: AllButFirst<AddCallbackParameters[T]>): <Class extends ModFeature, Fn extends AddCallbackParameters[T][0]>(target: Class, propertyKey: string, _descriptor: TypedPropertyDescriptor<Fn>) => void;
+
+/**
+ * A decorator function that signifies that the decorated class method should be automatically
+ * registered with `ModUpgraded.AddCallbackCustom`.
+ */
+export declare function CallbackCustom<T extends ModCallbackCustom2>(modCallbackCustom: T, ...optionalArgs: AllButFirst<AddCallbackParametersCustom2[T]>): <Class extends {
+    mod: ModUpgraded;
+}>(target: Class, propertyKey: string) => void;
+
+declare type CallbackSignatureGridEntity = ((gridEntity: GridEntity) => void) | ((gridEntity: GridEntity, oldState: int, newState: int) => void);
+
+declare type CallbackSignatureGridEntityCustom = ((gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void) | ((gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType, oldState: int, newState: int) => void);
+
+declare type CallbackSignaturePlayer = ((player: EntityPlayer) => void) | ((player: EntityPlayer) => int | undefined) | ((player: EntityPlayer, amount: float, damageFlags: BitFlags<DamageFlag>, source: EntityRef, countdownFrames: int) => boolean | undefined);
+
+declare type CallbackSignatureRevive = (player: EntityPlayer, revivalType: int) => void;
+
+/**
+ * A mapping of the callback enum to the associated callback functions (and optional arguments).
+ * This is so that the respective callback functions can be added/removed on demand as subscribers
+ * get added/removed.
+ */
+declare type CallbackTuple = {
+    [K in ModCallback]: [K, AddCallbackParameters[K]];
+}[ModCallback];
+
 /**
  * Helper function to see if the provided player can pick up an eternal heart. (If a player already
  * has an eternal heart and full heart containers, they are not able to pick up any additional
@@ -940,6 +1130,8 @@ export declare function combineArrays<T>(...arrays: Array<T[] | readonly T[]>):
  */
 export declare function combineSets<T>(...sets: Array<Set<T> | ReadonlySet<T>>): Set<T>;
 
+export declare type Constructor = new (...args: any[]) => {};
+
 /**
  * Helper function to get the enum name for the specified `Controller` value. Note that this will
  * trim off the "BUTTON_" prefix.
@@ -1069,6 +1261,215 @@ export declare const CUSTOM_FLOOR_STAGE: LevelStage;
  */
 export declare const CUSTOM_FLOOR_STAGE_TYPE = StageType.WRATH_OF_THE_LAMB;
 
+/**
+ * The base class for a custom callback. Individual custom callbacks (and validation callbacks) will
+ * extend from this class.
+ */
+declare abstract class CustomCallback<T extends ModCallbackCustom2> extends Feature {
+    private subscriptions;
+    hasSubscriptions(): boolean;
+    add(...args: AddCallbackParametersCustom2[T]): void;
+    /**
+     * If the submitted function does not match any of the existing subscriptions, this method will do
+     * nothing.
+     */
+    remove(callback: AddCallbackParametersCustom2[T][0]): void;
+    fire: (...fireArgs: FireArgs<T>) => ReturnType<AddCallbackParametersCustom2[T][0]>;
+    /**
+     * This method needs to be overwritten for any callback that has optional filtration arguments.
+     */
+    protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
+}
+
+declare class CustomCallbackGridEntity<T extends ModCallbackCustomGridEntity> extends CustomCallback<T> {
+    protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
+}
+
+declare class CustomCallbackGridEntityCustom<T extends ModCallbackCustomGridEntityCustom> extends CustomCallback<T> {
+    protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
+}
+
+declare class CustomCallbackPlayer<T extends ModCallbackCustomPlayer> extends CustomCallback<T> {
+    protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
+}
+
+declare class CustomCallbackRevive<T extends ModCallbackCustomRevive> extends CustomCallback<T> {
+    protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
+}
+
+/**
+ * A mapping of the custom callback enum to the associated callback functions (and optional
+ * arguments). This is so that the respective callback functions can be added/removed on demand as
+ * subscribers get added/removed.
+ */
+declare type CustomCallbackTuple = {
+    [K in ModCallbackCustom2]: [K, AddCallbackParametersCustom2[K]];
+}[ModCallbackCustom2];
+
+declare class CustomGridEntities extends Feature {
+    v: {
+        level: {
+            /** Indexed by room list index and grid index. */
+            customGridEntities: DefaultMap<number, Map<number, GridEntityCustomData>, []>;
+        };
+        room: {
+            genericPropPtrHashes: Set<PtrHash>;
+            manuallyUsingShovel: boolean;
+        };
+    };
+    private runInNFrames;
+    constructor(runInNFrames: 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.)
+     *
+     * 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`.
+     * 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.
+     *
+     * @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.
+     */
+    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.
+     */
+    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.
+     */
+    isCustomGridEntity(gridEntityOrGridIndex: GridEntity | int): boolean;
+}
+
+declare class CustomRevive extends Feature {
+    v: {
+        run: {
+            state: CustomReviveState;
+            revivalType: number | null;
+            dyingPlayerIndex: PlayerIndex | null;
+        };
+    };
+    private preCustomRevive;
+    private postCustomRevive;
+    constructor(preCustomRevive: PreCustomRevive, postCustomRevive: PostCustomRevive);
+    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.
@@ -2199,6 +2600,21 @@ declare type ErrorCustomClassNotSerializable = "Error: Custom classes with one o
 
 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.
@@ -2222,6 +2638,22 @@ export declare function every<T>(array: T[], func: (value: T, index: number, arr
  */
 export declare type FactoryFunction<V, Args extends unknown[]> = (...args: Args) => V;
 
+/**
+ * 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 class Feature {
+    initialized: boolean;
+    v?: SaveData;
+    featuresUsed?: ISCFeature[];
+    callbacksUsed?: CallbackTuple[];
+    customCallbacksUsed?: CustomCallbackTuple[];
+    exportedMethods: string[];
+}
+
 export declare function fillLevelWithRedRooms(): void;
 
 /**
@@ -2254,6 +2686,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 ModCallbackCustom2> = Parameters<AddCallbackParametersCustom2[T][0]>;
+
 /**
  * Helper function to make an NPC fire one or more projectiles. Returns the fired projectile(s).
  *
@@ -2318,6 +2752,19 @@ 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;
+}
+
 /**
  * An object containing all 7 vanilla fonts that are pre-loaded and ready to use.
  *
@@ -2371,6 +2818,11 @@ export declare function forgottenSwitch(): void;
 
 declare type FunctionIsNotSerializable = "Error: Functions are not serializable. For more information, see: https://isaacscript.github.io/main/gotchas#functions-are-not-serializable";
 
+export declare type FunctionTuple = [
+name: string,
+func: (...args: unknown[]) => unknown
+];
+
 /**
  * A cached version of the class returned from the `Game()` constructor.
  *
@@ -2384,6 +2836,27 @@ export declare const game: Game;
 /** Game frames are what is returned by the `Game.GetFrameCount` method. */
 export declare const GAME_FRAMES_PER_SECOND = 30;
 
+declare class GameReorderedCallbacks extends Feature {
+    private currentStage;
+    private currentStageType;
+    private usedGlowingHourGlass;
+    private forceNewLevel;
+    private forceNewRoom;
+    private postGameStartedReordered;
+    private postNewLevelReordered;
+    private postNewRoomReordered;
+    private postGameStartedReorderedLast;
+    constructor(postGameStartedReordered: PostGameStartedReordered, postNewLevelReordered: PostNewLevelReordered, postNewRoomReordered: PostNewRoomReordered, postGameStartedReorderedLast: PostGameStartedReorderedLast);
+    private useItemGlowingHourGlass;
+    private postGameStarted;
+    private postNewLevel;
+    private postNewRoom;
+    private recordCurrentStage;
+    forceNewLevelCallback(): void;
+    forceNewRoomCallback(): void;
+    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.
@@ -2716,8 +3189,11 @@ export declare function getCharacters(): PlayerType[];
  * This function accounts for The Battery. For example, if the player has 2/6 charges on a D6, this
  * function will return 10 (because there are 4 charges remaining on the base charge and 6 charges
  * remaining on The Battery charge).
+ *
+ * @param player The player to get the charges from.
+ * @param activeSlot Optional. The slot to get the charges from. Default is `ActiveSlot.PRIMARY`.
  */
-export declare function getChargesAwayFromMax(player: EntityPlayer, activeSlot: ActiveSlot): int;
+export declare function getChargesAwayFromMax(player: EntityPlayer, activeSlot?: ActiveSlot): int;
 
 /**
  * Helper function to get an array of equidistant points on the circumference around a circle.
@@ -4214,6 +4690,12 @@ export declare function getPlayerFromEntity(entity: Entity): EntityPlayer | unde
  */
 export declare function getPlayerFromIndex(playerIndex: PlayerIndex): EntityPlayer | undefined;
 
+/**
+ * Helper function to get an `EntityPlayer` object from an `EntityPtr`. Returns undefined if the
+ * entity has gone out of scope or if the associated entity is not a player.
+ */
+export declare function getPlayerFromPtr(entityPtr: EntityPtr): EntityPlayer | undefined;
+
 /**
  * Helper function to get an object representing the player's health. You can use this in
  * combination with the `setPlayerHealth` function to restore the player's health back to a certain
@@ -5296,8 +5778,11 @@ export declare function getTopLeftWallGridIndex(): int;
  * Helper function to get the combined normal charge and the battery charge for the player's active
  * item. This is useful because you have to add these two values together when setting the active
  * charge.
+ *
+ * @param player The player to get the charges from.
+ * @param activeSlot Optional. The slot to get the charges from. Default is `ActiveSlot.PRIMARY`.
  */
-export declare function getTotalCharge(player: EntityPlayer, activeSlot: ActiveSlot): int;
+export declare function getTotalCharge(player: EntityPlayer, activeSlot?: ActiveSlot): int;
 
 /**
  * Returns the total number of collectibles amongst all players. For example, if player 1 has 1 Sad
@@ -5419,14 +5904,24 @@ export declare function getTrinketsForCacheFlag(cacheFlag: CacheFlag): ReadonlyS
 export declare function getTrinketTypes(): TrinketType[];
 
 /**
- * Helper function to get the name of a TypeScriptToLua class. TSTL classes are Lua tables created
- * with the `__TS__Class` Lua function from the TSTL lualib. Their name is contained within
- * "constructor.name" metatable key.
+ * Helper function to get the constructor from an instantiated TypeScriptToLua class, which is
+ * located on the metatable.
+ *
+ * Returns undefined if passed a non-table or if the provided table does not have a metatable.
+ */
+export declare function getTSTLClassConstructor(object: unknown): TSTLClassMetatable["constructor"] | undefined;
+
+export declare function getTSTLClassMethods(object: unknown): FunctionTuple[];
+
+/**
+ * Helper function to get the name of a TypeScriptToLua class from the instantiated class object.
+ *
+ * TSTL classes are Lua tables created with the `__TS__Class` Lua function from the TSTL lualib.
+ * Their name is contained within "constructor.name" metatable key.
  *
  * For example, a `Map` class is has a name of "Map".
  *
- * Returns undefined if the object is not a table or if the aforementioned metatable key does not
- * exist.
+ * Returns undefined if passed a non-table or if the provided table does not have a metatable.
  */
 export declare function getTSTLClassName(object: unknown): string | undefined;
 
@@ -5514,6 +6009,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.
  *
@@ -5533,6 +6042,39 @@ export declare interface GridEntityCustomData {
     defaultAnimation?: string;
 }
 
+declare class GridEntityDetection 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;
+}
+
+declare type GridEntityTuple = [
+gridEntityType: GridEntityType,
+variant: int,
+state: int
+];
+
 /**
  * Helper function to convert a grid index to a grid position.
  *
@@ -5548,6 +6090,32 @@ export declare function gridIndexToGridPosition(gridIndex: int, roomShape: RoomS
  */
 export declare function gridPositionToWorldPosition(gridPosition: Vector): Vector;
 
+/**
+ * A helper type to ensure that an object contains a key for every enum member. Use this with `as
+ * const` and `satisfies` to prevent narrowing the type of the object.
+ *
+ * For example:
+ *
+ * ```ts
+ * enum MyEnum {
+ *   Value1,
+ *   Value2,
+ *   Value3,
+ * }
+ *
+ * const MyEnumToString = {
+ *   [MyEnum.Value1]: "foo",
+ *   [MyEnum.Value2]: "bar",
+ *   [MyEnum.Value3]: "baz",
+ * } as const satisfies HasAllEnumKeys<MyEnum>;
+ *
+ * const value = MyEnumToString[MyEnum.Value2];
+ * ```
+ */
+export declare type HasAllEnumKeys<T extends string | number> = {
+    readonly [key in T]: unknown;
+};
+
 /**
  * Helper function to see if a particular entity has armor. In this context, armor refers to the
  * damage scaling mechanic. For example, Ultra Greed has armor, but a Gaper does not.
@@ -5826,6 +6394,17 @@ export declare function inSecretShop(): boolean;
  */
 export declare function inStartingRoom(): boolean;
 
+/**
+ * Used for `setInterval` functions.
+ *
+ * The return value is whether or not to continue the function from firing.
+ */
+declare type IntervalFunctionTuple = [
+frameCountToFire: int,
+func: () => boolean,
+numIntervalFrames: int
+];
+
 /**
  * Helper function to return an array of integers with the specified range, inclusive on both ends.
  * (The "i" stands for inclusive.)
@@ -5862,41 +6441,6 @@ declare interface IsaacAPIClassTypeToType {
     [CopyableIsaacAPIClassType.VECTOR]: Vector;
 }
 
-export declare enum IsaacScriptCommonFeature {
-    CHARACTER_HEALTH_CONVERSION = "characterHealthConversion",
-    CHARACTER_STATS = "characterStats",
-    COLLECTIBLE_ITEM_POOL_TYPE = "collectibleItemPoolType",
-    CUSTOM_GRID_ENTITY = "customGridEntity",
-    CUSTOM_HOTKEYS = "customHotkeys",
-    CUSTOM_PICKUP = "customPickup",
-    CUSTOM_STAGE = "customStage",
-    CUSTOM_TRAPDOOR = "customTrapdoor",
-    DEBUG_DISPLAY = "debugDisplay",
-    DEPLOY_JSON_ROOM = "deployJSONRoom",
-    DISABLE_ALL_SOUND = "displayAllSound",
-    DISABLE_INPUTS = "disableInputs",
-    FADE_IN_REMOVER = "fadeInRemover",
-    FAST_RESET = "fastReset",
-    FIRST_LAST = "firstLast",
-    FORGOTTEN_SWITCH = "forgottenSwitch",
-    EXTRA_CONSOLE_COMMANDS = "extraConsoleCommands",
-    PAUSE = "pause",
-    PERSISTENT_ENTITIES = "persistentEntities",
-    PICKUP_INDEX = "pickupIndex",
-    PLAYER_INVENTORY = "playerInventory",
-    PONY_DETECTION = "ponyDetection",
-    PREVENT_CHILD_ENTITIES = "preventChildEntities",
-    PREVENT_COLLECTIBLE_ROTATION = "preventCollectibleRotation",
-    ROOM_CLEAR_FRAME = "roomClearFrame",
-    ROOM_HISTORY = "roomHistory",
-    RUN_IN_N_FRAMES = "runInNFrames",
-    RUN_NEXT_ROOM = "runNextRoom",
-    SAVE_DATA_MANAGER = "saveDataManager",
-    SIREN_HELPERS = "sirenHelpers",
-    STAGE_HISTORY = "stageHistory",
-    TAINTED_LAZARUS_PLAYERS = "taintedLazarusPlayers"
-}
-
 /** Iterates over all inputs to determine if a particular button is pressed (i.e. held down). */
 export declare function isActionPressedOnAnyInput(buttonAction: ButtonAction): boolean;
 
@@ -5909,9 +6453,22 @@ export declare function isActionTriggeredOnAnyInput(buttonAction: ButtonAction):
 /** Returns true if the item type in the item config is equal to `ItemType.ITEM_ACTIVE`. */
 export declare function isActiveCollectible(collectibleType: CollectibleType): boolean;
 
-export declare function isActiveSlotDoubleCharged(player: EntityPlayer, activeSlot: ActiveSlot): boolean;
+/**
+ * Helper function to check if a player's active item is "double charged", meaning that it has both
+ * a full normal charge and a full charge from The Battery.
+ *
+ * @param player The player to check.
+ * @param activeSlot Optional. The slot to check. Default is `ActiveSlot.PRIMARY`.
+ */
+export declare function isActiveSlotDoubleCharged(player: EntityPlayer, activeSlot?: ActiveSlot): boolean;
 
-export declare function isActiveSlotEmpty(player: EntityPlayer, activeSlot: ActiveSlot): boolean;
+/**
+ * Helper function to check if the active slot of a particular player is empty.
+ *
+ * @param player The player to check.
+ * @param activeSlot Optional. The active slot to check. Default is `ActiveSlot.PRIMARY`.
+ */
+export declare function isActiveSlotEmpty(player: EntityPlayer, activeSlot?: ActiveSlot): boolean;
 
 /**
  * Checks for specific NPCs that have "CanShutDoors" set to true naturally by the game, but should
@@ -6007,6 +6564,30 @@ export declare function isCardPickup(pickup: EntityPickup): pickup is EntityPick
 /** Returns whether or not the given card type matches the specified item config card type. */
 export declare function isCardType(cardType: CardType, itemConfigCardType: ItemConfigCardType): boolean;
 
+export declare enum ISCFeature {
+    CUSTOM_REVIVE = "CustomRevive",
+    ESAU_JR_DETECTION = "EsauJrDetection",
+    FLIP_DETECTION = "FlipDetection",
+    GRID_ENTITY_COLLISION_DETECTION = "GridEntityCollisionDetection",
+    GRID_ENTITY_DETECTION = "GridEntityDetection",
+    GAME_REORDERED_CALLBACKS = "GameReorderedCallbacks",
+    PLAYER_REORDERED_CALLBACKS = "PlayerReorderedCallbacks",
+    CUSTOM_GRID_ENTITIES = "CustomGridEntities",
+    RUN_IN_N_FRAMES = "runInNFrames"
+}
+
+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_DETECTION]: GridEntityDetection;
+    [ISCFeature.GAME_REORDERED_CALLBACKS]: GameReorderedCallbacks;
+    [ISCFeature.PLAYER_REORDERED_CALLBACKS]: PlayerReorderedCallbacks;
+    [ISCFeature.CUSTOM_GRID_ENTITIES]: CustomGridEntities;
+    [ISCFeature.RUN_IN_N_FRAMES]: RunInNFrames;
+}
+
 /**
  * Helper function to check if a player is a specific character (i.e. `PlayerType`).
  *
@@ -6246,6 +6827,12 @@ export declare function isGlitchedCollectible(pickup: EntityPickup): boolean;
 
 export declare function isGoldenTrinketType(trinketType: TrinketType): boolean;
 
+/**
+ * Helper function to check if the difficulty of the current run is equal to `Difficulty.GREED` or
+ * `Difficulty.GREEDIER`.
+ */
+export declare function isGreedMode(): boolean;
+
 /** Helper function to detect if a variable is of type `GridEntity`. */
 export declare function isGridEntity(variable: unknown): variable is GridEntity;
 
@@ -6620,6 +7207,9 @@ export declare function isSuitCard(cardType: CardType): boolean;
 
 export declare function isTable(variable: unknown): variable is LuaMap<AnyNotNil, unknown>;
 
+/** Helper function to check if a Lua table has 0 keys. */
+export declare function isTableEmpty(luaMap: LuaMap<AnyNotNil, unknown>): boolean;
+
 /** Helper function for detecting if a player is one of the Tainted characters. */
 export declare function isTainted(player: EntityPlayer): boolean;
 
@@ -6675,16 +7265,18 @@ export declare function isTrinket(pickup: EntityPickup): pickup is EntityPickupT
 /**
  * Helper function to determine if a given object is a TypeScriptToLua `Map`.
  *
- * It is not reliable to use the `instanceof` operator to determine this because each Lua module has
- * their own copies of the entire lualib and thus their own instantiated version of a `Map`.
+ * It is not reliable to use the `instanceof` operator to determine this because each Lua module
+ * might have their own copy of the entire lualib and thus their own instantiated version of a
+ * `Map`.
  */
 export declare function isTSTLMap(object: unknown): object is Map<AnyNotNil, unknown>;
 
 /**
  * Helper function to determine if a given object is a TypeScriptToLua `Set`.
  *
- * It is not reliable to use the `instanceof` operator to determine this because each Lua module has
- * their own copies of the entire lualib and thus their own instantiated version of a `Set`.
+ * It is not reliable to use the `instanceof` operator to determine this because each Lua module
+ * might have their own copy of the entire lualib and thus their own instantiated version of a
+ * `Set`.
  */
 export declare function isTSTLSet(object: unknown): object is Set<AnyNotNil>;
 
@@ -6930,6 +7522,8 @@ export declare function kColorEquals(kColor1: KColor, kColor2: KColor): boolean;
  */
 export declare function keyboardToString(keyboard: Keyboard, uppercase: boolean): string | undefined;
 
+declare type KeysToScrubFromModClass = keyof Feature | LowercaseKeys<ModUpgraded>;
+
 /**
  * For `EntityType.EFFECT` (1000), `EffectVariant.LADDER` (8).
  *
@@ -7147,6 +7741,8 @@ export declare function logUserdata(userdata: unknown): void;
 
 export declare function logVector(vector: Vector, round?: boolean): void;
 
+export declare type LowercaseKeys<T> = StartsWithLowercase<keyof T>;
+
 /**
  * Helper function for non-TypeScript users to convert all of the elements in an array to something
  * else.
@@ -7211,6 +7807,20 @@ export declare function mapSetHash<V>(map: Map<PtrHash, V>, entity: Entity, valu
  */
 export declare function mapSetPlayer<V>(map: Map<PlayerIndex, V>, player: EntityPlayer, value: V): void;
 
+/**
+ * A helper type used to get the matching `ModCallbackCustom` enum values that match the provided
+ * callback function signature.
+ *
+ * "T extends T" is necessary because of distributive conditional types:
+ * https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
+ *
+ * "extends Parameters<FuncSignature>" is necessary because "() => void" will match "(arg1: number)
+ * => void", since in JavaScript, functions ignore extra arguments.
+ *
+ * "extends ReturnType<FuncSignature>" is necessary because "() => void" will match "() => number".
+ */
+declare type MatchingCallbackCustom<FuncSignature extends (...args: any[]) => unknown, T extends ModCallbackCustom2 = ModCallbackCustom2> = T extends T ? AddCallbackParametersCustom2[T][0] extends FuncSignature ? Parameters<AddCallbackParametersCustom2[T][0]> extends Parameters<FuncSignature> ? ReturnType<AddCallbackParametersCustom2[T][0]> extends ReturnType<FuncSignature> ? T : never : never : never : never;
+
 /**
  * The floor is represented by a 13x13 grid. Room indexes start at 0. The first row is represented
  * by grid indexes from 0 to 12. The second row is represented by grid indexes from 13 to 25, and so
@@ -8788,11 +9398,65 @@ export declare enum ModCallbackCustom2 {
     POST_COLLECTIBLE_EMPTY = 5,
     POST_COLLECTIBLE_INIT_FIRST = 6,
     POST_CURSED_TELEPORT = 7,
-    POST_KNIFE_INIT_LATE = 8,
-    POST_NEW_ROOM_EARLY = 9,
-    POST_PIT_RENDER = 10,
-    POST_ROOM_CLEAR_CHANGED = 11,
-    POST_SPIKES_RENDER = 12
+    POST_CUSTOM_REVIVE = 8,
+    POST_DICE_ROOM_ACTIVATED = 9,
+    POST_DOOR_RENDER = 10,
+    POST_DOOR_UPDATE = 11,
+    POST_EFFECT_INIT_LATE = 12,
+    POST_EFFECT_STATE_CHANGED = 13,
+    POST_ESAU_JR = 14,
+    POST_FAMILIAR_INIT_LATE = 15,
+    POST_FAMILIAR_STATE_CHANGED = 16,
+    POST_FIRST_ESAU_JR = 17,
+    POST_FIRST_FLIP = 18,
+    POST_FLIP = 19,
+    POST_GAME_STARTED_REORDERED = 20,
+    POST_GAME_STARTED_REORDERED_LAST = 21,
+    POST_GREED_MODE_WAVE = 22,
+    POST_GRID_ENTITY_BROKEN = 23,
+    POST_GRID_ENTITY_COLLISION = 24,
+    POST_GRID_ENTITY_CUSTOM_BROKEN = 25,
+    POST_GRID_ENTITY_CUSTOM_COLLISION = 26,
+    POST_GRID_ENTITY_CUSTOM_INIT = 27,
+    POST_GRID_ENTITY_CUSTOM_REMOVE = 28,
+    POST_GRID_ENTITY_CUSTOM_STATE_CHANGED = 29,
+    POST_GRID_ENTITY_CUSTOM_UPDATE = 30,
+    POST_GRID_ENTITY_INIT = 31,
+    POST_GRID_ENTITY_REMOVE = 32,
+    POST_GRID_ENTITY_STATE_CHANGED = 33,
+    POST_GRID_ENTITY_UPDATE = 34,
+    POST_HOLY_MANTLE_REMOVED = 35,
+    POST_KNIFE_INIT_LATE = 36,
+    POST_NEW_LEVEL_REORDERED = 37,
+    POST_NEW_ROOM_EARLY = 38,
+    POST_NEW_ROOM_REORDERED = 39,
+    POST_PEFFECT_UPDATE_REORDERED = 40,
+    POST_PIT_RENDER = 41,
+    POST_PLAYER_FATAL_DAMAGE = 42,
+    POST_PLAYER_RENDER_REORDERED = 43,
+    POST_PLAYER_UPDATE_REORDERED = 44,
+    POST_ROOM_CLEAR_CHANGED = 45,
+    POST_SPIKES_RENDER = 46,
+    PRE_BERSERK_DEATH = 47,
+    PRE_CUSTOM_REVIVE = 48
+}
+
+declare type ModCallbackCustomGridEntity = MatchingCallbackCustom<CallbackSignatureGridEntity>;
+
+declare type ModCallbackCustomGridEntityCustom = MatchingCallbackCustom<CallbackSignatureGridEntityCustom>;
+
+declare type ModCallbackCustomPlayer = MatchingCallbackCustom<CallbackSignaturePlayer>;
+
+declare type ModCallbackCustomRevive = MatchingCallbackCustom<CallbackSignatureRevive>;
+
+/**
+ * A helper class for a mod that wants to represent its individual features as classes. This is
+ * useful if you are using decorators to represent class methods that should be automatically
+ * subscribed to callbacks.
+ */
+export declare class ModFeature {
+    private mod;
+    constructor(mod: ModUpgraded);
 }
 
 /**
@@ -8804,8 +9468,8 @@ export declare enum ModCallbackCustom2 {
  */
 export declare class ModUpgraded implements Mod {
     /**
-     * The vanilla mod object stores the name of the mod for some reason. (It is never used or
-     * referenced. (We match the casing of the vanilla variable.)
+     * The `RegisterMod` function stores the name of the mod on the mod object for some reason. (It is
+     * never used or referenced.)
      */
     Name: string;
     /** We store a copy of the original mod object so that we can re-implement its functions. */
@@ -8814,25 +9478,66 @@ export declare class ModUpgraded implements Mod {
     private timeThreshold;
     private callbacks;
     constructor(mod: Mod, debug: boolean, timeThreshold?: float);
+    /**
+     * Registers a function to be executed when an in-game event happens. For example, the
+     * `ModCallback.POST_UPDATE` event corresponds to being executed once at the end of every game
+     * logic frame.
+     */
     AddCallback<T extends ModCallback>(modCallback: T, ...args: AddCallbackParameters[T]): void;
+    /** Returns whether or not a corresponding "save#.dat" file exists for the current mod. */
     HasData(): boolean;
+    /**
+     * Returns a string containing all of the data inside of the corresponding "save#.dat" file for
+     * this mod.
+     */
     LoadData(): string;
     /**
-     * This method does not care about the tertiary argument. Regardless of the conditions of how you
-     * registered the callback, it will be removed.
+     * Unregisters a function that was previously registered with the `AddCallback` method.
+     *
+     * This method does not care about the tertiary argument. In other words, regardless of the
+     * conditions of how you registered the callback, it will be removed.
      */
     RemoveCallback<T extends ModCallback>(modCallback: T, callback: AddCallbackParameters[T][0]): void;
+    /** Deletes the corresponding "save#.dat" file for this mod, if it exists. */
     RemoveData(): void;
+    /**
+     * Creates or updates the corresponding "save#.dat" file for this mod with the provided string.
+     */
     SaveData(data: string): void;
+    /**
+     * Registers a function to be executed when an in-game event happens. This method is specifically
+     * for events that are provided by the IsaacScript standard library. For example, the
+     * `ModCallbackCustom.POST_BOMB_EXPLODE` event corresponds to when a bomb explodes.
+     */
     AddCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, ...args: AddCallbackParametersCustom[T]): void;
+    /** Adds a callback in the new callback system format. This method is only temporary. */
     AddCallbackCustom2<T extends ModCallbackCustom2>(modCallbackCustom: T, ...args: AddCallbackParametersCustom2[T]): void;
     /**
-     * This method does not care about the tertiary argument. Regardless of the conditions of how you
-     * registered the callback, it will be removed.
+     * Unregisters a function that was previously registered with the `AddCallbackCustom` method.
+     *
+     * This method does not care about the tertiary argument. In other words, regardless of the
+     * conditions of how you registered the callback, it will be removed.
      */
-    RemoveCallbackCustom<T extends ModCallbackCustom>(modCallback: T, callback: AddCallbackParametersCustom[T][0]): void;
+    RemoveCallbackCustom<T extends ModCallbackCustom2>(modCallbackCustom: T, callback: AddCallbackParametersCustom2[T][0]): void;
+    /**
+     * This method should only be used by the `upgradeMod` function. Returns the class methods from
+     * the features that were added.
+     */
+    initOptionalFeature(feature: ISCFeature): FunctionTuple[];
+    /** This is used to initialize both custom callbacks and "extra features". */
+    private initFeature;
+    private uninitFeature;
 }
 
+/**
+ * By specifying one or more optional features, end-users will get a version of `ModUpgraded` that
+ * has extra methods corresponding to the features.
+ *
+ * We have to explicitly account for the empty array case, since `never` will cause mess up the
+ * union.
+ */
+declare type ModUpgradedWithFeatures<T extends ISCFeature> = [T] extends [never] ? ModUpgraded : Omit<ModUpgraded & UnionToIntersection<ISCFeatureToClass[T]>, KeysToScrubFromModClass>;
+
 /**
  * Helper function to move all of the players to where they would normally go when arriving at a new
  * floor. (In normal mode, this is the center of the room. In Greed Mode, this is below the top
@@ -8869,6 +9574,9 @@ export declare const NEW_RUN_PLAYER_STARTING_POSITION: Vector;
 /**
  * Constructor for a `ChargeBarSprites` object. For more information, see the `renderChargeBar`
  * helper function.
+ *
+ * Note that this is for the vertical charge bar that represents the number of charges that an
+ * active item has, not the circular charge bar that shows e.g. the charge rate of Brimstone.
  */
 export declare function newChargeBarSprites(maxCharges: int): ChargeBarSprites;
 
@@ -8878,6 +9586,16 @@ export declare function newChargeBarSprites(maxCharges: int): ChargeBarSprites;
  */
 export declare function newCollectibleSprite(collectibleType: CollectibleType): Sprite;
 
+/**
+ * Helper function for creating objects that represent a mapping of an enum value to some other
+ * value in a type-safe way.
+ *
+ * This function will ensure that the provided object has a key for each value in the enum.
+ *
+ * After the `satisfies` operator is released in TypeScript 4.9, this function should be deleted.
+ */
+export declare function newObjectWithEnumKeys<Enum extends number | string, T extends Record<Enum, unknown>>(theEnum: Record<string, Enum>, obj: T): T;
+
 export declare function newPickingUpItem(): PickingUpItem;
 
 /** Returns a `PlayerHealth` object with all zeros. */
@@ -9008,6 +9726,8 @@ export declare function openAllDoors(): void;
  */
 export declare function openDoorFast(door: GridEntityDoor): void;
 
+declare type OptionalArgs<T extends ModCallbackCustom2> = AllButFirst_2<AddCallbackParametersCustom2[T]>;
+
 /**
  * Helper function to parse a string that contains an entity type, a variant, and a sub-type,
  * separated by periods.
@@ -9085,7 +9805,15 @@ export declare type PickupIndex = int & {
 /** Maps pill effect names to the values of the `PillEffect` enum. */
 export declare const PILL_NAME_TO_EFFECT_MAP: ReadonlyMap<string, PillEffect>;
 
-export declare function playChargeSoundEffect(player: EntityPlayer, activeSlot: ActiveSlot): void;
+/**
+ * Helper function to play the appropriate sound effect for a player after getting one or more
+ * charges on their active item. (There is a different sound depending on whether the item is fully
+ * charged or not.)
+ *
+ * @param player The player to play the sound effect for.
+ * @param activeSlot Optional. The slot that was just charged. Default is `ActiveSlot.PRIMARY`.
+ */
+export declare function playChargeSoundEffect(player: EntityPlayer, activeSlot?: ActiveSlot): void;
 
 /**
  * Helper function to add one or more collectibles to a player.
@@ -9150,6 +9878,25 @@ export declare type PlayerIndex = int & {
     readonly __playerIndexBrand: symbol;
 };
 
+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;
@@ -9213,6 +9960,10 @@ playerVariant?: PlayerVariant,
 character?: PlayerType
 ];
 
+declare class PostCustomRevive extends CustomCallbackRevive<ModCallbackCustom2.POST_CUSTOM_REVIVE> {
+    constructor();
+}
+
 declare type PostCustomReviveRegisterParameters = [
 callback: (player: EntityPlayer, revivalType: int) => void,
 revivalType?: int
@@ -9243,6 +9994,10 @@ callback: (effect: EntityEffect, previousState: int, currentState: int) => void,
 effectVariant?: EffectVariant
 ];
 
+declare class PostEsauJr extends CustomCallback<ModCallbackCustom2.POST_ESAU_JR> {
+    constructor();
+}
+
 declare type PostEsauJrRegisterParameters = [
 callback: (player: EntityPlayer) => void
 ];
@@ -9257,18 +10012,38 @@ callback: (familiar: EntityFamiliar, previousState: int, currentState: int) => v
 familiarVariant?: FamiliarVariant
 ];
 
+declare class PostFirstEsauJr extends CustomCallback<ModCallbackCustom2.POST_FIRST_ESAU_JR> {
+    constructor();
+}
+
 declare type PostFirstEsauJrRegisterParameters = [
 callback: (player: EntityPlayer) => void
 ];
 
+declare class PostFirstFlip extends CustomCallback<ModCallbackCustom2.POST_FIRST_FLIP> {
+    constructor();
+}
+
 declare type PostFirstFlipRegisterParameters = [
 callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void
 ];
 
+declare class PostFlip extends CustomCallback<ModCallbackCustom2.POST_FLIP> {
+    constructor();
+}
+
 declare type PostFlipRegisterParameters = [
 callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void
 ];
 
+declare class PostGameStartedReordered extends CustomCallback<ModCallbackCustom2.POST_GAME_STARTED_REORDERED> {
+    constructor();
+}
+
+declare class PostGameStartedReorderedLast extends CustomCallback<ModCallbackCustom2.POST_GAME_STARTED_REORDERED> {
+    constructor();
+}
+
 declare type PostGameStartedReorderedLastRegisterParameters = [
 callback: (isContinued: boolean) => void
 ];
@@ -9281,12 +10056,21 @@ declare type PostGreedModeWaveRegisterParameters = [
 callback: (oldWave: int, newWave: int) => void
 ];
 
+declare class PostGridEntityBroken extends CustomCallbackGridEntity<ModCallbackCustom2.POST_GRID_ENTITY_BROKEN> {
+    constructor();
+}
+
 declare type PostGridEntityBrokenRegisterParameters = [
 callback: (gridEntity: GridEntity) => void,
 gridEntityType?: GridEntityType,
-gridEntityVariant?: int
+variant?: int
 ];
 
+declare class PostGridEntityCollision extends CustomCallback<T> {
+    constructor();
+    protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
+}
+
 declare type PostGridEntityCollisionRegisterParameters = [
 callback: (gridEntity: GridEntity, entity: Entity) => void,
 gridEntityType?: GridEntityType,
@@ -9295,11 +10079,20 @@ entityType?: EntityType,
 entityVariant?: int
 ];
 
+declare class PostGridEntityCustomBroken extends CustomCallbackGridEntityCustom<ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_BROKEN> {
+    constructor();
+}
+
 declare type PostGridEntityCustomBrokenRegisterParameters = [
 callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
 gridEntityTypeCustom?: GridEntityType
 ];
 
+declare class PostGridEntityCustomCollision extends CustomCallback<T_2> {
+    constructor();
+    protected shouldFire(fireArgs: FireArgs<T_2>, optionalArgs: OptionalArgs<T_2>): boolean;
+}
+
 declare type PostGridEntityCustomCollisionRegisterParameters = [
 callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType, entity: Entity) => void,
 gridEntityTypeCustom?: GridEntityType,
@@ -9307,11 +10100,20 @@ entityType?: EntityType,
 entityVariant?: int
 ];
 
+declare class PostGridEntityCustomInit extends CustomCallbackGridEntityCustom<ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_INIT> {
+    constructor();
+}
+
 declare type PostGridEntityCustomInitRegisterParameters = [
 callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
 gridEntityTypeCustom?: GridEntityType
 ];
 
+declare class PostGridEntityCustomRemove extends CustomCallback<T_4> {
+    constructor();
+    protected shouldFire(fireArgs: FireArgs<T_4>, optionalArgs: OptionalArgs<T_4>): boolean;
+}
+
 declare type PostGridEntityCustomRemoveRegisterParameters = [
 callback: (gridIndex: int, gridEntityTypeCustom: GridEntityType) => void,
 gridEntityTypeCustom?: GridEntityType
@@ -9322,44 +10124,69 @@ callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void
 gridEntityTypeCustom?: GridEntityType
 ];
 
+declare class PostGridEntityCustomStateChanged extends CustomCallbackGridEntityCustom<ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED> {
+    constructor();
+}
+
 declare type PostGridEntityCustomStateChangedRegisterParameters = [
 callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType, oldState: int, newState: int) => void,
 gridEntityTypeCustom?: GridEntityType
 ];
 
+declare class PostGridEntityCustomUpdate extends CustomCallbackGridEntityCustom<ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_UPDATE> {
+    constructor();
+}
+
 declare type PostGridEntityCustomUpdateRegisterParameters = [
 callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
 gridEntityTypeCustom?: GridEntityType
 ];
 
+declare class PostGridEntityInit extends CustomCallbackGridEntity<ModCallbackCustom2.POST_GRID_ENTITY_INIT> {
+    constructor();
+}
+
 declare type PostGridEntityInitRegisterParameters = [
 callback: (gridEntity: GridEntity) => void,
 gridEntityType?: GridEntityType,
-gridEntityVariant?: int
+variant?: int
 ];
 
+declare class PostGridEntityRemove extends CustomCallback<T_3> {
+    constructor();
+    protected shouldFire(fireArgs: FireArgs<T_3>, optionalArgs: OptionalArgs<T_3>): boolean;
+}
+
 declare type PostGridEntityRemoveRegisterParameters = [
-callback: (gridIndex: int, gridEntityType: GridEntityType) => void,
+callback: (gridIndex: int, gridEntityType: GridEntityType, variant: int) => void,
 gridEntityType?: GridEntityType,
-gridEntityVariant?: int
+variant?: int
 ];
 
 declare type PostGridEntityRenderRegisterParameters = [
 callback: (gridEntity: GridEntity) => void,
 gridEntityType?: GridEntityType,
-gridEntityVariant?: int
+variant?: int
 ];
 
+declare class PostGridEntityStateChanged extends CustomCallbackGridEntity<ModCallbackCustom2.POST_GRID_ENTITY_STATE_CHANGED> {
+    constructor();
+}
+
 declare type PostGridEntityStateChangedRegisterParameters = [
 callback: (gridEntity: GridEntity, oldState: int, newState: int) => void,
 gridEntityType?: GridEntityType,
-gridEntityVariant?: int
+variant?: int
 ];
 
+declare class PostGridEntityUpdate extends CustomCallbackGridEntity<ModCallbackCustom2.POST_GRID_ENTITY_UPDATE> {
+    constructor();
+}
+
 declare type PostGridEntityUpdateRegisterParameters = [
 callback: (gridEntity: GridEntity) => void,
 gridEntityType?: GridEntityType,
-gridEntityVariant?: int
+variant?: int
 ];
 
 declare type PostHolyMantleRemovedRegisterParameters = [
@@ -9393,10 +10220,18 @@ callback: (laser: EntityLaser) => void,
 laserVariant?: LaserVariant
 ];
 
+declare class PostNewLevelReordered extends CustomCallback<ModCallbackCustom2.POST_NEW_LEVEL_REORDERED> {
+    constructor();
+}
+
 declare type PostNewLevelReorderedRegisterParameters = [callback: () => void];
 
 declare type PostNewRoomEarlyRegisterParameters = [callback: () => void];
 
+declare class PostNewRoomReordered extends CustomCallback<ModCallbackCustom2.POST_NEW_ROOM_REORDERED> {
+    constructor();
+}
+
 declare type PostNewRoomReorderedRegisterParameters = [callback: () => void];
 
 declare type PostNPCInitLateRegisterParameters = [
@@ -9410,6 +10245,10 @@ entityType?: EntityType,
 variant?: int
 ];
 
+declare class PostPEffectUpdateReordered extends CustomCallbackPlayer<ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED> {
+    constructor();
+}
+
 declare type PostPEffectUpdateReorderedRegisterParameters = [
 callback: (player: EntityPlayer) => void,
 playerVariant?: PlayerVariant,
@@ -9491,12 +10330,20 @@ playerVariant?: PlayerVariant,
 character?: PlayerType
 ];
 
+declare class PostPlayerRenderReordered extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_RENDER_REORDERED> {
+    constructor();
+}
+
 declare type PostPlayerRenderReorderedRegisterParameters = [
 callback: (player: EntityPlayer) => void,
 playerVariant?: PlayerVariant,
 character?: PlayerType
 ];
 
+declare class PostPlayerUpdateReordered extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_UPDATE_REORDERED> {
+    constructor();
+}
+
 declare type PostPlayerUpdateReorderedRegisterParameters = [
 callback: (player: EntityPlayer) => void,
 playerVariant?: PlayerVariant,
@@ -9536,12 +10383,12 @@ pickupSubType?: int
 
 declare type PostRockRenderRegisterParameters = [
 callback: (rock: GridEntityRock) => void,
-gridEntityVariant?: int
+variant?: int
 ];
 
 declare type PostRockUpdateRegisterParameters = [
 callback: (rock: GridEntityRock) => void,
-gridEntityVariant?: int
+variant?: int
 ];
 
 declare type PostRoomClearChangedRegisterParameters = [
@@ -9588,12 +10435,12 @@ slotVariant?: SlotVariant
 
 declare type PostSpikesRenderRegisterParameters = [
 callback: (spikes: GridEntitySpikes) => void,
-gridEntityVariant?: int
+variant?: int
 ];
 
 declare type PostSpikesUpdateRegisterParameters = [
 callback: (spikes: GridEntitySpikes) => void,
-gridEntityVariant?: int
+variant?: int
 ];
 
 declare type PostTearInitLateRegisterParameters = [
@@ -9608,12 +10455,12 @@ tearVariant?: TearVariant
 
 declare type PostTNTRenderRegisterParameters = [
 callback: (tnt: GridEntityTNT) => void,
-gridEntityVariant?: int
+variant?: int
 ];
 
 declare type PostTNTUpdateRegisterParameters = [
 callback: (tnt: GridEntityTNT) => void,
-gridEntityVariant?: int
+variant?: int
 ];
 
 declare type PostTransformationRegisterParameters = [
@@ -9632,6 +10479,10 @@ playerVariant?: PlayerVariant,
 character?: PlayerType
 ];
 
+declare class PreCustomRevive extends CustomCallbackPlayer<ModCallbackCustom2.PRE_CUSTOM_REVIVE> {
+    constructor();
+}
+
 declare type PreCustomReviveRegisterParameters = [
 callback: (player: EntityPlayer) => int | undefined,
 playerVariant?: PlayerVariant,
@@ -9711,6 +10562,9 @@ export declare function printConsole(msg: string): 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;
 
+/** Used for `runInNFrames` functions. */
+declare type QueuedFunctionTuple = [frameCountToFire: int, func: () => void];
+
 /**
  * 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).
@@ -10384,6 +11238,9 @@ export declare const RENDER_FRAMES_PER_SECOND = 60;
 /**
  * Helper function to render a charge bar on the screen. First, call the `newChargeBarSprites`
  * function to initialize the sprites, and then call this function on every render frame.
+ *
+ * Note that this is for the vertical charge bar that represents the number of charges that an
+ * active item has, not the circular charge bar that shows e.g. the charge rate of Brimstone.
  */
 export declare function renderChargeBar(sprites: ChargeBarSprites, position: Vector, normalCharges: int, batteryCharges: int): void;
 
@@ -10536,6 +11393,114 @@ export declare function round(num: float, numDecimalPlaces?: number): float;
  */
 export declare function runDeepCopyTests(): void;
 
+declare class RunInNFrames extends Feature {
+    v: {
+        run: {
+            queuedGameFunctionTuples: QueuedFunctionTuple[];
+            queuedRenderFunctionTuples: QueuedFunctionTuple[];
+            intervalGameFunctionTuples: IntervalFunctionTuple[];
+            intervalRenderFunctionTuples: IntervalFunctionTuple[];
+        };
+    };
+    constructor();
+    private postUpdate;
+    private postRender;
+    /**
+     * 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.
+     */
+    runInNGameFrames(func: () => void, gameFrames: int): 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.
+     */
+    runInNRenderFrames(func: () => void, renderFrames: int): 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.
+     */
+    runNextGameFrame(func: () => void): 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.
+     */
+    runNextRenderFrame(func: () => void): 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.
+     *
+     * @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.
+     */
+    setIntervalGameFrames(func: () => boolean, gameFrames: int, runImmediately: 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.
+     *
+     * @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.
+     */
+    setIntervalRenderFrames(func: () => boolean, renderFrames: int, runImmediately: boolean): void;
+}
+
 /**
  * Supply a function to run N game frames from now in the `POST_UPDATE` callback.
  *
@@ -10759,6 +11724,12 @@ v: SaveData, conditionalFunc: false): void;
  */
 export declare function saveDataManagerLoad(): void;
 
+/**
+ * Removes a previously registered key from the save data manager. This is the opposite of the
+ * "saveDataManager" function.
+ */
+export declare function saveDataManagerRemove(key: string): void;
+
 /**
  * The save data manager will automatically reset variables at the appropriate times (i.e. when a
  * player enters a new room). Use this function to explicitly force the save data manager to reset a
@@ -10922,12 +11893,12 @@ export declare function serializeVector(vector: Vector): SerializedVector;
  *
  * @param player The player to give the item to.
  * @param collectibleType The collectible type of the item to give.
- * @param activeSlot The slot to set.
+ * @param activeSlot Optional. The slot to set. Default is `ActiveSlot.PRIMARY`.
  * @param charge Optional. The argument of charges to set. If not specified, the item will be set
  *               with maximum charges.
  * @param keepInPools Optional. Whether or not to remove the item from pools. Default is false.
  */
-export declare function setActiveItem(player: EntityPlayer, collectibleType: CollectibleType, activeSlot: ActiveSlot, charge?: int, keepInPools?: boolean): void;
+export declare function setActiveItem(player: EntityPlayer, collectibleType: CollectibleType, activeSlot?: ActiveSlot, charge?: int, keepInPools?: boolean): void;
 
 /**
  * Helper function to add one or more elements to a set at once without having to repeatedly call
@@ -10955,7 +11926,7 @@ export declare function setAllRNGToSeed(object: unknown, seed: Seed): void;
  */
 export declare function setAllRNGToStartSeed(object: unknown): void;
 
-/** Helper function to set the backdrop of the current room. */
+/** Helper function to set the backdrop (i.e. background) of the current room. */
 export declare function setBackdrop(backdropType: BackdropType): void;
 
 /**
@@ -12057,6 +13028,10 @@ export declare function stageTypeToLetter(stageType: StageType): string;
  */
 export declare function startAmbush(): void;
 
+export declare type StartsWithLowercase<S> = S extends string ? Extract<S, Uncapitalize<S>> : never;
+
+export declare type StartsWithUppercase<S> = S extends string ? Extract<S, Capitalize<S>> : never;
+
 /** This represents the kinds of stats that a player can have. */
 export declare enum StatType {
     /** Corresponds to `CacheFlag.DAMAGE` (1 << 0) and `EntityPlayer.Damage`. */
@@ -12123,6 +13098,14 @@ 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 = ModCallbackCustom2.POST_GRID_ENTITY_COLLISION;
+
+declare type T_2 = ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_COLLISION;
+
+declare type T_3 = ModCallbackCustom2.POST_GRID_ENTITY_REMOVE;
+
+declare type T_4 = ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_REMOVE;
+
 /**
  * Helper function to check if a Lua table has all of the provided keys.
  *
@@ -12392,6 +13375,15 @@ export declare type TSTLClass = LuaMap<AnyNotNil, unknown> & {
     readonly __tstlClassBrand: symbol;
 };
 
+declare interface TSTLClassMetatable {
+    ____constructor: () => void;
+    __index: unknown;
+    constructor: {
+        name: string;
+        prototype: LuaMetatable<LuaMap<AnyNotNil, unknown>>;
+    };
+}
+
 /**
  * Helper function to sort a two-dimensional array by the first element.
  *
@@ -12413,6 +13405,9 @@ export declare function twoDimensionalSort<T>(array1: T[], array2: T[]): -1 | 0
  */
 export declare const UI_HEART_WIDTH = 12;
 
+/** A helper type to convert a union to an intersection. */
+declare type UnionToIntersection<U> = (U extends U ? (u: U) => 0 : never) extends (i: infer I) => 0 ? Extract<I, U> : never;
+
 /** Helper function to put things back to normal after the `pause` function was used. */
 export declare function unpause(): void;
 
@@ -12450,6 +13445,8 @@ export declare function unsetHotkey(keyboard: Keyboard): void;
  * ```
  *
  * @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
@@ -12457,7 +13454,9 @@ export declare function unsetHotkey(keyboard: Keyboard): void;
  *                      or milliseconds (if the "--luadebug" launch flag is turned off).
  * @returns The upgraded mod object.
  */
-export declare function upgradeMod(modVanilla: Mod, debug?: boolean, timeThreshold?: float): ModUpgraded;
+export declare function upgradeMod<T extends ISCFeature = never>(modVanilla: Mod, features?: T[], debug?: boolean, timeThreshold?: float): ModUpgradedWithFeatures<T>;
+
+export declare type UppercaseKeys<T> = StartsWithUppercase<keyof T>;
 
 /**
  * Helper function to use an active item without showing an animation, keeping the item, or adding
@@ -12489,6 +13488,35 @@ export declare function validateCustomEnum(transpiledEnumName: string, transpile
  */
 export declare function validateEnumContiguous<T>(transpiledEnumName: string, transpiledEnum: T): void;
 
+/**
+ * Helper function to validate that an interface contains all of the keys of an enum. You must
+ * specify both generic parameters in order for this to work properly (i.e. the interface and then
+ * the enum).
+ *
+ * For example:
+ *
+ * ```ts
+ * enum MyEnum {
+ *   Value1,
+ *   Value2,
+ *   Value3,
+ * }
+ *
+ * interface MyEnumToType {
+ *   [MyEnum.Value1]: boolean;
+ *   [MyEnum.Value2]: number;
+ *   [MyEnum.Value3]: string;
+ * }
+ *
+ * validateInterfaceMatchesEnum<MyEnumToType, MyEnum>();
+ * ```
+ *
+ * This function is only meant to be used with interfaces (i.e. types that will not exist at
+ * run-time). If you are generating an object that will contain all of the keys of an enum, use the
+ * `newObjectWithEnumKeys` helper function instead.
+ */
+export declare function validateInterfaceMatchesEnum<T extends Record<Enum, unknown>, Enum extends string | number>(): void;
+
 export declare function vectorEquals(vector1: Vector, vector2: Vector): boolean;
 
 /**