isaacscript-common 14.1.2 → 14.2.0

package/dist/index.d.ts

@@ -79,6 +79,10 @@ import { TrapdoorVariant } from 'isaac-typescript-definitions';
 import { TrinketType } from 'isaac-typescript-definitions';
 import { UseFlag } from 'isaac-typescript-definitions';
 
+export declare const ADD_CALLBACK_ARGS_KEY = "__addCallbackArgs";
+
+export declare const ADD_CALLBACK_CUSTOM_ARGS_KEY = "__addCallbackCustomArgs";
+
 declare interface AddCallbackParametersCustom {
     [ModCallbackCustom.POST_AMBUSH_FINISHED]: PostAmbushFinishedRegisterParameters;
     [ModCallbackCustom.POST_AMBUSH_STARTED]: PostAmbushStartedRegisterParameters;
@@ -289,6 +293,10 @@ declare interface AddCallbackParametersCustom2 {
     callback: (gridIndex: int, gridEntityTypeCustom: GridEntityType) => void,
     gridEntityTypeCustom?: GridEntityType
     ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_RENDER]: [
+    callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
+    gridEntityTypeCustom?: GridEntityType
+    ];
     [ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED]: [
     callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType, oldState: int, newState: int) => void,
     gridEntityTypeCustom?: GridEntityType
@@ -307,6 +315,11 @@ declare interface AddCallbackParametersCustom2 {
     gridEntityType?: GridEntityType,
     variant?: int
     ];
+    [ModCallbackCustom2.POST_GRID_ENTITY_RENDER]: [
+    callback: (gridEntity: GridEntity) => void,
+    gridEntityType?: GridEntityType,
+    variant?: int
+    ];
     [ModCallbackCustom2.POST_GRID_ENTITY_STATE_CHANGED]: [
     callback: (gridEntity: GridEntity, oldState: int, newState: int) => void,
     gridEntityType?: GridEntityType,
@@ -322,27 +335,110 @@ declare interface AddCallbackParametersCustom2 {
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom2.POST_NEW_LEVEL_REORDERED]: [callback: () => void];
+    [ModCallbackCustom2.POST_ITEM_DISCHARGE]: [
+    callback: (player: EntityPlayer, collectibleType: CollectibleType, activeSlot: ActiveSlot) => void,
+    collectibleType?: CollectibleType
+    ];
+    [ModCallbackCustom2.POST_ITEM_PICKUP]: [callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => void] | [
+    callback: (player: EntityPlayer, pickingUpItem: PickingUpItemCollectible) => void,
+    itemType: ItemType.PASSIVE | ItemType.ACTIVE | ItemType.FAMILIAR,
+    collectibleType?: CollectibleType
+    ] | [
+    callback: (player: EntityPlayer, pickingUpItem: PickingUpItemTrinket) => void,
+    itemType: ItemType.TRINKET,
+    trinketType?: TrinketType
+    ];
     [ModCallbackCustom2.POST_KNIFE_INIT_LATE]: [
     callback: (knife: EntityKnife) => void,
     knifeVariant?: KnifeVariant
     ];
+    [ModCallbackCustom2.POST_LASER_INIT_LATE]: [
+    callback: (laser: EntityLaser) => void,
+    laserVariant?: LaserVariant
+    ];
+    [ModCallbackCustom2.POST_NEW_LEVEL_REORDERED]: [callback: () => void];
     [ModCallbackCustom2.POST_NEW_ROOM_EARLY]: [callback: () => void];
     [ModCallbackCustom2.POST_NEW_ROOM_REORDERED]: [callback: () => void];
+    [ModCallbackCustom2.POST_NPC_INIT_LATE]: [
+    callback: (npc: EntityNPC) => void,
+    entityType?: EntityType,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_NPC_STATE_CHANGED]: [
+    callback: (npc: EntityNPC, previousState: int, currentState: int) => void,
+    entityType?: EntityType,
+    variant?: int
+    ];
     [ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED]: [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
+    [ModCallbackCustom2.POST_PICKUP_COLLECT]: [
+    callback: (pickup: EntityPickup, player: EntityPlayer) => void,
+    pickupVariant?: PickupVariant,
+    subType?: int
+    ];
+    [ModCallbackCustom2.POST_PICKUP_INIT_FIRST]: [
+    callback: (pickup: EntityPickup) => void,
+    pickupVariant?: PickupVariant,
+    subType?: int
+    ];
+    [ModCallbackCustom2.POST_PICKUP_INIT_LATE]: [
+    callback: (pickup: EntityPickup) => void,
+    pickupVariant?: PickupVariant,
+    subType?: int
+    ];
+    [ModCallbackCustom2.POST_PICKUP_STATE_CHANGED]: [
+    callback: (pickup: EntityPickup, previousState: int, currentState: int) => void,
+    pickupVariant?: PickupVariant,
+    subType?: int
+    ];
     [ModCallbackCustom2.POST_PIT_RENDER]: [
     callback: (pit: GridEntityPit) => void,
     pitVariant?: PitVariant
     ];
+    [ModCallbackCustom2.POST_PIT_UPDATE]: [
+    callback: (pit: GridEntityPit) => void,
+    pitVariant?: PitVariant
+    ];
+    [ModCallbackCustom2.POST_PLAYER_CHANGE_HEALTH]: [
+    callback: (player: EntityPlayer, healthType: HealthType, difference: int, oldValue: int, newValue: int) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
+    [ModCallbackCustom2.POST_PLAYER_CHANGE_STAT]: [
+    callback: <T extends StatType>(player: EntityPlayer, statType: StatType, difference: int, oldValue: StatTypeType[T], newValue: StatTypeType[T]) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
+    [ModCallbackCustom2.POST_PLAYER_CHANGE_TYPE]: [
+    callback: (player: EntityPlayer, oldCharacter: PlayerType, newCharacter: PlayerType) => void,
+    playerVariant?: PlayerVariant
+    ];
+    [ModCallbackCustom2.POST_PLAYER_COLLECTIBLE_ADDED]: [
+    callback: (player: EntityPlayer, collectibleType: CollectibleType) => void,
+    collectibleType?: CollectibleType
+    ];
+    [ModCallbackCustom2.POST_PLAYER_COLLECTIBLE_REMOVED]: [
+    callback: (player: EntityPlayer, collectibleType: CollectibleType) => void,
+    collectibleType?: CollectibleType
+    ];
     [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_INIT_FIRST]: [
+    callback: (player: EntityPlayer) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
+    [ModCallbackCustom2.POST_PLAYER_INIT_LATE]: [
+    callback: (player: EntityPlayer) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
     [ModCallbackCustom2.POST_PLAYER_RENDER_REORDERED]: [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,
@@ -353,14 +449,101 @@ declare interface AddCallbackParametersCustom2 {
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
+    [ModCallbackCustom2.POST_POOP_RENDER]: [
+    callback: (poop: GridEntityPoop) => void,
+    poopVariant?: PoopGridEntityVariant
+    ];
+    [ModCallbackCustom2.POST_POOP_UPDATE]: [
+    callback: (poop: GridEntityPoop) => void,
+    poopVariant?: PoopGridEntityVariant
+    ];
+    [ModCallbackCustom2.POST_PRESSURE_PLATE_RENDER]: [
+    callback: (pressurePlate: GridEntityPressurePlate) => void,
+    pressurePlateVariant?: PressurePlateVariant
+    ];
+    [ModCallbackCustom2.POST_PRESSURE_PLATE_UPDATE]: [
+    callback: (pressurePlate: GridEntityPressurePlate) => void,
+    pressurePlateVariant?: PressurePlateVariant
+    ];
+    [ModCallbackCustom2.POST_PROJECTILE_INIT_LATE]: [
+    callback: (projectile: EntityProjectile) => void,
+    projectileVariant?: ProjectileVariant
+    ];
+    [ModCallbackCustom2.POST_PURCHASE]: [
+    callback: (player: EntityPlayer, pickup: EntityPickup) => void,
+    pickupVariant?: PickupVariant,
+    pickupSubType?: int
+    ];
+    [ModCallbackCustom2.POST_ROCK_RENDER]: [
+    callback: (rock: GridEntityRock) => void,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_ROCK_UPDATE]: [
+    callback: (rock: GridEntityRock) => void,
+    variant?: int
+    ];
     [ModCallbackCustom2.POST_ROOM_CLEAR_CHANGED]: [
     callback: (roomClear: boolean) => void,
     roomClear?: boolean
     ];
+    [ModCallbackCustom2.POST_SACRIFICE]: [
+    callback: (player: EntityPlayer, numSacrifices: int) => void,
+    playerVariant?: PlayerVariant,
+    character?: PlayerType
+    ];
+    [ModCallbackCustom2.POST_SLOT_ANIMATION_CHANGED]: [
+    callback: (slot: EntitySlot, previousAnimation: string, currentAnimation: string) => void,
+    slotVariant?: SlotVariant
+    ];
+    [ModCallbackCustom2.POST_SLOT_COLLISION]: [
+    callback: (slot: EntitySlot, player: EntityPlayer) => void,
+    slotVariant?: SlotVariant
+    ];
+    [ModCallbackCustom2.POST_SLOT_DESTROYED]: [
+    callback: (slot: EntitySlot, slotDestructionType: SlotDestructionType) => void,
+    slotVariant?: SlotVariant,
+    slotDestructionType?: SlotDestructionType
+    ];
+    [ModCallbackCustom2.POST_SLOT_INIT]: [
+    callback: (slot: EntitySlot) => void,
+    slotVariant?: SlotVariant
+    ];
+    [ModCallbackCustom2.POST_SLOT_RENDER]: [
+    callback: (slot: EntitySlot) => void,
+    slotVariant?: SlotVariant
+    ];
+    [ModCallbackCustom2.POST_SLOT_UPDATE]: [
+    callback: (slot: EntitySlot) => void,
+    slotVariant?: SlotVariant
+    ];
     [ModCallbackCustom2.POST_SPIKES_RENDER]: [
     callback: (spikes: GridEntitySpikes) => void,
     variant?: int
     ];
+    [ModCallbackCustom2.POST_SPIKES_UPDATE]: [
+    callback: (spikes: GridEntitySpikes) => void,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_TEAR_INIT_LATE]: [
+    callback: (tear: EntityTear) => void,
+    tearVariant?: TearVariant
+    ];
+    [ModCallbackCustom2.POST_TEAR_INIT_VERY_LATE]: [
+    callback: (tear: EntityTear) => void,
+    tearVariant?: TearVariant
+    ];
+    [ModCallbackCustom2.POST_TNT_RENDER]: [
+    callback: (tnt: GridEntityTNT) => void,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_TNT_UPDATE]: [
+    callback: (tnt: GridEntityTNT) => void,
+    variant?: int
+    ];
+    [ModCallbackCustom2.POST_TRANSFORMATION]: [
+    callback: (player: EntityPlayer, playerForm: PlayerForm, hasForm: boolean) => void,
+    playerForm?: PlayerForm
+    ];
     [ModCallbackCustom2.PRE_BERSERK_DEATH]: [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,
@@ -371,6 +554,15 @@ declare interface AddCallbackParametersCustom2 {
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
+    [ModCallbackCustom2.PRE_ITEM_PICKUP]: [callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => void] | [
+    callback: (player: EntityPlayer, pickingUpItem: PickingUpItemCollectible) => void,
+    itemType: ItemType.PASSIVE | ItemType.ACTIVE | ItemType.FAMILIAR,
+    collectibleType?: CollectibleType
+    ] | [
+    callback: (player: EntityPlayer, pickingUpItem: PickingUpItemTrinket) => void,
+    itemType: ItemType.TRINKET,
+    trinketType?: TrinketType
+    ];
 }
 
 /**
@@ -560,6 +752,8 @@ export declare enum AmbushType {
  */
 export declare function angleToDirection(angleDegrees: int): Direction;
 
+declare type AnyClass = new (...args: readonly unknown[]) => unknown;
+
 /**
  * A type union that matches `Entity`, `EntityBomb`, `EntityEffect`, and so on.
  *
@@ -569,6 +763,12 @@ export declare type AnyEntity = Entity | EntityBomb | EntityEffect | EntityFamil
 
 export declare function anyEntityCloserThan(entities: Entity[], position: Vector, distance: int): boolean;
 
+/**
+ * Helper type to represent any function. This is safer than using the built-in `Function` type, as
+ * it does not completely turn off all type safety.
+ */
+export declare type AnyFunction = (...args: unknown[]) => unknown;
+
 /**
  * A type union that matches `GridEntity`, `GridEntityDoor`, `GridEntityPit`, and so on.
  *
@@ -827,24 +1027,30 @@ export declare function calculateStageTypeRepentance(stage: LevelStage): StageTy
 /**
  * A decorator function that signifies that the decorated class method should be automatically
  * registered with `Mod.AddCallback`.
+ *
+ * @ignore
  */
 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`.
+ *
+ * @ignore
  */
-export declare function CallbackCustom<T extends ModCallbackCustom2>(modCallbackCustom: T, ...optionalArgs: AllButFirst<AddCallbackParametersCustom2[T]>): <Class extends {
-    mod: ModUpgraded;
-}>(target: Class, propertyKey: string) => void;
+export declare function CallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, ...optionalArgs: AllButFirst<AddCallbackParametersCustom[T]>): <Class extends ModFeature, Fn extends AddCallbackParametersCustom[T][0]>(target: Class, propertyKey: string, _descriptor: TypedPropertyDescriptor<Fn>) => void;
+
+declare type CallbackSignatureCollectibleType = (player: EntityPlayer, collectibleType: CollectibleType) => 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 CallbackSignatureItemPickup = ((player: EntityPlayer, pickingUpItem: PickingUpItem) => void) | ((player: EntityPlayer, pickingUpItem: PickingUpItemCollectible) => void) | ((player: EntityPlayer, pickingUpItem: PickingUpItemTrinket) => void);
 
-declare type CallbackSignatureRevive = (player: EntityPlayer, revivalType: int) => void;
+declare type CallbackSignaturePlayer = ((player: EntityPlayer) => void) | ((player: EntityPlayer) => int | undefined) | ((player: EntityPlayer, oldCharacter: PlayerType, newCharacter: PlayerType) => void) | ((player: EntityPlayer, amount: float, damageFlags: BitFlags<DamageFlag>, source: EntityRef, countdownFrames: int) => boolean | undefined) | ((player: EntityPlayer, healthType: HealthType, difference: int, oldValue: int, newValue: int) => void) | (<T extends StatType>(player: EntityPlayer, statType: StatType, difference: int, oldValue: StatTypeType[T], newValue: StatTypeType[T]) => void);
+
+declare type CallbackSignatureSlot = ((slot: EntitySlot) => void) | ((slot: EntitySlot, slotDestructionType: SlotDestructionType) => void) | ((slot: EntitySlot, player: EntityPlayer) => void) | ((slot: EntitySlot, previousAnimation: string, currentAnimation: string) => void);
 
 /**
  * A mapping of the callback enum to the associated callback functions (and optional arguments).
@@ -1267,13 +1473,12 @@ export declare const CUSTOM_FLOOR_STAGE_TYPE = StageType.WRATH_OF_THE_LAMB;
  */
 declare abstract class CustomCallback<T extends ModCallbackCustom2> extends Feature {
     private subscriptions;
-    hasSubscriptions(): boolean;
-    add(...args: AddCallbackParametersCustom2[T]): void;
+    addSubscriber(...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;
+    removeSubscriber(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.
@@ -1281,6 +1486,10 @@ declare abstract class CustomCallback<T extends ModCallbackCustom2> extends Feat
     protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
 }
 
+declare class CustomCallbackCollectibleType<T extends ModCallbackCustomCollectibleType> extends CustomCallback<T> {
+    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;
 }
@@ -1289,11 +1498,15 @@ declare class CustomCallbackGridEntityCustom<T extends ModCallbackCustomGridEnti
     protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
 }
 
+declare class CustomCallbackItemPickup<T extends ModCallbackCustomItemPickup> 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> {
+declare class CustomCallbackSlot<T extends ModCallbackCustomSlot> extends CustomCallback<T> {
     protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
 }
 
@@ -1319,8 +1532,8 @@ declare class CustomGridEntities extends Feature {
     };
     private runInNFrames;
     constructor(runInNFrames: RunInNFrames);
+    private postNewRoom;
     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
@@ -1447,9 +1660,9 @@ declare class CustomRevive extends Feature {
     private postCustomRevive;
     constructor(preCustomRevive: PreCustomRevive, postCustomRevive: PostCustomRevive);
     private postRender;
-    private postNewRoomReordered;
-    private postPEffectUpdateReordered;
+    private postPEffectUpdate;
     private checkWaitingForItemAnimation;
+    private postNewRoom;
     private postPlayerFatalDamage;
     private preBerserkDeath;
     /**
@@ -2005,14 +2218,19 @@ export declare interface CustomStageTSConfig {
  * @param serializationType Optional. Has 3 possible values. Can copy objects as-is, or can
  *                          serialize objects to Lua tables, or can deserialize Lua tables to
  *                          objects. Default is `SerializationType.NONE`.
- * @param traversalDescription Optional. Used to track the current key that we are operating on.
- *                             Default is an empty string.
+ * @param traversalDescription Optional. Used to track the current key that we are operating on for
+ *                             debugging purposes. Default is an empty string.
+ * @param classConstructors Optional. A Lua table that maps the name of a user-defined TSTL class to
+ *                          its corresponding constructor. If the `deepCopy` function finds any
+ *                          user-defined TSTL classes when recursively iterating through the given
+ *                          object, it will use this map to instantiate a new class. Default is an
+ *                          empty Lua table.
  * @param insideMap Optional. Tracks whether or not the deep copy function is in the process of
  *                  recursively copying a TSTL Map. Default is false.
  */
-export declare function deepCopy<T>(value: T, serializationType?: SerializationType.NONE, traversalDescription?: string, insideMap?: boolean): T;
+export declare function deepCopy<T>(value: T, serializationType?: SerializationType.NONE, traversalDescription?: string, classConstructors?: LuaMap<string, AnyClass>, insideMap?: boolean): T;
 
-export declare function deepCopy(value: unknown, serializationType: SerializationType, traversalDescription?: string, insideMap?: boolean): unknown;
+export declare function deepCopy(value: unknown, serializationType: SerializationType, traversalDescription?: string, classConstructors?: LuaMap<string, AnyClass>, insideMap?: boolean): unknown;
 
 export declare const DEFAULT_BASE_STAGE = LevelStage.BASEMENT_2;
 
@@ -2183,8 +2401,9 @@ export declare function deleteSetsFromSet<T>(mainSet: Set<T>, ...setsToRemove: A
  * 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.
  *
- * You can create JSON rooms by using the `convert-xml-to-json` tool (e.g. `npx convert-xml-to-json
- * my-rooms.xml`).
+ * 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.
  *
@@ -2213,8 +2432,9 @@ export declare function deployJSONRoom(jsonRoom: JSONRoom | Readonly<JSONRoom>,
  * Specifically, this will clear the current room of all entities and grid entities, and then spawn
  * all of the entries and grid entities in one of the provided JSON rooms.
  *
- * You can create JSON rooms by using the `convert-xml-to-json` tool (e.g. `npx convert-xml-to-json
- * my-rooms.xml`).
+ * 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.
  *
@@ -2596,8 +2816,6 @@ export declare function enableFastReset(): void;
  */
 export declare function eRange(start: int, end?: int, increment?: number): int[];
 
-declare type ErrorCustomClassNotSerializable = "Error: Custom classes with one or more methods are not serializable when inside of an array, map, or set. For more information, see: https://isaacscript.github.io/main/gotchas#custom-classes-are-not-serializable";
-
 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 {
@@ -2647,6 +2865,7 @@ export declare type FactoryFunction<V, Args extends unknown[]> = (...args: Args)
  */
 declare class Feature {
     initialized: boolean;
+    numConsumers: number;
     v?: SaveData;
     featuresUsed?: ISCFeature[];
     callbacksUsed?: CallbackTuple[];
@@ -2817,10 +3036,7 @@ 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
-];
+export declare type FunctionTuple = [name: string, func: AnyFunction];
 
 /**
  * A cached version of the class returned from the `Game()` constructor.
@@ -3511,6 +3727,24 @@ data: GridEntityCustomData
  */
 export declare function getCustomGridEntityType(gridEntityOrGridIndex: GridEntity | int): GridEntityType | undefined;
 
+/**
+ * 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).
+ *
+ * @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`.
+ */
+export declare function getCustomItemPoolCollectible(itemPoolTypeCustom: ItemPoolType, decrease?: boolean, seedOrRNG?: Seed | RNG, defaultItem?: CollectibleType): CollectibleType;
+
 /**
  * Helper function to get a set containing all of the global variable names that are contained
  * within the Isaac environment by default.
@@ -4007,12 +4241,16 @@ export declare function getItemConfigCardType(cardType: CardType): ItemConfigCar
 /**
  * Helper function to calculate what the resulting `BitFlags<DoorSlotFlag>` value would be for a
  * given JSON room.
+ *
+ * (A JSON room is an XML file converted to JSON so that it can be directly imported into your mod.)
  */
 export declare function getJSONRoomDoorSlotFlags(jsonRoom: JSONRoom): BitFlags<DoorSlotFlag>;
 
 /**
  * Helper function to find a specific room from an array of JSON rooms.
  *
+ * (A JSON room is an XML file converted to JSON so that it can be directly imported into your mod.)
+ *
  * @param jsonRooms The array of rooms to search through.
  * @param variant The room variant to select. (The room variant can be thought of as the ID of the
  *                room.)
@@ -4022,6 +4260,8 @@ export declare function getJSONRoomOfVariant(jsonRooms: JSONRoom[] | readonly JS
 /**
  * Helper function to find all of the JSON rooms that match the sub-type provided.
  *
+ * (A JSON room is an XML file converted to JSON so that it can be directly imported into your mod.)
+ *
  * @param jsonRooms The array of rooms to search through.
  * @param subType The sub-type to match.
  */
@@ -5063,9 +5303,20 @@ export declare function getRandomEnumValue<T>(transpiledEnum: T, seedOrRNG?: See
  */
 export declare function getRandomFloat(min: int, max: int, seedOrRNG?: Seed | RNG): float;
 
-/** Get a random value from a `WeightedArray`. (The second element in the array is the weight.) */
+/**
+ * Get a random value from a `WeightedArray`. (A `WeightedArray` is an array of tuples, where the
+ * first element in the tuple is a value, and the second element in the tuple is a float
+ * corresponding to the value's weight.)
+ */
 export declare function getRandomFromWeightedArray<T>(weightedArray: WeightedArray<T>, seedOrRNG?: Seed | RNG): T;
 
+/**
+ * Get a random index from a `WeightedArray`. (A `WeightedArray` is an array of tuples, where the
+ * first element in the tuple is a value, and the second element in the tuple is a float
+ * corresponding to the value's weight.)
+ */
+export declare function getRandomIndexFromWeightedArray<T>(weightedArray: WeightedArray<T>, seedOrRNG?: Seed | RNG): int;
+
 /**
  * This returns a random integer between min and max. It is inclusive on both ends.
  *
@@ -5092,6 +5343,9 @@ export declare function getRandomInt(min: int, max: int, seedOrRNG?: Seed | RNG,
 /**
  * Helper function to get a random JSON entity from an array of JSON entities.
  *
+ * (A JSON entity is an entity inside of a JSON room. A JSON room is an XML file converted to JSON
+ * so that it can be directly imported into your mod.)
+ *
  * Note that this function does not simply choose a random element in the provided array; it will
  * properly account for each room weight using the algorithm from:
  * https://stackoverflow.com/questions/1761626/weighted-random-numbers
@@ -5107,6 +5361,8 @@ export declare function getRandomJSONEntity(jsonEntities: JSONEntity[], seedOrRN
 /**
  * Helper function to get a random JSON room from an array of JSON rooms.
  *
+ * (A JSON room is an XML file converted to JSON so that it can be directly imported into your mod.)
+ *
  * Note that this function does not simply choose a random element in the provided array; it will
  * properly account for each room weight using the algorithm from:
  * https://stackoverflow.com/questions/1761626/weighted-random-numbers
@@ -6039,7 +6295,21 @@ export declare interface GridEntityCustomData {
     defaultAnimation?: string;
 }
 
-declare class GridEntityDetection extends Feature {
+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. */
@@ -6063,15 +6333,9 @@ declare class GridEntityDetection extends Feature {
     private checkGridEntityStateChanged;
     private checkNewGridEntity;
     private updateTupleInMap;
-    private postNewRoomReordered;
+    private postNewRoom;
 }
 
-declare type GridEntityTuple = [
-gridEntityType: GridEntityType,
-variant: int,
-state: int
-];
-
 /**
  * Helper function to convert a grid index to a grid position.
  *
@@ -6147,13 +6411,14 @@ export declare function hasFlyingTemporaryEffect(player: EntityPlayer): boolean;
 
 export declare function hasFlyingTransformation(player: EntityPlayer): boolean;
 
-/** After touching a white fire, a player will turn into The Lost until they clear a room. */
-export declare function hasLostCurse(player: EntityPlayer): boolean;
-
-declare type HasMethods<T> = {} extends {
+/** Helper type to check if an object or class has one or more functions/methods. */
+export declare type HasFunction<T> = Record<string, unknown> extends {
     [K in keyof T as T[K] extends Function ? K : never]-?: 1;
 } ? never : T;
 
+/** After touching a white fire, a player will turn into The Lost until they clear a room. */
+export declare function hasLostCurse(player: EntityPlayer): boolean;
+
 /**
  * Returns whether or not the player can hold an additional active item, beyond what they are
  * currently carrying. This takes the Schoolbag into account.
@@ -6322,10 +6587,10 @@ export declare function inHomeCloset(): boolean;
 /**
  * Initializes an array with all of the elements containing the specified default value.
  *
- * If the provided default value is not a boolean, number, or string, then it will be copied with
- * the `deepCopy` function before adding it to the new array. In this way, you can initialize an
- * array of arrays, or an array of maps, and so on. (If the `deepCopy` function was not used, then
- * all of the array elements would just be references to the same underlying data structure.)
+ * The provided default value will be copied with the `deepCopy` function before adding it to the
+ * new array. Thus, you can initialize an array of arrays, or an array of maps, and so on. (If the
+ * `deepCopy` function was not used, then all of the array elements would just be references to the
+ * same underlying data structure.)
  *
  * For example:
  *
@@ -6562,15 +6827,21 @@ export declare function isCardPickup(pickup: EntityPickup): pickup is EntityPick
 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"
+    CUSTOM_REVIVE = 0,
+    ESAU_JR_DETECTION = 1,
+    FLIP_DETECTION = 2,
+    GRID_ENTITY_COLLISION_DETECTION = 3,
+    GRID_ENTITY_RENDER_DETECTION = 4,
+    GRID_ENTITY_UPDATE_DETECTION = 5,
+    GAME_REORDERED_CALLBACKS = 6,
+    ITEM_PICKUP_DETECTION = 7,
+    PLAYER_COLLECTIBLE_DETECTION = 8,
+    PLAYER_REORDERED_CALLBACKS = 9,
+    SLOT_RENDER_DETECTION = 10,
+    SLOT_UPDATE_DETECTION = 11,
+    CUSTOM_GRID_ENTITIES = 12,
+    RUN_IN_N_FRAMES = 13,
+    SAVE_DATA_MANAGER = 14
 }
 
 declare interface ISCFeatureToClass {
@@ -6578,11 +6849,17 @@ declare interface ISCFeatureToClass {
     [ISCFeature.ESAU_JR_DETECTION]: EsauJrDetection;
     [ISCFeature.FLIP_DETECTION]: FlipDetection;
     [ISCFeature.GRID_ENTITY_COLLISION_DETECTION]: GridEntityCollisionDetection;
-    [ISCFeature.GRID_ENTITY_DETECTION]: GridEntityDetection;
+    [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_RENDER_DETECTION]: SlotRenderDetection;
+    [ISCFeature.SLOT_UPDATE_DETECTION]: SlotUpdateDetection;
     [ISCFeature.CUSTOM_GRID_ENTITIES]: CustomGridEntities;
     [ISCFeature.RUN_IN_N_FRAMES]: RunInNFrames;
+    [ISCFeature.SAVE_DATA_MANAGER]: SaveDataManager;
 }
 
 /**
@@ -6872,12 +7149,6 @@ export declare function isIsaacAPIClass(object: unknown): object is IsaacAPIClas
 
 export declare function isIsaacAPIClassOfType(object: unknown, classType: string): boolean;
 
-/**
- * Returns whether or not this is a class that is provided by the `isaacscript-common` library, such
- * as a `DefaultMap`.
- */
-export declare function isIsaacScriptCommonClass(object: unknown): boolean;
-
 /**
  * Helper function for detecting when a player is Jacob or Esau. This will only match the
  * non-tainted versions of these characters.
@@ -7128,14 +7399,14 @@ export declare function isSecretRoomDoor(door: GridEntityDoor): boolean;
 export declare function isSelfDamage(damageFlags: DamageFlag | BitFlags<DamageFlag>): boolean;
 
 /**
- * Used to determine is the given table is a serialized `BitSet128` object created by the save data
- * manager and/or the `deepCopy` function.
+ * Used to determine is the given table is a serialized `BitSet128` object created by the `deepCopy`
+ * function.
  */
 export declare function isSerializedBitSet128(object: unknown): object is SerializedBitSet128;
 
 /**
- * Used to determine is the given table is a serialized `Color` object created by the save data
- * manager and/or the `deepCopy` function.
+ * Used to determine is the given table is a serialized `Color` object created by the `deepCopy`
+ * function.
  */
 export declare function isSerializedColor(object: unknown): object is SerializedColor;
 
@@ -7148,20 +7419,20 @@ export declare function isSerializedColor(object: unknown): object is Serialized
 export declare function isSerializedIsaacAPIClass(object: unknown): object is SerializedIsaacAPIClass;
 
 /**
- * Used to determine is the given table is a serialized `KColor` object created by the save data
- * manager and/or the `deepCopy` function.
+ * Used to determine is the given table is a serialized `KColor` object created by the `deepCopy`
+ * function.
  */
 export declare function isSerializedKColor(object: unknown): object is SerializedKColor;
 
 /**
- * Used to determine is the given table is a serialized `RNG` object created by the save data
- * manager and/or the `deepCopy` function.
+ * Used to determine is the given table is a serialized `RNG` object created by the `deepCopy`
+ * function.
  */
 export declare function isSerializedRNG(object: unknown): object is SerializedRNG;
 
 /**
- * Used to determine is the given table is a serialized `Vector` object created by the save data
- * manager and/or the `deepCopy` function.
+ * Used to determine is the given table is a serialized `Vector` object created by the `deepCopy`
+ * function.
  */
 export declare function isSerializedVector(object: unknown): object is SerializedVector;
 
@@ -7310,12 +7581,6 @@ export declare function isVanillaPlayer(player: EntityPlayer): boolean;
 
 export declare function isVanillaTrinketType(trinketType: TrinketType): boolean;
 
-/**
- * Returns whether or not this is a class that is provided as part of the TypeScriptToLua
- * transpiler, such as a `Map` or a `Set`.
- */
-export declare function isVanillaTSTLClass(object: unknown): boolean;
-
 /**
  * Helper function to determine if a given grid index should have a wall generated by the vanilla
  * game. This is useful as a mechanism to distinguish between real walls and custom walls spawned by
@@ -7339,6 +7604,20 @@ 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 postPEffectUpdate;
+    private queueEmpty;
+    private queueNotEmpty;
+}
+
 /**
  * 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.
@@ -7519,8 +7798,6 @@ 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).
  *
@@ -7710,8 +7987,8 @@ export declare function logSet(set: Set<AnyNotNil> | ReadonlySet<AnyNotNil>): vo
 export declare function logSounds(): void;
 
 /**
- * Helper function for logging every key and value of a table. This is a deep log; the function will
- * recursively call itself if it counters a table within a table.
+ * Helper function for logging every key and value of a Lua table. This is a deep log; the function
+ * will recursively call itself if it counters a table within a table.
  *
  * This function will only work on tables that have string keys (because it logs the keys in order,
  * instead of randomly). It will throw a run-time error if it encounters a non-string key.
@@ -7724,6 +8001,14 @@ export declare function logTable(luaTable: unknown, parentTables?: number): void
  */
 export declare function logTableDifferences<K extends AnyNotNil, V>(table1: LuaMap<K, V>, table2: LuaMap<K, V>): void;
 
+/**
+ * Helper function to log the keys of a Lua table. This is not a deep log; only the keys of the
+ * top-most table will be logged.
+ *
+ * This function is useful for tables that have recursive references.
+ */
+export declare function logTableKeys(luaTable: unknown): void;
+
 /** Helper function for printing out every tear flag that is turned on. Useful when debugging. */
 export declare function logTearFlags(flags: TearFlag | BitFlags<TearFlag>): void;
 
@@ -7857,6 +8142,44 @@ export declare const MAX_SPEED_STAT = 2;
 /** Corresponds to the maximum value for `EntityPlayer.SamsonBerserkCharge`. */
 export declare const MAX_TAINTED_SAMSON_BERSERK_CHARGE = 100000;
 
+/**
+ * `merge` takes the values from a new table and recursively merges them into an old object (while
+ * performing appropriate deserialization).
+ *
+ * This function is used to merge incoming data from the "save#.dat" file into a mod's variables.
+ * Merging is useful instead of blowing away a table entirely because mod code often relies on the
+ * local table/object references.
+ *
+ * This function always assumes that the new table is serialized data and will attempt to perform
+ * deserialization on the objects within. In other words, unlike the `deepCopy` function, the
+ * `merge` function will always operates in the mode of `SerializationType.DESERIALIZE`. For the
+ * types of objects that will be deserialized, see the documentation for the `deepCopy` function.
+ *
+ * This function does not iterate over the old object, like you would naively expect. This is
+ * because it is common for a variable to have a type of `something | null`. If this is the case,
+ * the key would not appear when iterating over the old object (because a value of null transpiles
+ * to nil, which means the table key does not exist). Thus, we must instead iterate over the new
+ * object and copy the values backwards. The consequence of this is that `merge` can copy over old
+ * variables that are no longer used in the code, or copy over old variables of a different type,
+ * which can cause run-time errors. In such cases, users will have to manually delete their save
+ * data.
+ *
+ * @param oldObject The old object to merge the values into. This can be either a Lua table, a TSTL
+ *                  map, or a TSTL set.
+ * @param newTable The new table to merge the values from. This must be a Lua table that represents
+ *                 serialized data. In other words, it should be created with the `deepCopy`
+ *                 function using `SerializationType.SERIALIZE`.
+ * @param traversalDescription Used to track the current key that we are operating on for debugging
+ *                             purposes. Use a name that corresponds to the name of the merging
+ *                             table.
+ * @param classConstructors Optional. A Lua table that maps the name of a user-defined TSTL class to
+ *                          its corresponding constructor. If the `deepCopy` function finds any
+ *                          user-defined TSTL classes when recursively iterating through the given
+ *                          object, it will use this map to instantiate a new class. Default is an
+ *                          empty Lua table.
+ */
+export declare function merge(oldObject: LuaMap<AnyNotNil, unknown> | Map<AnyNotNil, unknown> | Set<AnyNotNil>, newTable: LuaMap<AnyNotNil, unknown>, traversalDescription: string, classConstructors?: LuaMap<string, AnyClass>): void;
+
 /** If you set `EntityPlayer.ShotSpeed` lower than this value, it will have no effect. */
 export declare const MIN_PLAYER_SHOT_SPEED_STAT = 0.6;
 
@@ -8607,9 +8930,11 @@ export declare enum ModCallbackCustom {
      * This callback is useful because many attributes cannot be set or retrieved properly in the
      * normal `POST_NPC_INIT` callback.
      *
-     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method, you can provide
-     * an optional third argument that will make the callback only fire if it matches the `EntityType`
-     * provided.
+     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+     * - You can provide an optional third argument that will make the callback only fire if it
+     *   matches the `EntityType` provided.
+     * - You can provide an optional fourth argument that will make the callback only fire if it
+     *   matches the variant provided.
      *
      * ```ts
      * function postNPCInitLate(npc: EntityNPC): void {}
@@ -8665,9 +8990,11 @@ export declare enum ModCallbackCustom {
      *
      * Use this callback to know when a pickup is added to the player's inventory or health.
      *
-     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method, you can provide
-     * an optional third argument that will make the callback only fire if it matches the
-     * `PickupVariant` provided.
+     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+     * - You can provide an optional third argument that will make the callback only fire if it
+     *   matches the `PickupVariant` provided.
+     * - You can provide an optional fourth argument that will make the callback only fire if it
+     *   matches the sub-type provided.
      *
      * ```ts
      * function postPickupCollect(pickup: EntityPickup, player: EntityPlayer): void {}
@@ -8681,9 +9008,11 @@ export declare enum ModCallbackCustom {
      * This callback is useful because pickups will despawn upon leaving the room and respawn upon
      * re-entering the room.
      *
-     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method, you can provide
-     * an optional third argument that will make the callback only fire if it matches the
-     * `PickupVariant` provided.
+     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+     * - You can provide an optional third argument that will make the callback only fire if it
+     *   matches the `PickupVariant` provided.
+     * - You can provide an optional fourth argument that will make the callback only fire if it
+     *   matches the sub-type provided.
      *
      * ```ts
      * function postPickupInitFirst(pickup: EntityPickup): void {}
@@ -8696,9 +9025,11 @@ export declare enum ModCallbackCustom {
      * This callback is useful because many attributes cannot be set or retrieved properly in the
      * normal `POST_PICKUP_INIT` callback.
      *
-     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method, you can provide
-     * an optional third argument that will make the callback only fire if it matches the
-     * `PickupVariant` provided.
+     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+     * - You can provide an optional third argument that will make the callback only fire if it
+     *   matches the `PickupVariant` provided.
+     * - You can provide an optional fourth argument that will make the callback only fire if it
+     *   matches the sub-type provided.
      *
      * ```ts
      * function postPickupInitLate(pickup: EntityPickup): void {}
@@ -8709,9 +9040,11 @@ export declare enum ModCallbackCustom {
      * Fires from the `POST_PICKUP_UPDATE` callback when a pickup's state has changed from what it was
      * on the previous frame. (In this context, "state" refers to the `EntityPickup.State` field.)
      *
-     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method, you can provide
-     * an optional third argument that will make the callback only fire if it matches the
-     * `PickupVariant` provided.
+     * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+     * - You can provide an optional third argument that will make the callback only fire if it
+     *   matches the `PickupVariant` provided.
+     * - You can provide an optional fourth argument that will make the callback only fire if it
+     *   matches the sub-type provided.
      *
      * ```ts
      * function postPickupStateChanged(
@@ -8787,13 +9120,13 @@ export declare enum ModCallbackCustom {
      *   matches the `PlayerType` provided.
      *
      * ```ts
-     * function postPlayerChangeStat(
+     * function postPlayerChangeStat<T extends StatType>(
      *   player: EntityPlayer,
-     *   statType: StatType,
+     *   statType: T,
      *   difference: int,
-     *   oldValue: number | boolean | BitFlags<TearFlag> | Color | Vector,
-     *   newValue: number | boolean | BitFlags<TearFlag> | Color | Vector,
-     * ): void {}
+     *   oldValue: StatTypeType[T],
+     *   newValue: StatTypeType[T],
+     * ) => void {}
      * ```
      */
     POST_PLAYER_CHANGE_STAT = 55,
@@ -9068,6 +9401,10 @@ export declare enum ModCallbackCustom {
      * Fires from the `POST_UPDATE` callback when the clear state of a room changes (as according to
      * the `Room.IsClear` method).
      *
+     * For example, this callback fires when you defeat all the enemies in a room (clear --> not
+     * clear) or when you bomb an angel statue (not clear --> clear). This callback does not fire when
+     * you travel between a cleared room and an uncleared room.
+     *
      * When registering the callback with the `ModUpgraded.AddCallbackCustom` method, you can provide
      * an optional third argument that will make the callback only fire if the room clear state
      * matches the boolean provided.
@@ -9416,43 +9753,98 @@ export declare enum ModCallbackCustom2 {
     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
+    POST_GRID_ENTITY_CUSTOM_RENDER = 29,
+    POST_GRID_ENTITY_CUSTOM_STATE_CHANGED = 30,
+    POST_GRID_ENTITY_CUSTOM_UPDATE = 31,
+    POST_GRID_ENTITY_INIT = 32,
+    POST_GRID_ENTITY_REMOVE = 33,
+    POST_GRID_ENTITY_RENDER = 34,
+    POST_GRID_ENTITY_STATE_CHANGED = 35,
+    POST_GRID_ENTITY_UPDATE = 36,
+    POST_HOLY_MANTLE_REMOVED = 37,
+    POST_ITEM_DISCHARGE = 38,
+    POST_ITEM_PICKUP = 39,
+    POST_KNIFE_INIT_LATE = 40,
+    POST_LASER_INIT_LATE = 41,
+    POST_NEW_LEVEL_REORDERED = 42,
+    POST_NEW_ROOM_EARLY = 43,
+    POST_NEW_ROOM_REORDERED = 44,
+    POST_NPC_INIT_LATE = 45,
+    POST_NPC_STATE_CHANGED = 46,
+    POST_PEFFECT_UPDATE_REORDERED = 47,
+    POST_PICKUP_COLLECT = 48,
+    POST_PICKUP_INIT_FIRST = 49,
+    POST_PICKUP_INIT_LATE = 50,
+    POST_PICKUP_STATE_CHANGED = 51,
+    POST_PIT_RENDER = 52,
+    POST_PIT_UPDATE = 53,
+    POST_PLAYER_CHANGE_HEALTH = 54,
+    POST_PLAYER_CHANGE_STAT = 55,
+    POST_PLAYER_CHANGE_TYPE = 56,
+    POST_PLAYER_COLLECTIBLE_ADDED = 57,
+    POST_PLAYER_COLLECTIBLE_REMOVED = 58,
+    POST_PLAYER_FATAL_DAMAGE = 59,
+    POST_PLAYER_INIT_FIRST = 60,
+    POST_PLAYER_INIT_LATE = 61,
+    POST_PLAYER_RENDER_REORDERED = 62,
+    POST_PLAYER_UPDATE_REORDERED = 63,
+    POST_POOP_RENDER = 64,
+    POST_POOP_UPDATE = 65,
+    POST_PRESSURE_PLATE_RENDER = 66,
+    POST_PRESSURE_PLATE_UPDATE = 67,
+    POST_PROJECTILE_INIT_LATE = 68,
+    POST_PURCHASE = 69,
+    POST_ROCK_RENDER = 70,
+    POST_ROCK_UPDATE = 71,
+    POST_ROOM_CLEAR_CHANGED = 72,
+    POST_SACRIFICE = 73,
+    POST_SLOT_ANIMATION_CHANGED = 74,
+    POST_SLOT_COLLISION = 75,
+    POST_SLOT_DESTROYED = 76,
+    POST_SLOT_INIT = 77,
+    POST_SLOT_RENDER = 78,
+    POST_SLOT_UPDATE = 79,
+    POST_SPIKES_RENDER = 80,
+    POST_SPIKES_UPDATE = 81,
+    POST_TEAR_INIT_LATE = 82,
+    POST_TEAR_INIT_VERY_LATE = 83,
+    POST_TNT_RENDER = 84,
+    POST_TNT_UPDATE = 85,
+    POST_TRANSFORMATION = 86,
+    PRE_BERSERK_DEATH = 87,
+    PRE_CUSTOM_REVIVE = 88,
+    PRE_ITEM_PICKUP = 89
 }
 
+declare type ModCallbackCustomCollectibleType = MatchingCallbackCustom<CallbackSignatureCollectibleType>;
+
 declare type ModCallbackCustomGridEntity = MatchingCallbackCustom<CallbackSignatureGridEntity>;
 
 declare type ModCallbackCustomGridEntityCustom = MatchingCallbackCustom<CallbackSignatureGridEntityCustom>;
 
+declare type ModCallbackCustomItemPickup = MatchingCallbackCustom<CallbackSignatureItemPickup>;
+
 declare type ModCallbackCustomPlayer = MatchingCallbackCustom<CallbackSignaturePlayer>;
 
-declare type ModCallbackCustomRevive = MatchingCallbackCustom<CallbackSignatureRevive>;
+declare type ModCallbackCustomSlot = MatchingCallbackCustom<CallbackSignatureSlot>;
 
 /**
- * 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.
+ * A helper class for mods that wants 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.
+ *
+ * For example:
+ *
+ * ```ts
+ * export class MyFeature extends ModFeature {
+ *   @Callback(ModCallback.POST_GAME_STARTED)
+ *   postGameStarted(isContinued: boolean): void {
+ *     Isaac.DebugString(`Callback fired: POST_GAME_STARTED`);
+ *   }
+ * }
+ * ```
  */
 export declare class ModFeature {
-    private mod;
     constructor(mod: ModUpgraded);
 }
 
@@ -9464,10 +9856,6 @@ export declare class ModFeature {
  * To upgrade your mod, use the `upgradeMod` helper function.
  */
 export declare class ModUpgraded implements Mod {
-    /**
-     * 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. */
     private mod;
@@ -9517,23 +9905,28 @@ export declare class ModUpgraded implements Mod {
      */
     RemoveCallbackCustom<T extends ModCallbackCustom2>(modCallbackCustom: T, callback: AddCallbackParametersCustom2[T][0]): void;
     /**
-     * This method should only be used by the `upgradeMod` function. Returns the names of the exported
-     * class methods from the features that were added.
+     * This is used to initialize both custom callbacks and "extra features".
+     *
+     * This mirrors the `uninitFeature` method.
      */
-    initOptionalFeature(feature: ISCFeature): FunctionTuple[];
-    /** This is used to initialize both custom callbacks and "extra features". */
     private initFeature;
+    /**
+     * This is used to uninitialize both custom callbacks and "extra features".
+     *
+     * This mirrors the `initFeature` method.
+     */
     private uninitFeature;
+    /** Returns the names of the exported class methods from the features that were added. */
+    private initOptionalFeature;
 }
 
 /**
  * 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.
+ * We have to explicitly account for the empty array case, since the `never` will mess up the union.
  */
-declare type ModUpgradedWithFeatures<T extends ISCFeature> = [T] extends [never] ? ModUpgraded : Omit<ModUpgraded & UnionToIntersection<ISCFeatureToClass[T]>, KeysToScrubFromModClass>;
+declare type ModUpgradedWithFeatures<T extends ISCFeature> = [T] extends [never] ? ModUpgraded : ModUpgraded & Omit<UnionToIntersection<ISCFeatureToClass[T]>, keyof Feature>;
 
 /**
  * Helper function to move all of the players to where they would normally go when arriving at a new
@@ -9820,6 +10213,46 @@ 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 runInNFrames;
+    constructor(postPlayerCollectibleAdded: PostPlayerCollectibleAdded, postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved, 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;
+    private postPEffectUpdate;
+    /**
+     * 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;
+    private entityTakeDmgPlayer;
+}
+
 export declare function playerConvertBlackHeartsToSoulHearts(player: EntityPlayer): void;
 
 export declare function playerConvertSoulHeartsToBlackHearts(player: EntityPlayer): void;
@@ -9957,8 +10390,9 @@ playerVariant?: PlayerVariant,
 character?: PlayerType
 ];
 
-declare class PostCustomRevive extends CustomCallbackRevive<ModCallbackCustom2.POST_CUSTOM_REVIVE> {
+declare class PostCustomRevive extends CustomCallback<ModCallbackCustom2.POST_CUSTOM_REVIVE> {
     constructor();
+    protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
 }
 
 declare type PostCustomReviveRegisterParameters = [
@@ -10063,9 +10497,9 @@ gridEntityType?: GridEntityType,
 variant?: int
 ];
 
-declare class PostGridEntityCollision extends CustomCallback<T> {
+declare class PostGridEntityCollision extends CustomCallback<T_2> {
     constructor();
-    protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
+    protected shouldFire(fireArgs: FireArgs<T_2>, optionalArgs: OptionalArgs<T_2>): boolean;
 }
 
 declare type PostGridEntityCollisionRegisterParameters = [
@@ -10085,9 +10519,9 @@ callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void
 gridEntityTypeCustom?: GridEntityType
 ];
 
-declare class PostGridEntityCustomCollision extends CustomCallback<T_2> {
+declare class PostGridEntityCustomCollision extends CustomCallback<T_3> {
     constructor();
-    protected shouldFire(fireArgs: FireArgs<T_2>, optionalArgs: OptionalArgs<T_2>): boolean;
+    protected shouldFire(fireArgs: FireArgs<T_3>, optionalArgs: OptionalArgs<T_3>): boolean;
 }
 
 declare type PostGridEntityCustomCollisionRegisterParameters = [
@@ -10106,9 +10540,9 @@ callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void
 gridEntityTypeCustom?: GridEntityType
 ];
 
-declare class PostGridEntityCustomRemove extends CustomCallback<T_4> {
+declare class PostGridEntityCustomRemove extends CustomCallback<T_5> {
     constructor();
-    protected shouldFire(fireArgs: FireArgs<T_4>, optionalArgs: OptionalArgs<T_4>): boolean;
+    protected shouldFire(fireArgs: FireArgs<T_5>, optionalArgs: OptionalArgs<T_5>): boolean;
 }
 
 declare type PostGridEntityCustomRemoveRegisterParameters = [
@@ -10116,6 +10550,10 @@ callback: (gridIndex: int, gridEntityTypeCustom: GridEntityType) => void,
 gridEntityTypeCustom?: GridEntityType
 ];
 
+declare class PostGridEntityCustomRender extends CustomCallbackGridEntityCustom<ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_RENDER> {
+    constructor();
+}
+
 declare type PostGridEntityCustomRenderRegisterParameters = [
 callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
 gridEntityTypeCustom?: GridEntityType
@@ -10149,9 +10587,9 @@ gridEntityType?: GridEntityType,
 variant?: int
 ];
 
-declare class PostGridEntityRemove extends CustomCallback<T_3> {
+declare class PostGridEntityRemove extends CustomCallback<T_4> {
     constructor();
-    protected shouldFire(fireArgs: FireArgs<T_3>, optionalArgs: OptionalArgs<T_3>): boolean;
+    protected shouldFire(fireArgs: FireArgs<T_4>, optionalArgs: OptionalArgs<T_4>): boolean;
 }
 
 declare type PostGridEntityRemoveRegisterParameters = [
@@ -10160,6 +10598,10 @@ gridEntityType?: GridEntityType,
 variant?: int
 ];
 
+declare class PostGridEntityRender extends CustomCallbackGridEntity<ModCallbackCustom2.POST_GRID_ENTITY_RENDER> {
+    constructor();
+}
+
 declare type PostGridEntityRenderRegisterParameters = [
 callback: (gridEntity: GridEntity) => void,
 gridEntityType?: GridEntityType,
@@ -10197,6 +10639,10 @@ callback: (player: EntityPlayer, collectibleType: CollectibleType, activeSlot: A
 collectibleType?: CollectibleType
 ];
 
+declare class PostItemPickup extends CustomCallbackItemPickup<ModCallbackCustom2.POST_ITEM_PICKUP> {
+    constructor();
+}
+
 declare type PostItemPickupRegisterParameters = [callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => void] | [
 callback: (player: EntityPlayer, pickingUpItem: PickingUpItemCollectible) => void,
 itemType: ItemType.PASSIVE | ItemType.ACTIVE | ItemType.FAMILIAR,
@@ -10299,11 +10745,19 @@ callback: (player: EntityPlayer, oldCharacter: PlayerType, newCharacter: PlayerT
 playerVariant?: PlayerVariant
 ];
 
+declare class PostPlayerCollectibleAdded extends CustomCallbackCollectibleType<ModCallbackCustom2.POST_PLAYER_COLLECTIBLE_ADDED> {
+    constructor();
+}
+
 declare type PostPlayerCollectibleAddedRegisterParameters = [
 callback: (player: EntityPlayer, collectibleType: CollectibleType) => void,
 collectibleType?: CollectibleType
 ];
 
+declare class PostPlayerCollectibleRemoved extends CustomCallbackCollectibleType<ModCallbackCustom2.POST_PLAYER_COLLECTIBLE_REMOVED> {
+    constructor();
+}
+
 declare type PostPlayerCollectibleRemovedRegisterParameters = [
 callback: (player: EntityPlayer, collectibleType: CollectibleType) => void,
 collectibleType?: CollectibleType
@@ -10399,6 +10853,10 @@ playerVariant?: PlayerVariant,
 character?: PlayerType
 ];
 
+declare class PostSlotAnimationChanged extends CustomCallbackSlot<ModCallbackCustom2.POST_SLOT_ANIMATION_CHANGED> {
+    constructor();
+}
+
 declare type PostSlotAnimationChangedRegisterParameters = [
 callback: (slot: EntitySlot, previousAnimation: string, currentAnimation: string) => void,
 slotVariant?: SlotVariant
@@ -10415,16 +10873,28 @@ slotVariant?: SlotVariant,
 slotDestructionType?: SlotDestructionType
 ];
 
+declare class PostSlotInit extends CustomCallbackSlot<ModCallbackCustom2.POST_SLOT_INIT> {
+    constructor();
+}
+
 declare type PostSlotInitRegisterParameters = [
 callback: (slot: EntitySlot) => void,
 slotVariant?: SlotVariant
 ];
 
+declare class PostSlotRender extends CustomCallbackSlot<ModCallbackCustom2.POST_SLOT_RENDER> {
+    constructor();
+}
+
 declare type PostSlotRenderRegisterParameters = [
 callback: (slot: EntitySlot) => void,
 slotVariant?: SlotVariant
 ];
 
+declare class PostSlotUpdate extends CustomCallbackSlot<ModCallbackCustom2.POST_SLOT_UPDATE> {
+    constructor();
+}
+
 declare type PostSlotUpdateRegisterParameters = [
 callback: (slot: EntitySlot) => void,
 slotVariant?: SlotVariant
@@ -10492,6 +10962,10 @@ playerVariant?: PlayerVariant,
 character?: PlayerType
 ];
 
+declare class PreItemPickup extends CustomCallbackItemPickup<ModCallbackCustom2.PRE_ITEM_PICKUP> {
+    constructor();
+}
+
 declare type PreItemPickupRegisterParameters = [callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => void] | [
 callback: (player: EntityPlayer, pickingUpItem: PickingUpItemCollectible) => void,
 itemType: ItemType.PASSIVE | ItemType.ACTIVE | ItemType.FAMILIAR,
@@ -10589,6 +11063,39 @@ export declare function registerCharacterHealthConversion(playerType: PlayerType
  */
 export declare function registerCharacterStats(playerType: PlayerType, statMap: Map<CacheFlag, number> | ReadonlyMap<CacheFlag, number>): void;
 
+/**
+ * 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.
+ *
+ * @param itemPoolTypeCustom An integer that identifies what kind of item pool you are creating. It
+ *                           should correspond to a local enum value created in your mod. The
+ *                           integer can be any unique value and can safely overlap with the vanilla
+ *                           item pool type values.
+ * @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.
+ */
+export declare function registerCustomItemPool(itemPoolTypeCustom: ItemPoolType, collectibles: WeightedArray<CollectibleType>): void;
+
 /**
  * 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.
@@ -11523,8 +12030,7 @@ export declare function runInNGameFrames(func: () => void, gameFrames: int): voi
 export declare function runInNRenderFrames(func: () => void, renderFrames: int): void;
 
 /**
- * Run the suite of tests that prove that the "merge" function works properly. (This function is not
- * exported but is used internally in the save data manager.)
+ * Run the suite of tests that prove that the "merge" function works properly.
  *
  * This function is only useful if you are troubleshooting the save data manager.
  */
@@ -11574,7 +12080,7 @@ export declare function runNextRenderFrame(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.
  *
- * Depending on which object keys you use, the variables will be automatically reset at certain
+ * Depending on which object keys you use, the variables will automatically be reset at certain
  * times and automatically saved to disk.
  *
  * Each sub-object of save data has a string as a key and arbitrary data as a value. However, the
@@ -11609,6 +12115,216 @@ 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;
+    constructor(mod: Mod);
+    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.)
+     *
+     * 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.
+     *
+     * Note that before using the save data manager, you must call the `upgradeMod` function. (Upgrade
+     * your mod before registering any of your own callbacks so that the save data manager will run
+     * before any of your code does.)
+     *
+     * 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 Hour Glass, 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 Hour Glass
+     * 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.
+     * @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, // This is the overload for the standard case with serializable data.
+    v: SaveData<Persistent, Run, Level>, conditionalFunc?: () => boolean): void;
+    saveDataManager(key: string, // This is the overload for the case when saving data is disabled.
+    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.
+     */
+    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.
+     */
+    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)`
+     */
+    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.
+     */
+    saveDataManagerRegisterClass(...tstlClasses: AnyClass[]): void;
+    /**
+     * Removes a previously registered key from the save data manager. This is the opposite of the
+     * "saveDataManager" method.
+     */
+    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");
+     * ```
+     */
+    saveDataManagerReset(key: string, childObjectKey: SaveDataKey): void;
+}
+
 /**
  * This is the entry point to the save data manager, a system which provides two major features:
  *
@@ -11705,11 +12421,9 @@ export declare enum SaveDataKey {
  *                        will allow you to use non-serializable objects in your save data, such as
  *                        `EntityPtr`.
  */
-export declare function saveDataManager<Persistent, Run, Level>(key: string, // This is the overload for the standard case with serializable data.
-v: SaveData<Persistent, Run, Level>, conditionalFunc?: () => boolean): void;
+export declare function saveDataManager<Persistent, Run, Level>(key: string, v: SaveData<Persistent, Run, Level>, conditionalFunc?: () => boolean): void;
 
-export declare function saveDataManager(key: string, // This is the overload for the case when saving data is disabled.
-v: SaveData, conditionalFunc: false): void;
+export declare function saveDataManager(key: string, v: SaveData, conditionalFunc: false): void;
 
 /**
  * The save data manager will automatically load variables from disk at the appropriate times (i.e.
@@ -11721,6 +12435,18 @@ v: SaveData, conditionalFunc: false): void;
  */
 export declare function saveDataManagerLoad(): void;
 
+/**
+ * By default, the save data manager will not be able to serialize 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 a class
+ * constructor with the save data manager. If the save data manager finds a registered class of the
+ * same name when deserializing, it will automatically run the registered constructor (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.
+ */
+export declare function saveDataManagerRegisterClass(...tstlClasses: AnyClass[]): void;
+
 /**
  * Removes a previously registered key from the save data manager. This is the opposite of the
  * "saveDataManager" function.
@@ -11781,9 +12507,9 @@ declare type SerializableArray<T> = Array<SerializableInsideArrayOrMap<T>>;
 
 /**
  * This is mostly copied from the `Serializable` type. The difference is that we want to disallow
- * classes with methods.
+ * functions inside of containers.
  */
-declare type SerializableInsideArrayOrMap<T> = T extends SerializablePrimitive ? T : T extends CopyableIsaacAPIClass ? T : T extends IsaacAPIClass ? ErrorIsaacAPIClassIsNotSerializable : T extends Array<infer U> ? SerializableArray<U> : T extends ReadonlyArray<infer U> ? SerializableReadonlyArray<U> : T extends Map<infer K, infer V> ? SerializableMap<K, V> : T extends ReadonlyMap<infer K, infer V> ? SerializableReadonlyMap<K, V> : T extends Set<infer V> ? SerializableSet<V> : T extends ReadonlySet<infer V> ? SerializableReadonlySet<V> : T extends HasMethods<T> ? ErrorCustomClassNotSerializable : T extends Function ? FunctionIsNotSerializable : SerializableObject<T>;
+declare type SerializableInsideArrayOrMap<T> = T extends SerializablePrimitive ? T : T extends CopyableIsaacAPIClass ? T : T extends IsaacAPIClass ? ErrorIsaacAPIClassIsNotSerializable : T extends Array<infer U> ? SerializableArray<U> : T extends ReadonlyArray<infer U> ? SerializableReadonlyArray<U> : T extends Map<infer K, infer V> ? SerializableMap<K, V> : T extends ReadonlyMap<infer K, infer V> ? SerializableReadonlyMap<K, V> : T extends Set<infer V> ? SerializableSet<V> : T extends ReadonlySet<infer V> ? SerializableReadonlySet<V> : T extends Function ? FunctionIsNotSerializable : SerializableObject<T>;
 
 declare type SerializableMap<K, V> = Map<SerializableInsideArrayOrMap<K>, SerializableInsideArrayOrMap<V>>;
 
@@ -11801,6 +12527,46 @@ declare type SerializableReadonlySet<T> = ReadonlySet<SerializableInsideArrayOrM
 
 declare type SerializableSet<T> = Set<SerializableInsideArrayOrMap<T>>;
 
+/**
+ * During serialization, we write an arbitrary string key to the object with a value of an empty
+ * string. This is used during deserialization to instantiate the correct type of object.
+ *
+ * Note that we do not bother branding TSTL classes because we have no way to run the proper
+ * constructor during deserialization.
+ */
+export declare enum SerializationBrand {
+    DEFAULT_MAP = "__TSTL_DEFAULT_MAP",
+    MAP = "__TSTL_MAP",
+    SET = "__TSTL_SET",
+    BIT_SET_128 = "__BIT_SET_128",
+    COLOR = "__COLOR",
+    K_COLOR = "__K_COLOR",
+    RNG = "__RNG",
+    VECTOR = "__VECTOR",
+    /**
+     * This is set to the value that represents the default value (instead of an empty string like the
+     * other brands are).
+     */
+    DEFAULT_MAP_VALUE = "__TSTL_DEFAULT_MAP_VALUE",
+    /**
+     * The JSON library is unable to distinguish between a maps with number keys and an array. It will
+     * assume that both of these are an array. Thus, in the case of a map with number keys, it will
+     * insert null in every empty spot, leading to crashes.
+     *
+     * For example, a map with keys of 5 and 10 would be converted to the following array: `[null,
+     * null, null, null, "myValueForKey5", null, null, null, null, "myValueForKey10"]`
+     *
+     * The deep copier works around this by converting number keys to strings. It inserts this brand
+     * to keep track of the mutation.
+     */
+    OBJECT_WITH_NUMBER_KEYS = "__TSTL_OBJECT_WITH_NUMBER_KEYS",
+    /**
+     * This brand represents a user-defined class other than a `DefaultMap`, `Map`, or `Set`. It will
+     * have a string value that corresponds to the name of the class.
+     */
+    TSTL_CLASS = "__TSTL_CLASS"
+}
+
 /** This is used with the `deepCopy` and `merge` functions. */
 export declare enum SerializationType {
     NONE = 0,
@@ -12467,6 +13233,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
@@ -13095,13 +13889,15 @@ 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 = ModCallbackCustom2.POST_CUSTOM_REVIVE;
+
+declare type T_2 = ModCallbackCustom2.POST_GRID_ENTITY_COLLISION;
 
-declare type T_2 = ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_COLLISION;
+declare type T_3 = ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_COLLISION;
 
-declare type T_3 = ModCallbackCustom2.POST_GRID_ENTITY_REMOVE;
+declare type T_4 = ModCallbackCustom2.POST_GRID_ENTITY_REMOVE;
 
-declare type T_4 = ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_REMOVE;
+declare type T_5 = ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_REMOVE;
 
 /**
  * Helper function to check if a Lua table has all of the provided keys.