isaacscript-common 87.9.5 → 87.9.7

package/dist/index.rollup.d.ts

@@ -91,181 +91,185 @@ export declare type Add<A extends number, B extends number> = Length<[
 ]>;
 
 declare interface AddCallbackParametersCustom {
-    [ModCallbackCustom.ENTITY_TAKE_DMG_FILTER]: [
+    readonly [ModCallbackCustom.ENTITY_TAKE_DMG_FILTER]: readonly [
     callback: (entity: Entity, amount: float, damageFlags: BitFlags<DamageFlag>, source: EntityRef, countdownFrames: int) => boolean | undefined,
     entityType?: EntityType,
     variant?: number,
     subType?: number
     ];
-    [ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER]: [
+    readonly [ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER]: readonly [
     callback: (player: EntityPlayer, amount: float, damageFlags: BitFlags<DamageFlag>, source: EntityRef, countdownFrames: int) => boolean | undefined,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.INPUT_ACTION_FILTER]: [
+    readonly [ModCallbackCustom.INPUT_ACTION_FILTER]: readonly [
     callback: (entity: Entity | undefined, inputHook: InputHook, buttonAction: ButtonAction) => boolean | float | undefined,
     inputHook?: InputHook,
     buttonAction?: ButtonAction
     ];
-    [ModCallbackCustom.INPUT_ACTION_PLAYER]: [
+    readonly [ModCallbackCustom.INPUT_ACTION_PLAYER]: readonly [
     callback: (player: EntityPlayer, inputHook: InputHook, buttonAction: ButtonAction) => boolean | float | undefined,
     playerVariant?: PlayerVariant,
     character?: PlayerType,
     inputHook?: InputHook,
     buttonAction?: ButtonAction
     ];
-    [ModCallbackCustom.POST_AMBUSH_FINISHED]: [
+    readonly [ModCallbackCustom.POST_AMBUSH_FINISHED]: readonly [
     callback: (ambushType: AmbushType) => void,
     ambushType?: AmbushType
     ];
-    [ModCallbackCustom.POST_AMBUSH_STARTED]: [
+    readonly [ModCallbackCustom.POST_AMBUSH_STARTED]: readonly [
     callback: (ambushType: AmbushType) => void,
     ambushType?: AmbushType
     ];
-    [ModCallbackCustom.POST_BOMB_EXPLODED]: [
+    readonly [ModCallbackCustom.POST_BOMB_EXPLODED]: readonly [
     callback: (bomb: EntityBomb) => void,
     bombVariant?: BombVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_BOMB_INIT_FILTER]: [
+    readonly [ModCallbackCustom.POST_BOMB_INIT_FILTER]: readonly [
     callback: (bomb: EntityBomb) => void,
     bombVariant?: BombVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_BOMB_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_BOMB_INIT_LATE]: readonly [
     callback: (bomb: EntityBomb) => void,
     bombVariant?: BombVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_BOMB_RENDER_FILTER]: [
+    readonly [ModCallbackCustom.POST_BOMB_RENDER_FILTER]: readonly [
     callback: (bomb: EntityBomb, renderOffset: Vector) => void,
     bombVariant?: BombVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_BOMB_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.POST_BOMB_UPDATE_FILTER]: readonly [
     callback: (bomb: EntityBomb) => void,
     bombVariant?: BombVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_BONE_SWING]: [callback: (knife: EntityKnife) => void];
-    [ModCallbackCustom.POST_COLLECTIBLE_EMPTY]: [
+    readonly [ModCallbackCustom.POST_BONE_SWING]: readonly [
+    callback: (knife: EntityKnife) => void
+    ];
+    readonly [ModCallbackCustom.POST_COLLECTIBLE_EMPTY]: readonly [
     callback: (collectible: EntityPickupCollectible, oldCollectibleType: CollectibleType) => void,
     collectibleType?: CollectibleType
     ];
-    [ModCallbackCustom.POST_CURSED_TELEPORT]: [
+    readonly [ModCallbackCustom.POST_CURSED_TELEPORT]: readonly [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_CUSTOM_REVIVE]: [
+    readonly [ModCallbackCustom.POST_CUSTOM_REVIVE]: readonly [
     callback: (player: EntityPlayer, revivalType: int) => void,
     revivalType?: int
     ];
-    [ModCallbackCustom.POST_DICE_ROOM_ACTIVATED]: [
+    readonly [ModCallbackCustom.POST_DICE_ROOM_ACTIVATED]: readonly [
     callback: (player: EntityPlayer, diceFloorSubType: DiceFloorSubType) => void,
     diceFloorSubType?: DiceFloorSubType
     ];
-    [ModCallbackCustom.POST_DOOR_RENDER]: [
+    readonly [ModCallbackCustom.POST_DOOR_RENDER]: readonly [
     callback: (door: GridEntityDoor) => void,
     doorVariant?: DoorVariant
     ];
-    [ModCallbackCustom.POST_DOOR_UPDATE]: [
+    readonly [ModCallbackCustom.POST_DOOR_UPDATE]: readonly [
     callback: (door: GridEntityDoor) => void,
     doorVariant?: DoorVariant
     ];
-    [ModCallbackCustom.POST_EFFECT_INIT_FILTER]: [
+    readonly [ModCallbackCustom.POST_EFFECT_INIT_FILTER]: readonly [
     callback: (effect: EntityEffect) => void,
     effectVariant?: EffectVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_EFFECT_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_EFFECT_INIT_LATE]: readonly [
     callback: (effect: EntityEffect) => void,
     effectVariant?: EffectVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_EFFECT_RENDER_FILTER]: [
+    readonly [ModCallbackCustom.POST_EFFECT_RENDER_FILTER]: readonly [
     callback: (effect: EntityEffect, renderOffset: Vector) => void,
     effectVariant?: EffectVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_EFFECT_STATE_CHANGED]: [
+    readonly [ModCallbackCustom.POST_EFFECT_STATE_CHANGED]: readonly [
     callback: (effect: EntityEffect, previousState: int, currentState: int) => void,
     effectVariant?: EffectVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_EFFECT_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.POST_EFFECT_UPDATE_FILTER]: readonly [
     callback: (effect: EntityEffect) => void,
     effectVariant?: EffectVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_ENTITY_KILL_FILTER]: [
+    readonly [ModCallbackCustom.POST_ENTITY_KILL_FILTER]: readonly [
     callback: (entity: Entity) => void,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.POST_ENTITY_REMOVE_FILTER]: [
+    readonly [ModCallbackCustom.POST_ENTITY_REMOVE_FILTER]: readonly [
     callback: (entity: Entity) => void,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.POST_ESAU_JR]: [callback: (player: EntityPlayer) => void];
-    [ModCallbackCustom.POST_FAMILIAR_INIT_FILTER]: [
+    readonly [ModCallbackCustom.POST_ESAU_JR]: readonly [
+    callback: (player: EntityPlayer) => void
+    ];
+    readonly [ModCallbackCustom.POST_FAMILIAR_INIT_FILTER]: readonly [
     callback: (familiar: EntityFamiliar) => void,
     familiarVariant?: FamiliarVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_FAMILIAR_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_FAMILIAR_INIT_LATE]: readonly [
     callback: (familiar: EntityFamiliar) => void,
     familiarVariant?: FamiliarVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_FAMILIAR_RENDER_FILTER]: [
+    readonly [ModCallbackCustom.POST_FAMILIAR_RENDER_FILTER]: readonly [
     callback: (familiar: EntityFamiliar, renderOffset: Vector) => void,
     familiarVariant?: FamiliarVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_FAMILIAR_STATE_CHANGED]: [
+    readonly [ModCallbackCustom.POST_FAMILIAR_STATE_CHANGED]: readonly [
     callback: (familiar: EntityFamiliar, previousState: int, currentState: int) => void,
     familiarVariant?: FamiliarVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_FAMILIAR_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.POST_FAMILIAR_UPDATE_FILTER]: readonly [
     callback: (familiar: EntityFamiliar) => void,
     familiarVariant?: FamiliarVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_FIRST_ESAU_JR]: [
+    readonly [ModCallbackCustom.POST_FIRST_ESAU_JR]: readonly [
     callback: (player: EntityPlayer) => void
     ];
-    [ModCallbackCustom.POST_FIRST_FLIP]: [
+    readonly [ModCallbackCustom.POST_FIRST_FLIP]: readonly [
     callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void
     ];
-    [ModCallbackCustom.POST_FLIP]: [
+    readonly [ModCallbackCustom.POST_FLIP]: readonly [
     callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void
     ];
-    [ModCallbackCustom.POST_GAME_END_FILTER]: [
+    readonly [ModCallbackCustom.POST_GAME_END_FILTER]: readonly [
     callback: (isGameOver: boolean) => void,
     isGameOver?: boolean
     ];
-    [ModCallbackCustom.POST_GAME_STARTED_REORDERED]: [
+    readonly [ModCallbackCustom.POST_GAME_STARTED_REORDERED]: readonly [
     callback: (isContinued: boolean) => void,
     isContinued: boolean | undefined
     ];
-    [ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST]: [
+    readonly [ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST]: readonly [
     callback: (isContinued: boolean) => void,
     isContinued: boolean | undefined
     ];
-    [ModCallbackCustom.POST_GREED_MODE_WAVE]: [
+    readonly [ModCallbackCustom.POST_GREED_MODE_WAVE]: readonly [
     callback: (oldWave: int, newWave: int) => void
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_BROKEN]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_BROKEN]: readonly [
     callback: (gridEntity: GridEntity) => void,
     gridEntityType?: GridEntityType,
     variant?: int
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_COLLISION]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_COLLISION]: readonly [
     callback: (gridEntity: GridEntity, entity: Entity) => void,
     gridEntityType?: GridEntityType,
     gridEntityVariant?: int,
@@ -273,505 +277,509 @@ declare interface AddCallbackParametersCustom {
     entityVariant?: int,
     entitySubType?: int
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN]: readonly [
     callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
     gridEntityTypeCustom?: GridEntityType
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_COLLISION]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_COLLISION]: readonly [
     callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType, entity: Entity) => void,
     gridEntityTypeCustom?: GridEntityType,
     entityType?: EntityType,
     entityVariant?: int,
     entitySubType?: int
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_INIT]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_INIT]: readonly [
     callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
     gridEntityTypeCustom?: GridEntityType
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_REMOVE]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_REMOVE]: readonly [
     callback: (gridIndex: int, gridEntityTypeCustom: GridEntityType) => void,
     gridEntityTypeCustom?: GridEntityType
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_RENDER]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_RENDER]: readonly [
     callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
     gridEntityTypeCustom?: GridEntityType
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED]: readonly [
     callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType, oldState: int, newState: int) => void,
     gridEntityTypeCustom?: GridEntityType
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE]: readonly [
     callback: (gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void,
     gridEntityTypeCustom?: GridEntityType
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_INIT]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_INIT]: readonly [
     callback: (gridEntity: GridEntity) => void,
     gridEntityType?: GridEntityType,
     variant?: int
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_REMOVE]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_REMOVE]: readonly [
     callback: (gridIndex: int, gridEntityType: GridEntityType, variant: int) => void,
     gridEntityType?: GridEntityType,
     variant?: int
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_RENDER]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_RENDER]: readonly [
     callback: (gridEntity: GridEntity) => void,
     gridEntityType?: GridEntityType,
     variant?: int
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_STATE_CHANGED]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_STATE_CHANGED]: readonly [
     callback: (gridEntity: GridEntity, oldState: int, newState: int) => void,
     gridEntityType?: GridEntityType,
     variant?: int
     ];
-    [ModCallbackCustom.POST_GRID_ENTITY_UPDATE]: [
+    readonly [ModCallbackCustom.POST_GRID_ENTITY_UPDATE]: readonly [
     callback: (gridEntity: GridEntity) => void,
     gridEntityType?: GridEntityType,
     variant?: int
     ];
-    [ModCallbackCustom.POST_HOLY_MANTLE_REMOVED]: [
+    readonly [ModCallbackCustom.POST_HOLY_MANTLE_REMOVED]: readonly [
     callback: (player: EntityPlayer, oldNumHolyMantles: int, newNumHolyMantles: int) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_ITEM_DISCHARGE]: [
+    readonly [ModCallbackCustom.POST_ITEM_DISCHARGE]: readonly [
     callback: (player: EntityPlayer, collectibleType: CollectibleType, activeSlot: ActiveSlot) => void,
     collectibleType?: CollectibleType
     ];
-    [ModCallbackCustom.POST_ITEM_PICKUP]: [callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => void] | [
+    readonly [ModCallbackCustom.POST_ITEM_PICKUP]: readonly [
+    callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => void
+    ] | readonly [
     callback: (player: EntityPlayer, pickingUpItem: PickingUpItemCollectible) => void,
     itemType: ItemType.PASSIVE | ItemType.ACTIVE | ItemType.FAMILIAR,
     collectibleType?: CollectibleType
-    ] | [
+    ] | readonly [
     callback: (player: EntityPlayer, pickingUpItem: PickingUpItemTrinket) => void,
     itemType: ItemType.TRINKET,
     trinketType?: TrinketType
     ];
-    [ModCallbackCustom.POST_KEYBOARD_CHANGED]: [
+    readonly [ModCallbackCustom.POST_KEYBOARD_CHANGED]: readonly [
     callback: (keyboard: Keyboard, pressed: boolean) => void,
     keyboard?: Keyboard,
     pressed?: boolean
     ];
-    [ModCallbackCustom.POST_KNIFE_INIT_FILTER]: [
+    readonly [ModCallbackCustom.POST_KNIFE_INIT_FILTER]: readonly [
     callback: (knife: EntityKnife) => void,
     knifeVariant?: KnifeVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_KNIFE_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_KNIFE_INIT_LATE]: readonly [
     callback: (knife: EntityKnife) => void,
     knifeVariant?: KnifeVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_KNIFE_RENDER_FILTER]: [
+    readonly [ModCallbackCustom.POST_KNIFE_RENDER_FILTER]: readonly [
     callback: (knife: EntityKnife, renderOffset: Vector) => void,
     knifeVariant?: KnifeVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_KNIFE_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.POST_KNIFE_UPDATE_FILTER]: readonly [
     callback: (knife: EntityKnife) => void,
     knifeVariant?: KnifeVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_LASER_INIT_FILTER]: [
+    readonly [ModCallbackCustom.POST_LASER_INIT_FILTER]: readonly [
     callback: (laser: EntityLaser) => void,
     laserVariant?: LaserVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_LASER_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_LASER_INIT_LATE]: readonly [
     callback: (laser: EntityLaser) => void,
     laserVariant?: LaserVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_LASER_RENDER_FILTER]: [
+    readonly [ModCallbackCustom.POST_LASER_RENDER_FILTER]: readonly [
     callback: (laser: EntityLaser, renderOffset: Vector) => void,
     laserVariant?: LaserVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_LASER_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.POST_LASER_UPDATE_FILTER]: readonly [
     callback: (laser: EntityLaser) => void,
     laserVariant?: LaserVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_NEW_LEVEL_REORDERED]: [
+    readonly [ModCallbackCustom.POST_NEW_LEVEL_REORDERED]: readonly [
     callback: (stage: LevelStage, stageType: StageType) => void,
     stage?: LevelStage,
     stageType?: StageType
     ];
-    [ModCallbackCustom.POST_NEW_ROOM_EARLY]: [
+    readonly [ModCallbackCustom.POST_NEW_ROOM_EARLY]: readonly [
     callback: (roomType: RoomType) => void,
     roomType?: RoomType
     ];
-    [ModCallbackCustom.POST_NEW_ROOM_REORDERED]: [
+    readonly [ModCallbackCustom.POST_NEW_ROOM_REORDERED]: readonly [
     callback: (roomType: RoomType) => void,
     roomType?: RoomType
     ];
-    [ModCallbackCustom.POST_NPC_DEATH_FILTER]: [
+    readonly [ModCallbackCustom.POST_NPC_DEATH_FILTER]: readonly [
     callback: (npc: EntityNPC) => void,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.POST_NPC_INIT_FILTER]: [
+    readonly [ModCallbackCustom.POST_NPC_INIT_FILTER]: readonly [
     callback: (npc: EntityNPC) => void,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.POST_NPC_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_NPC_INIT_LATE]: readonly [
     callback: (npc: EntityNPC) => void,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.POST_NPC_RENDER_FILTER]: [
+    readonly [ModCallbackCustom.POST_NPC_RENDER_FILTER]: readonly [
     callback: (npc: EntityNPC, renderOffset: Vector) => void,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.POST_NPC_STATE_CHANGED]: [
+    readonly [ModCallbackCustom.POST_NPC_STATE_CHANGED]: readonly [
     callback: (npc: EntityNPC, previousState: int, currentState: int) => void,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.POST_NPC_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.POST_NPC_UPDATE_FILTER]: readonly [
     callback: (npc: EntityNPC) => void,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED]: [
+    readonly [ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED]: readonly [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_PICKUP_CHANGED]: [
+    readonly [ModCallbackCustom.POST_PICKUP_CHANGED]: readonly [
     callback: (pickup: EntityPickup, oldVariant: PickupVariant, oldSubType: int, newVariant: PickupVariant, newSubType: int) => void,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PICKUP_COLLECT]: [
+    readonly [ModCallbackCustom.POST_PICKUP_COLLECT]: readonly [
     callback: (pickup: EntityPickup, player: EntityPlayer) => void,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PICKUP_INIT_FILTER]: [
+    readonly [ModCallbackCustom.POST_PICKUP_INIT_FILTER]: readonly [
     callback: (pickup: EntityPickup) => void,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PICKUP_INIT_FIRST]: [
+    readonly [ModCallbackCustom.POST_PICKUP_INIT_FIRST]: readonly [
     callback: (pickup: EntityPickup) => void,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PICKUP_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_PICKUP_INIT_LATE]: readonly [
     callback: (pickup: EntityPickup) => void,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PICKUP_RENDER_FILTER]: [
+    readonly [ModCallbackCustom.POST_PICKUP_RENDER_FILTER]: readonly [
     callback: (pickup: EntityPickup, renderOffset: Vector) => void,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PICKUP_SELECTION_FILTER]: [
+    readonly [ModCallbackCustom.POST_PICKUP_SELECTION_FILTER]: readonly [
     callback: (pickup: EntityPickup, variant: PickupVariant, subType: int) => [pickupVariant: PickupVariant, subType: int] | undefined,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PICKUP_STATE_CHANGED]: [
+    readonly [ModCallbackCustom.POST_PICKUP_STATE_CHANGED]: readonly [
     callback: (pickup: EntityPickup, previousState: int, currentState: int) => void,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PICKUP_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.POST_PICKUP_UPDATE_FILTER]: readonly [
     callback: (pickup: EntityPickup) => void,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PIT_RENDER]: [
+    readonly [ModCallbackCustom.POST_PIT_RENDER]: readonly [
     callback: (pit: GridEntityPit) => void,
     pitVariant?: PitVariant
     ];
-    [ModCallbackCustom.POST_PIT_UPDATE]: [
+    readonly [ModCallbackCustom.POST_PIT_UPDATE]: readonly [
     callback: (pit: GridEntityPit) => void,
     pitVariant?: PitVariant
     ];
-    [ModCallbackCustom.POST_PLAYER_CHANGE_HEALTH]: [
+    readonly [ModCallbackCustom.POST_PLAYER_CHANGE_HEALTH]: readonly [
     callback: (player: EntityPlayer, healthType: HealthType, difference: int, oldValue: int, newValue: int) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_PLAYER_CHANGE_STAT]: [
+    readonly [ModCallbackCustom.POST_PLAYER_CHANGE_STAT]: readonly [
     callback: <T extends PlayerStat>(player: EntityPlayer, playerStat: PlayerStat, difference: int, oldValue: PlayerStats[T], newValue: PlayerStats[T]) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_PLAYER_CHANGE_TYPE]: [
+    readonly [ModCallbackCustom.POST_PLAYER_CHANGE_TYPE]: readonly [
     callback: (player: EntityPlayer, oldCharacter: PlayerType, newCharacter: PlayerType) => void,
     playerVariant?: PlayerVariant
     ];
-    [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED]: [
+    readonly [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED]: readonly [
     callback: (player: EntityPlayer, collectibleType: CollectibleType) => void,
     collectibleType?: CollectibleType
     ];
-    [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED]: [
+    readonly [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED]: readonly [
     callback: (player: EntityPlayer, collectibleType: CollectibleType) => void,
     collectibleType?: CollectibleType
     ];
-    [ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE]: [
+    readonly [ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE]: readonly [
     callback: (player: EntityPlayer, amount: float, damageFlags: BitFlags<DamageFlag>, source: EntityRef, countdownFrames: int) => boolean | undefined,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_PLAYER_INIT_FIRST]: [
+    readonly [ModCallbackCustom.POST_PLAYER_INIT_FIRST]: readonly [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_PLAYER_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_PLAYER_INIT_LATE]: readonly [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_PLAYER_RENDER_REORDERED]: [
+    readonly [ModCallbackCustom.POST_PLAYER_RENDER_REORDERED]: readonly [
     callback: (player: EntityPlayer, renderOffset: Vector) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_PLAYER_UPDATE_REORDERED]: [
+    readonly [ModCallbackCustom.POST_PLAYER_UPDATE_REORDERED]: readonly [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_POOP_RENDER]: [
+    readonly [ModCallbackCustom.POST_POOP_RENDER]: readonly [
     callback: (poop: GridEntityPoop) => void,
     poopVariant?: PoopGridEntityVariant
     ];
-    [ModCallbackCustom.POST_POOP_UPDATE]: [
+    readonly [ModCallbackCustom.POST_POOP_UPDATE]: readonly [
     callback: (poop: GridEntityPoop) => void,
     poopVariant?: PoopGridEntityVariant
     ];
-    [ModCallbackCustom.POST_PRESSURE_PLATE_RENDER]: [
+    readonly [ModCallbackCustom.POST_PRESSURE_PLATE_RENDER]: readonly [
     callback: (pressurePlate: GridEntityPressurePlate) => void,
     pressurePlateVariant?: PressurePlateVariant
     ];
-    [ModCallbackCustom.POST_PRESSURE_PLATE_UPDATE]: [
+    readonly [ModCallbackCustom.POST_PRESSURE_PLATE_UPDATE]: readonly [
     callback: (pressurePlate: GridEntityPressurePlate) => void,
     pressurePlateVariant?: PressurePlateVariant
     ];
-    [ModCallbackCustom.POST_PROJECTILE_INIT_FILTER]: [
+    readonly [ModCallbackCustom.POST_PROJECTILE_INIT_FILTER]: readonly [
     callback: (projectile: EntityProjectile) => void,
     projectileVariant?: ProjectileVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PROJECTILE_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_PROJECTILE_INIT_LATE]: readonly [
     callback: (projectile: EntityProjectile) => void,
     projectileVariant?: ProjectileVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PROJECTILE_KILL]: [
+    readonly [ModCallbackCustom.POST_PROJECTILE_KILL]: readonly [
     callback: (projectile: EntityProjectile) => void,
     projectileVariant?: ProjectileVariant,
     subType?: number
     ];
-    [ModCallbackCustom.POST_PROJECTILE_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.POST_PROJECTILE_UPDATE_FILTER]: readonly [
     callback: (projectile: EntityProjectile) => void,
     projectileVariant?: ProjectileVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PROJECTILE_RENDER_FILTER]: [
+    readonly [ModCallbackCustom.POST_PROJECTILE_RENDER_FILTER]: readonly [
     callback: (projectile: EntityProjectile, renderOffset: Vector) => void,
     projectileVariant?: ProjectileVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_PURCHASE]: [
+    readonly [ModCallbackCustom.POST_PURCHASE]: readonly [
     callback: (player: EntityPlayer, pickup: EntityPickup) => void,
     pickupVariant?: PickupVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_ROCK_RENDER]: [
+    readonly [ModCallbackCustom.POST_ROCK_RENDER]: readonly [
     callback: (rock: GridEntityRock) => void,
     gridEntityType?: GridEntityType,
     variant?: int
     ];
-    [ModCallbackCustom.POST_ROCK_UPDATE]: [
+    readonly [ModCallbackCustom.POST_ROCK_UPDATE]: readonly [
     callback: (rock: GridEntityRock) => void,
     gridEntityType?: GridEntityType,
     variant?: int
     ];
-    [ModCallbackCustom.POST_ROOM_CLEAR_CHANGED]: [
+    readonly [ModCallbackCustom.POST_ROOM_CLEAR_CHANGED]: readonly [
     callback: (roomClear: boolean) => void,
     roomClear?: boolean
     ];
-    [ModCallbackCustom.POST_SACRIFICE]: [
+    readonly [ModCallbackCustom.POST_SACRIFICE]: readonly [
     callback: (player: EntityPlayer, numSacrifices: int) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED]: [
+    readonly [ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED]: readonly [
     callback: (slot: EntitySlot, previousAnimation: string, currentAnimation: string) => void,
     slotVariant?: SlotVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_SLOT_COLLISION]: [
+    readonly [ModCallbackCustom.POST_SLOT_COLLISION]: readonly [
     callback: (slot: EntitySlot, player: EntityPlayer) => void,
     slotVariant?: SlotVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_SLOT_DESTROYED]: [
+    readonly [ModCallbackCustom.POST_SLOT_DESTROYED]: readonly [
     callback: (slot: EntitySlot, slotDestructionType: SlotDestructionType) => void,
     slotVariant?: SlotVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_SLOT_INIT]: [
+    readonly [ModCallbackCustom.POST_SLOT_INIT]: readonly [
     callback: (slot: EntitySlot) => void,
     slotVariant?: SlotVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_SLOT_RENDER]: [
+    readonly [ModCallbackCustom.POST_SLOT_RENDER]: readonly [
     callback: (slot: EntitySlot) => void,
     slotVariant?: SlotVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_SLOT_UPDATE]: [
+    readonly [ModCallbackCustom.POST_SLOT_UPDATE]: readonly [
     callback: (slot: EntitySlot) => void,
     slotVariant?: SlotVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_SPIKES_RENDER]: [
+    readonly [ModCallbackCustom.POST_SPIKES_RENDER]: readonly [
     callback: (spikes: GridEntitySpikes) => void,
     variant?: int
     ];
-    [ModCallbackCustom.POST_SPIKES_UPDATE]: [
+    readonly [ModCallbackCustom.POST_SPIKES_UPDATE]: readonly [
     callback: (spikes: GridEntitySpikes) => void,
     variant?: int
     ];
-    [ModCallbackCustom.POST_TEAR_INIT_FILTER]: [
+    readonly [ModCallbackCustom.POST_TEAR_INIT_FILTER]: readonly [
     callback: (tear: EntityTear) => void,
     tearVariant?: TearVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_TEAR_INIT_LATE]: [
+    readonly [ModCallbackCustom.POST_TEAR_INIT_LATE]: readonly [
     callback: (tear: EntityTear) => void,
     tearVariant?: TearVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_TEAR_INIT_VERY_LATE]: [
+    readonly [ModCallbackCustom.POST_TEAR_INIT_VERY_LATE]: readonly [
     callback: (tear: EntityTear) => void,
     tearVariant?: TearVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_TEAR_KILL]: [
+    readonly [ModCallbackCustom.POST_TEAR_KILL]: readonly [
     callback: (tear: EntityTear) => void,
     tearVariant?: TearVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_TEAR_RENDER_FILTER]: [
+    readonly [ModCallbackCustom.POST_TEAR_RENDER_FILTER]: readonly [
     callback: (tear: EntityTear, renderOffset: Vector) => void,
     tearVariant?: TearVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_TEAR_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.POST_TEAR_UPDATE_FILTER]: readonly [
     callback: (tear: EntityTear) => void,
     tearVariant?: TearVariant,
     subType?: int
     ];
-    [ModCallbackCustom.POST_TNT_RENDER]: [
+    readonly [ModCallbackCustom.POST_TNT_RENDER]: readonly [
     callback: (tnt: GridEntityTNT) => void,
     variant?: int
     ];
-    [ModCallbackCustom.POST_TNT_UPDATE]: [
+    readonly [ModCallbackCustom.POST_TNT_UPDATE]: readonly [
     callback: (tnt: GridEntityTNT) => void,
     variant?: int
     ];
-    [ModCallbackCustom.POST_TRANSFORMATION]: [
+    readonly [ModCallbackCustom.POST_TRANSFORMATION]: readonly [
     callback: (player: EntityPlayer, playerForm: PlayerForm, hasForm: boolean) => void,
     playerForm?: PlayerForm
     ];
-    [ModCallbackCustom.POST_TRINKET_BREAK]: [
+    readonly [ModCallbackCustom.POST_TRINKET_BREAK]: readonly [
     callback: (player: EntityPlayer, trinketType: TrinketType) => void,
     trinketType?: TrinketType
     ];
-    [ModCallbackCustom.POST_USE_PILL_FILTER]: [
+    readonly [ModCallbackCustom.POST_USE_PILL_FILTER]: readonly [
     callback: (pillEffect: PillEffect, pillColor: PillColor, player: EntityPlayer, useFlags: BitFlags<UseFlag>) => void,
     pillEffect?: PillEffect,
     pillColor?: PillColor
     ];
-    [ModCallbackCustom.PRE_BERSERK_DEATH]: [
+    readonly [ModCallbackCustom.PRE_BERSERK_DEATH]: readonly [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.PRE_BOMB_COLLISION_FILTER]: [
+    readonly [ModCallbackCustom.PRE_BOMB_COLLISION_FILTER]: readonly [
     callback: (bomb: EntityBomb, collider: Entity, low: boolean) => boolean | undefined,
     bombVariant?: BombVariant,
     subtype?: int
     ];
-    [ModCallbackCustom.PRE_CUSTOM_REVIVE]: [
+    readonly [ModCallbackCustom.PRE_CUSTOM_REVIVE]: readonly [
     callback: (player: EntityPlayer) => int | undefined,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.PRE_ENTITY_SPAWN_FILTER]: [
+    readonly [ModCallbackCustom.PRE_ENTITY_SPAWN_FILTER]: readonly [
     callback: (entityType: EntityType, variant: int, subType: int, position: Vector, velocity: Vector, spawner: Entity | undefined, initSeed: Seed) => [entityType: EntityType, variant: int, subType: int, initSeed: Seed] | undefined,
     entityType?: EntityType,
     variant?: int,
     subtype?: int
     ];
-    [ModCallbackCustom.PRE_FAMILIAR_COLLISION_FILTER]: [
+    readonly [ModCallbackCustom.PRE_FAMILIAR_COLLISION_FILTER]: readonly [
     callback: (familiar: EntityFamiliar, collider: Entity, low: boolean) => boolean | undefined,
     familiarVariant?: FamiliarVariant,
     subtype?: int
     ];
-    [ModCallbackCustom.PRE_GET_PEDESTAL]: [
+    readonly [ModCallbackCustom.PRE_GET_PEDESTAL]: readonly [
     callback: (player: EntityPlayer, collectible: EntityPickupCollectible) => boolean | undefined,
     playerVariant?: PlayerVariant,
     character?: PlayerType
     ];
-    [ModCallbackCustom.PRE_ITEM_PICKUP]: [
+    readonly [ModCallbackCustom.PRE_ITEM_PICKUP]: readonly [
     callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => boolean | undefined
-    ] | [
+    ] | readonly [
     callback: (player: EntityPlayer, pickingUpItem: PickingUpItemCollectible) => boolean | undefined,
     itemType: ItemType.PASSIVE | ItemType.ACTIVE | ItemType.FAMILIAR,
     collectibleType?: CollectibleType
-    ] | [
+    ] | readonly [
     callback: (player: EntityPlayer, pickingUpItem: PickingUpItemTrinket) => boolean | undefined,
     itemType: ItemType.TRINKET,
     trinketType?: TrinketType
     ];
-    [ModCallbackCustom.PRE_KNIFE_COLLISION_FILTER]: [
+    readonly [ModCallbackCustom.PRE_KNIFE_COLLISION_FILTER]: readonly [
     callback: (knife: EntityKnife, collider: Entity, low: boolean) => boolean | undefined,
     knifeVariant?: KnifeVariant,
     subtype?: int
     ];
-    [ModCallbackCustom.PRE_NEW_LEVEL]: [callback: (player: EntityPlayer) => void];
-    [ModCallbackCustom.PRE_NPC_COLLISION_FILTER]: [
+    readonly [ModCallbackCustom.PRE_NEW_LEVEL]: readonly [
+    callback: (player: EntityPlayer) => void
+    ];
+    readonly [ModCallbackCustom.PRE_NPC_COLLISION_FILTER]: readonly [
     callback: (npc: EntityNPC, collider: Entity, low: boolean) => undefined | boolean,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.PRE_NPC_UPDATE_FILTER]: [
+    readonly [ModCallbackCustom.PRE_NPC_UPDATE_FILTER]: readonly [
     callback: (npc: EntityNPC) => undefined | boolean,
     entityType?: EntityType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.PRE_PROJECTILE_COLLISION_FILTER]: [
+    readonly [ModCallbackCustom.PRE_PROJECTILE_COLLISION_FILTER]: readonly [
     callback: (projectile: EntityProjectile, collider: Entity, low: boolean) => boolean | undefined,
     projectileVariant?: ProjectileVariant,
     subtype?: int
     ];
-    [ModCallbackCustom.PRE_ROOM_ENTITY_SPAWN_FILTER]: [
+    readonly [ModCallbackCustom.PRE_ROOM_ENTITY_SPAWN_FILTER]: readonly [
     callback: (entityTypeOrGridEntityXMLType: EntityType | GridEntityXMLType, variant: int, subType: int, gridIndex: int, initSeed: Seed) => [type: EntityType | GridEntityXMLType, variant: int, subType: int] | undefined,
     entityTypeOrGridEntityXMLType?: EntityType | GridEntityXMLType,
     variant?: int,
     subType?: int
     ];
-    [ModCallbackCustom.PRE_TEAR_COLLISION_FILTER]: [
+    readonly [ModCallbackCustom.PRE_TEAR_COLLISION_FILTER]: readonly [
     callback: (tear: EntityTear, collider: Entity, low: boolean) => boolean | undefined,
     tearVariant?: TearVariant,
     subtype?: int
@@ -962,13 +970,16 @@ export declare const ALL_DISPLAY_FLAGS: BitFlags<number & {
 }>;
 
 /** Helper type to create a new tuple containing all but the first element of another tuple. */
-export declare type AllButFirst<T extends unknown[]> = T extends [
+export declare type AllButFirst<T extends readonly unknown[]> = T extends readonly [
 unknown,
 ...infer Tail
 ] ? Tail : unknown[];
 
 /** Helper type to create a new tuple containing all but the last element of another tuple. */
-export declare type AllButLast<T extends unknown[]> = T extends [...infer Head, unknown] ? Head : unknown[];
+export declare type AllButLast<T extends readonly unknown[]> = T extends readonly [
+...infer Head,
+unknown
+] ? Head : unknown[];
 
 /** This is used by the `POST_AMBUSH_STARTED` and `POST_AMBUSH_FINISHED` custom callbacks. */
 export declare enum AmbushType {
@@ -1304,7 +1315,7 @@ export declare function benchmark(numTrials: int, ...functions: ReadonlyArray<()
 export declare function bitFlags<T extends BitFlag | BitFlag128>(flag: T): BitFlags<T>;
 
 /**
- * The path to the png file for collectible items during Curse of the Blind, making them appear with
+ * The path to the PNG file for collectible items during Curse of the Blind, making them appear with
  * a red question mark.
  */
 export declare const BLIND_ITEM_PNG_PATH = "gfx/items/collectibles/questionmark.png";
@@ -1454,11 +1465,11 @@ declare class CharacterStats extends Feature {
  * This is used in the `newChargeBarSprites` and related helper functions.
  */
 export declare interface ChargeBarSprites {
-    back: Sprite;
-    meter: Sprite;
-    meterBattery: Sprite;
-    lines: Sprite;
-    maxCharges: int;
+    readonly back: Readonly<Sprite>;
+    readonly meter: Readonly<Sprite>;
+    readonly meterBattery: Readonly<Sprite>;
+    readonly lines: Readonly<Sprite>;
+    readonly maxCharges: int;
 }
 
 /**
@@ -1791,13 +1802,13 @@ export declare function copyIsaacAPIClass<T extends CopyableIsaacAPIClass>(isaac
 export declare function copyKColor(kColor: KColor): KColor;
 
 /** Helper function to copy a map. (You can also use a Map constructor to accomplish this task.) */
-export declare function copyMap<K, V>(oldMap: ReadonlyMap<K, V>): Map<K, V>;
+export declare function copyMap<K, V>(oldMap: ReadonlyMap<K, V>): ReadonlyMap<K, V>;
 
 /** Helper function to copy an `RNG` Isaac API class. */
 export declare function copyRNG(rng: RNG): RNG;
 
 /** Helper function to copy a set. (You can also use a Set constructor to accomplish this task.) */
-export declare function copySet<T>(oldSet: ReadonlySet<T>): Set<T>;
+export declare function copySet<T>(oldSet: ReadonlySet<T>): ReadonlySet<T>;
 
 /** Helper function to copy specific values from a userdata object (e.g. `Vector`) to a table. */
 export declare function copyUserdataValuesToTable(object: unknown, keys: readonly string[], luaMap: LuaMap<string, unknown>): void;
@@ -1858,18 +1869,18 @@ export declare function crc32(str: string): number;
  */
 declare abstract class CustomCallback<T extends ModCallbackCustom> extends Feature {
     private subscriptions;
-    addSubscriber(priority: CallbackPriority | int, callbackFunc: AddCallbackParametersCustom[T][0], ...optionalArgs: AllButFirst<AddCallbackParametersCustom[T]>): void;
-    /**
-     * If the submitted function does not match any of the existing subscriptions, this method will do
-     * nothing.
-     */
-    removeSubscriber(callback: AddCallbackParametersCustom[T][0]): void;
     fire: (...fireArgs: FireArgs<T>) => ReturnType<AddCallbackParametersCustom[T][0]>;
     /**
      * This method needs to be overwritten for any callback that has optional filtration arguments.
      * See "shouldFire.ts" for methods tailored to specific kinds of callbacks.
      */
     protected shouldFire: (fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>) => boolean;
+    addSubscriber(priority: CallbackPriority | int, callbackFunc: AddCallbackParametersCustom[T][0], ...optionalArgs: AllButFirst<AddCallbackParametersCustom[T]>): void;
+    /**
+     * If the submitted function does not match any of the existing subscriptions, this method will do
+     * nothing.
+     */
+    removeSubscriber(callback: AddCallbackParametersCustom[T][0]): void;
 }
 
 declare class CustomGridEntities extends Feature {
@@ -2186,24 +2197,24 @@ declare class CustomPickups extends Feature {
 }
 
 declare class CustomRevive extends Feature {
-    v: {
-        run: {
-            state: CustomReviveState;
-            revivalType: int | null;
-            dyingPlayerIndex: PlayerIndex | null;
-        };
-    };
     private readonly preCustomRevive;
     private readonly postCustomRevive;
     private readonly runInNFrames;
-    constructor(preCustomRevive: PreCustomRevive, postCustomRevive: PostCustomRevive, runInNFrames: RunInNFrames);
     private readonly postRender;
     private readonly postFamiliarInitOneUp;
     private readonly postNewRoomReordered;
     private readonly postPEffectUpdateReordered;
-    private checkWaitingForItemAnimation;
     private readonly postPlayerFatalDamage;
     private readonly preBerserkDeath;
+    v: {
+        run: {
+            state: CustomReviveState;
+            revivalType: int | null;
+            dyingPlayerIndex: PlayerIndex | null;
+        };
+    };
+    constructor(preCustomRevive: PreCustomRevive, postCustomRevive: PostCustomRevive, runInNFrames: RunInNFrames);
+    private checkWaitingForItemAnimation;
     /**
      * 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.
@@ -2231,7 +2242,7 @@ export declare interface CustomStageBossPoolEntry {
      * The name of the boss. This should correspond to the entry for the boss in the "entities2.xml"
      * file.
      */
-    name: string;
+    readonly name: string;
     /**
      * The arbitrary sub-type chosen for this boss, ranging between 1 and 999. You must set the boss
      * rooms for this boss to this sub-type in Basement Renovator by right-clicking on the room on the
@@ -2248,29 +2259,29 @@ export declare interface CustomStageBossPoolEntry {
      * @minimum 1
      * @maximum 999
      */
-    subType: number;
+    readonly subType: number;
     /**
      * The weight of the boss. This is used when randomly selecting which boss to use for the floor.
      * For example, use a value of 1 if you want this boss to be equally likely as any other boss, 0.5
      * if you want it to be half as likely, 2 if you want it to be twice as likely, and so on.
      */
-    weight: number;
+    readonly weight: number;
     /** Optional. A collection of sprites used for the boss on the "versus" screen. */
-    versusScreen?: {
+    readonly versusScreen?: {
         /**
          * Mandatory. The full path to the spritesheet that contains the graphics of the name of the
          * boss that will be displayed on the top of the boss "versus" screen.
          *
          * If not specified, a sprite showing "???" will be used.
          */
-        namePNGPath: string;
+        readonly namePNGPath: string;
         /**
          * Mandatory. The full path to the spritesheet that contains the portrait of the boss that will
          * be displayed on the right side of the boss "versus" screen.
          *
          * If not specified, a sprite showing "???" will be used.
          */
-        portraitPNGPath: string;
+        readonly portraitPNGPath: string;
     };
 }
 
@@ -2290,7 +2301,7 @@ declare interface CustomStageLuaUnsafe extends CustomStageTSConfig {
      * (Internally, the IsaacScript standard library uses this as a basis for determining which rooms
      * should randomly appear on the floor.)
      */
-    roomsMetadata: CustomStageRoomMetadata[];
+    readonly roomsMetadata: readonly CustomStageRoomMetadata[];
 }
 
 /**
@@ -2298,12 +2309,12 @@ declare interface CustomStageLuaUnsafe extends CustomStageTSConfig {
  * each room.
  */
 export declare interface CustomStageRoomMetadata {
-    type: number;
-    variant: number;
-    subType: number;
-    shape: number;
-    doorSlotFlags: number;
-    weight: number;
+    readonly type: number;
+    readonly variant: number;
+    readonly subType: number;
+    readonly shape: number;
+    readonly doorSlotFlags: number;
+    readonly weight: number;
 }
 
 declare class CustomStages extends Feature {
@@ -2318,9 +2329,6 @@ declare class CustomStages extends Feature {
     private readonly gameReorderedCallbacks;
     private readonly pause;
     private readonly runInNFrames;
-    private initCustomStageMetadata;
-    private initRoomTypeMap;
-    private initCustomTrapdoorDestination;
     private readonly goToCustomStage;
     private readonly postRender;
     /**
@@ -2338,6 +2346,9 @@ declare class CustomStages extends Feature {
     private readonly postGridEntityBrokenRockAlt;
     private readonly postGridEntityInit;
     private readonly postNewRoomReordered;
+    private initCustomStageMetadata;
+    private initRoomTypeMap;
+    private initCustomTrapdoorDestination;
     /** Pick a custom room for each vanilla room. */
     private setStageRoomsData;
     /**
@@ -2381,19 +2392,19 @@ export declare interface CustomStageShadow {
      * For an example of a vanilla shadow overlay, see:
      * `resources/gfx/overlays/basement/1x1_overlay_1.png`
      */
-    pngPath: string;
+    readonly pngPath: string;
     /**
      * Optional. An object representing the color used for the shadow.
      *
      * If not specified, an object of `{ r: 0, g: 0, b: 0, a: 0.25 }` will be used (which corresponds
      * to 75% faded black).
      */
-    color?: {
+    readonly color?: {
         /**
          * @minimum 0
          * @maximum 1
          */
-        r: number;
+        readonly r: number;
         /**
          * @minimum 0
          * @maximum 1
@@ -2424,12 +2435,12 @@ export declare interface CustomStageShadow {
  */
 export declare interface CustomStageTSConfig {
     /** Mandatory. The name of the custom stage. */
-    name: string;
+    readonly name: string;
     /**
      * Mandatory. The path to the XML file that contains the rooms for the custom stage (created with
      * Basement Renovator).
      */
-    xmlPath: string;
+    readonly xmlPath: string;
     /**
      * Mandatory. An arbitrarily chosen prefix in the range of 101-999 that will be unique to this
      * stage.
@@ -2442,7 +2453,7 @@ export declare interface CustomStageTSConfig {
      * @minimum 100
      * @maximum 999
      */
-    roomVariantPrefix: number;
+    readonly roomVariantPrefix: number;
     /**
      * Optional. An integer between 2 and 13, corresponding to the `LevelStage` enum. This is the
      * number of the stage that will be warped to and used as a basis for the stage by the level
@@ -2462,7 +2473,7 @@ export declare interface CustomStageTSConfig {
      * @minimum 2
      * @maximum 13
      */
-    baseStage?: number;
+    readonly baseStage?: number;
     /**
      * Optional. An integer between 0 and 5, corresponding to the `StageType` enum. This is the number
      * of the stage type that will be warped to and used as a basis for the stage by the level
@@ -2473,20 +2484,20 @@ export declare interface CustomStageTSConfig {
      * @minimum 0
      * @maximum 5
      */
-    baseStageType?: number;
+    readonly baseStageType?: number;
     /**
      * Optional. A string that represents the name of the music track from the "content/music.xml"
      * file that corresponds to this custom stage. It will be manually played upon entering the stage.
      *
      * If not specified, the same music track as the base stage will be used.
      */
-    music?: string;
+    readonly music?: string;
     /**
      * Optional. An object containing the paths to the backdrop graphics for the stage. (A backdrop is
      * the graphics for the walls and floor.) If not specified, the graphics for Basement will be
      * used.
      */
-    backdropPNGPaths?: {
+    readonly backdropPNGPaths?: {
         /**
          * An array that contains the full paths to the graphic files that are used for the floor in
          * narrow rooms. (The "n" stands for "narrow").
@@ -2496,7 +2507,7 @@ export declare interface CustomStageTSConfig {
          *
          * For an example of this, see the vanilla file "resources/gfx/backdrop/01_basement_nfloor.png".
          */
-        nFloors: string[];
+        readonly nFloors: readonly string[];
         /**
          * An array that contains the full paths to the graphic files that are used for the floor in L
          * rooms.
@@ -2506,7 +2517,7 @@ export declare interface CustomStageTSConfig {
          *
          * For an example of this, see the vanilla file "resources/gfx/backdrop/01_lbasementfloor.png".
          */
-        lFloors: string[];
+        readonly lFloors: readonly string[];
         /**
          * An array that contains the full paths to the graphic files that are used for the walls of the
          * floor.
@@ -2518,7 +2529,7 @@ export declare interface CustomStageTSConfig {
          * the vanilla file, they concatenate all four variations together into one PNG file. However,
          * for the custom stages feature, you must separate each wall variation into a separate file.)
          */
-        walls: string[];
+        readonly walls: readonly string[];
         /**
          * An array that contains the full paths to the graphic files for the stage's corners.
          *
@@ -2532,7 +2543,7 @@ export declare interface CustomStageTSConfig {
          * you must separate each corner variation into a separate file (and put it in a different file
          * from the walls).
          */
-        corners: string[];
+        readonly corners: readonly string[];
     };
     /**
      * Optional. The full path to the spritesheet that contains the graphics of the decorations for
@@ -2544,7 +2555,7 @@ export declare interface CustomStageTSConfig {
      * If you want to have custom animations for your decorations, then do not use this field and use
      * `decorationsANM2Path` instead.
      */
-    decorationsPNGPath?: string;
+    readonly decorationsPNGPath?: string;
     /**
      * Optional. The full path to the anm2 file that contains the custom animations for the
      * decorations of the floor.
@@ -2555,7 +2566,7 @@ export declare interface CustomStageTSConfig {
      * If you do not want to have custom animations for your decorations, then do not use this field
      * and use `decorationsPNGPath` instead.
      */
-    decorationsANM2Path?: string;
+    readonly decorationsANM2Path?: string;
     /**
      * Optional. The full path to the spritesheet that contains the graphics of the rocks/blocks/urns
      * for the floor.
@@ -2571,7 +2582,7 @@ export declare interface CustomStageTSConfig {
      * If you want to have custom animations for your rocks, then do not use this field and use
      * `rocksANM2Path` instead.
      */
-    rocksPNGPath?: string;
+    readonly rocksPNGPath?: string;
     /**
      * Optional. The full path to the anm2 file that contains the custom animations for the
      * rocks/blocks/urns of the floor.
@@ -2587,7 +2598,7 @@ export declare interface CustomStageTSConfig {
      * If you do not want to have custom animations for your rocks, then do not use this field and use
      * `rocksPNGPath` instead.
      */
-    rocksANM2Path?: string;
+    readonly rocksANM2Path?: string;
     /**
      * Optional. The full path to the spritesheet that contains the graphics of the pits for the
      * floor.
@@ -2598,7 +2609,7 @@ export declare interface CustomStageTSConfig {
      * If you do not want to have custom animations for your pits, then do not use this field and use
      * `pitsANM2Path` instead.
      */
-    pitsPNGPath?: string;
+    readonly pitsPNGPath?: string;
     /**
      * Optional. The full path to the anm2 file that contains the custom animations for the pits of
      * the floor.
@@ -2609,12 +2620,12 @@ export declare interface CustomStageTSConfig {
      * If you do not want to have custom animations for your pits, then do not use this field and use
      * `pitsPNGPath` instead.
      */
-    pitsANM2Path?: string;
+    readonly pitsANM2Path?: string;
     /**
      * Optional. A collection of paths that contain graphics for the doors of the floor. If not
      * specified, the doors for Basement will be used.
      */
-    doorPNGPaths?: {
+    readonly doorPNGPaths?: {
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the normal doors for
          * the floor.
@@ -2622,7 +2633,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_01_normaldoor.png`
          */
-        normal?: string;
+        readonly normal?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the Treasure Room
          * doors for the floor.
@@ -2630,7 +2641,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_02_treasureroomdoor.png`
          */
-        treasureRoom?: string;
+        readonly treasureRoom?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the Boss Room doors
          * for the floor.
@@ -2638,7 +2649,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_10_bossroomdoor.png`
          */
-        bossRoom?: string;
+        readonly bossRoom?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the Secret Room and
          * Super Secret Room doors for the floor.
@@ -2646,7 +2657,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_08_holeinwall.png`
          */
-        secretRoom?: string;
+        readonly secretRoom?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the arcade doors for
          * the floor.
@@ -2654,7 +2665,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_05_arcaderoomdoor.png`
          */
-        arcade?: string;
+        readonly arcade?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the Curse Room doors
          * for the floor.
@@ -2662,7 +2673,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_04_selfsacrificeroomdoor.png`
          */
-        curseRoom?: string;
+        readonly curseRoom?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the normal Challenge
          * Room doors for the floor.
@@ -2670,7 +2681,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_03_ambushroomdoor.png`
          */
-        normalChallengeRoom?: string;
+        readonly normalChallengeRoom?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the Boss Challenge
          * Room doors for the floor.
@@ -2678,7 +2689,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_09_bossambushroomdoor.png`
          */
-        bossChallengeRoom?: string;
+        readonly bossChallengeRoom?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the Devil Room doors
          * for the floor.
@@ -2686,7 +2697,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_07_devilroomdoor.png`
          */
-        devilRoom?: string;
+        readonly devilRoom?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the Angel Room doors
          * for the floor.
@@ -2694,7 +2705,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_07_holyroomdoor.png`
          */
-        angelRoom?: string;
+        readonly angelRoom?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the Boss Rush doors
          * for the floor.
@@ -2702,7 +2713,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_15_bossrushdoor.png`
          */
-        bossRush?: string;
+        readonly bossRush?: string;
         /**
          * Optional. The full path to the spritesheet that contains the graphics of the Chest Room doors
          * for the floor.
@@ -2710,7 +2721,7 @@ export declare interface CustomStageTSConfig {
          * If not specified, the vanilla Basement door spritesheet will be used. For reference, this is
          * located at: `resources/gfx/grid/door_02b_chestroomdoor.png`
          */
-        chestRoom?: string;
+        readonly chestRoom?: string;
     };
     /**
      * Optional. An array of shadow objects that describe the graphics for the custom shadows of the
@@ -2718,7 +2729,7 @@ export declare interface CustomStageTSConfig {
      * Basement, a shadow of a sideways V is used, among others.) If not specified, no extra shadows
      * will be drawn.
      */
-    shadows?: {
+    readonly shadows?: {
         /**
          * Optional. An array containing the shadows that will be used in rooms of shape
          * `RoomShape.SHAPE_1x1` (1), `RoomShape.IH` (2), and `RoomShape.IV` (3).
@@ -2727,7 +2738,7 @@ export declare interface CustomStageTSConfig {
          *
          * If not specified, no extra shadows will be drawn in these room shapes.
          */
-        "1x1"?: CustomStageShadow[];
+        readonly "1x1"?: readonly CustomStageShadow[];
         /**
          * Optional. An array containing the shadows that will be used in rooms of shape
          * `RoomShape.SHAPE_1x2` (4) and `RoomShape.IIV` (5).
@@ -2736,7 +2747,7 @@ export declare interface CustomStageTSConfig {
          *
          * If not specified, no extra shadows will be drawn in these room shapes.
          */
-        "1x2"?: CustomStageShadow[];
+        readonly "1x2"?: readonly CustomStageShadow[];
         /**
          * Optional. An array containing the shadows that will be used in rooms of shape
          * `RoomShape.SHAPE_2x1` (6) and `RoomShape.IIH` (7).
@@ -2745,7 +2756,7 @@ export declare interface CustomStageTSConfig {
          *
          * If not specified, no extra shadows will be drawn in these room shapes.
          */
-        "2x1"?: CustomStageShadow[];
+        readonly "2x1"?: readonly CustomStageShadow[];
         /**
          * Optional. An array containing the shadows that will be used in rooms of shape
          * `RoomShape.SHAPE_2x2` (8), `RoomShape.LTL` (9), `RoomShape.LTR` (10), `RoomShape.LBL` (11),
@@ -2755,20 +2766,20 @@ export declare interface CustomStageTSConfig {
          *
          * If not specified, no extra shadows will be drawn in these room shapes.
          */
-        "2x2"?: CustomStageShadow[];
+        readonly "2x2"?: readonly CustomStageShadow[];
     };
     /**
      * Optional. An array containing the bosses that should be used for the stage. This can include
      * both vanilla bosses and modded bosses.
      */
-    bossPool?: CustomStageBossPoolEntry[];
+    readonly bossPool?: readonly CustomStageBossPoolEntry[];
     /**
      * Optional. A collection of colors used for in the boss "versus" screen for all of the bosses.
      *
      * Note that these graphics will only be applied if one or more bosses are specified in the
      * `bossPool` field.
      */
-    versusScreen?: {
+    readonly versusScreen?: {
         /**
          * Optional. An object representing the color to use for the background of the boss "versus"
          * screen. If not specified, the color for Basement 1 will be used.
@@ -2776,27 +2787,27 @@ export declare interface CustomStageTSConfig {
          * For a list of the colors that correspond to the vanilla stages, see
          * `versusScreenBackgroundColors.ts`.
          */
-        backgroundColor?: {
+        readonly backgroundColor?: {
             /**
              * @minimum 0
              * @maximum 1
              */
-            r: number;
+            readonly r: number;
             /**
              * @minimum 0
              * @maximum 1
              */
-            g: number;
+            readonly g: number;
             /**
              * @minimum 0
              * @maximum 1
              */
-            b: number;
+            readonly b: number;
             /**
              * @minimum 0
              * @maximum 1
              */
-            a: number;
+            readonly a: number;
         };
         /**
          * Optional. An object representing the color to use for the dirt spots in the boss "versus"
@@ -2806,27 +2817,27 @@ export declare interface CustomStageTSConfig {
          * For a list of the colors that correspond to the vanilla stages, see
          * `versusScreenDirtSpotColors.ts`.
          */
-        dirtSpotColor?: {
+        readonly dirtSpotColor?: {
             /**
              * @minimum 0
              * @maximum 1
              */
-            r: number;
+            readonly r: number;
             /**
              * @minimum 0
              * @maximum 1
              */
-            g: number;
+            readonly g: number;
             /**
              * @minimum 0
              * @maximum 1
              */
-            b: number;
+            readonly b: number;
             /**
              * @minimum 0
              * @maximum 1
              */
-            a: number;
+            readonly a: number;
         };
     };
 }
@@ -2849,6 +2860,8 @@ declare class CustomTrapdoors extends Feature {
     private readonly runNextRoom;
     private readonly stageHistory;
     private readonly postRender;
+    private readonly postGridEntityCustomUpdateTrapdoor;
+    private readonly postPEffectUpdateReordered;
     private checkAllPlayersJumpComplete;
     private checkPixelationToBlackComplete;
     private goToCustomTrapdoorDestination;
@@ -2856,7 +2869,6 @@ declare class CustomTrapdoors extends Feature {
     private checkSecondPixelationHalfWay;
     private checkAllPlayersLayingDownComplete;
     private drawBlackSprite;
-    private readonly postGridEntityCustomUpdateTrapdoor;
     private checkCustomTrapdoorOpenClose;
     private shouldTrapdoorOpen;
     private isPlayerCloseAfterBoss;
@@ -2864,7 +2876,6 @@ declare class CustomTrapdoors extends Feature {
     private playerTouchedCustomTrapdoor;
     private startDelayedJump;
     private adjustPlayerPositionToTrapdoor;
-    private readonly postPEffectUpdateReordered;
     private checkJumpComplete;
     private shouldTrapdoorSpawnOpen;
     private logStateChanged;
@@ -2949,6 +2960,7 @@ declare class DebugDisplay extends Feature {
     private readonly poop;
     private readonly door;
     private readonly pressurePlate;
+    private toggleFeature;
     /**
      * If the "togglePlayerDisplay" function is called, text will be drawn on the screen next to each
      * player. Use this function to specify a callback function that returns the string that should be
@@ -3191,7 +3203,6 @@ declare class DebugDisplay extends Feature {
      * @public
      */
     setPressurePlateDisplay(textCallback: (pressurePlate: GridEntityPressurePlate) => string): void;
-    private toggleFeature;
     /**
      * Toggles the debug display for players, which will draw text on the screen next to each player.
      *
@@ -4256,13 +4267,13 @@ declare class EdenStartingStatsHealth extends Feature {
      * granted yet.
      */
     private readonly postPlayerInit;
-    private getEdenStats;
-    private getEdenHealth;
     /**
      * We must use the `POST_PLAYER_COLLECTIBLE_ADDED` callback since the collectibles are not yet
      * granted in the `POST_PLAYER_INIT` callback.
      */
     private readonly postPlayerCollectibleAdded;
+    private getEdenStats;
+    private getEdenHealth;
     /**
      * Helper function to get the active collectible that Eden started with at the beginning of the
      * run.
@@ -4407,6 +4418,10 @@ export declare function eRange(start: int, end?: int, increment?: number): reado
 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 {
+    private readonly postEsauJr;
+    private readonly postFirstEsauJr;
+    private readonly postUpdate;
+    private readonly postUseItemEsauJr;
     v: {
         run: {
             usedEsauJrFrame: int | null;
@@ -4414,11 +4429,7 @@ declare class EsauJrDetection extends Feature {
             usedEsauJrAtLeastOnce: boolean;
         };
     };
-    private readonly postEsauJr;
-    private readonly postFirstEsauJr;
     constructor(postEsauJr: PostEsauJr, postFirstEsauJr: PostFirstEsauJr);
-    private readonly postUpdate;
-    private readonly postUseItemEsauJr;
 }
 
 /**
@@ -4702,16 +4713,16 @@ export declare const FIRST_PILL_EFFECT = PillEffect.BAD_GAS;
 export declare const FIRST_TRINKET_TYPE = TrinketType.SWALLOWED_PENNY;
 
 declare class FlipDetection extends Feature {
+    private readonly postFlip;
+    private readonly postFirstFlip;
+    private readonly postUseItemFlip;
     v: {
         run: {
             /** We don't consider the case of a multiplayer game with more than one Tainted Lazarus. */
             usedFlipAtLeastOnce: boolean;
         };
     };
-    private readonly postFlip;
-    private readonly postFirstFlip;
     constructor(postFlip: PostFlip, postFirstFlip: PostFirstFlip);
-    private readonly postUseItemFlip;
 }
 
 /**
@@ -8313,17 +8324,17 @@ export declare const GRID_INDEX_CENTER_OF_1X1_ROOM = 67;
 export declare function gridCoordinatesToWorldPosition(x: int, y: int): Readonly<Vector>;
 
 declare class GridEntityCollisionDetection extends Feature {
+    private readonly postGridEntityCollision;
+    private readonly postGridEntityCustomCollision;
+    private readonly customGridEntities;
+    private readonly postUpdate;
     v: {
         room: {
             /** Indexed by grid entity pointer hash. */
             collidingEntitiesMap: DefaultMap<PtrHash, Set<PtrHash>, []>;
         };
     };
-    private readonly postGridEntityCollision;
-    private readonly postGridEntityCustomCollision;
-    private readonly customGridEntities;
     constructor(postGridEntityCollision: PostGridEntityCollision, postGridEntityCustomCollision: PostGridEntityCustomCollision, customGridEntities: CustomGridEntities);
-    private readonly postUpdate;
 }
 
 /**
@@ -8337,12 +8348,12 @@ export declare interface GridEntityCustomData {
      * This is not a real `GridEntityType`; rather it is an arbitrary integer selected by end-user
      * mods.
      */
-    gridEntityTypeCustom: GridEntityType;
-    roomListIndex: int;
-    gridIndex: int;
-    gridCollisionClass?: GridCollisionClass;
-    anm2Path?: string;
-    defaultAnimation?: string;
+    readonly gridEntityTypeCustom: GridEntityType;
+    readonly roomListIndex: int;
+    readonly gridIndex: int;
+    readonly gridCollisionClass?: GridCollisionClass;
+    readonly anm2Path?: string;
+    readonly defaultAnimation?: string;
 }
 
 /**
@@ -8359,8 +8370,8 @@ declare class GridEntityRenderDetection extends Feature {
     private readonly postGridEntityRender;
     private readonly postGridEntityCustomRender;
     private readonly customGridEntities;
-    constructor(postGridEntityRender: PostGridEntityRender, postGridEntityCustomRender: PostGridEntityCustomRender, customGridEntities: CustomGridEntities);
     private readonly postRender;
+    constructor(postGridEntityRender: PostGridEntityRender, postGridEntityCustomRender: PostGridEntityCustomRender, customGridEntities: CustomGridEntities);
 }
 
 declare type GridEntityTuple = [
@@ -8370,12 +8381,6 @@ state: int
 ];
 
 declare class GridEntityUpdateDetection extends Feature {
-    v: {
-        room: {
-            /** Indexed by grid index. */
-            initializedGridEntities: Map<int, GridEntityTuple>;
-        };
-    };
     private readonly postGridEntityInit;
     private readonly postGridEntityCustomInit;
     private readonly postGridEntityUpdate;
@@ -8387,13 +8392,19 @@ declare class GridEntityUpdateDetection extends Feature {
     private readonly postGridEntityBroken;
     private readonly postGridEntityCustomBroken;
     private readonly 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 readonly postUpdate;
+    private readonly postNewRoomReordered;
+    v: {
+        room: {
+            /** Indexed by grid index. */
+            initializedGridEntities: Map<int, GridEntityTuple>;
+        };
+    };
+    constructor(postGridEntityInit: PostGridEntityInit, postGridEntityCustomInit: PostGridEntityCustomInit, postGridEntityUpdate: PostGridEntityUpdate, postGridEntityCustomUpdate: PostGridEntityCustomUpdate, postGridEntityRemove: PostGridEntityRemove, postGridEntityCustomRemove: PostGridEntityCustomRemove, postGridEntityStateChanged: PostGridEntityStateChanged, postGridEntityCustomStateChanged: PostGridEntityCustomStateChanged, postGridEntityBroken: PostGridEntityBroken, postGridEntityCustomBroken: PostGridEntityCustomBroken, customGridEntities: CustomGridEntities);
     private checkGridEntitiesRemoved;
     private checkGridEntityStateChanged;
     private checkNewGridEntity;
     private updateTupleInMap;
-    private readonly postNewRoomReordered;
 }
 
 /**
@@ -8964,19 +8975,19 @@ export declare function is2x1RoomShape(roomShape: RoomShape): boolean;
 export declare function isaacAPIClassEquals(object1: unknown, object2: unknown, keys: readonly string[]): boolean;
 
 declare interface IsaacAPIClassTypeToSerializedType {
-    [CopyableIsaacAPIClassType.BIT_SET_128]: SerializedBitSet128;
-    [CopyableIsaacAPIClassType.COLOR]: SerializedColor;
-    [CopyableIsaacAPIClassType.K_COLOR]: SerializedKColor;
-    [CopyableIsaacAPIClassType.RNG]: SerializedRNG;
-    [CopyableIsaacAPIClassType.VECTOR]: SerializedVector;
+    readonly [CopyableIsaacAPIClassType.BIT_SET_128]: Readonly<SerializedBitSet128>;
+    readonly [CopyableIsaacAPIClassType.COLOR]: Readonly<SerializedColor>;
+    readonly [CopyableIsaacAPIClassType.K_COLOR]: Readonly<SerializedKColor>;
+    readonly [CopyableIsaacAPIClassType.RNG]: Readonly<SerializedRNG>;
+    readonly [CopyableIsaacAPIClassType.VECTOR]: Readonly<SerializedVector>;
 }
 
 declare interface IsaacAPIClassTypeToType {
-    [CopyableIsaacAPIClassType.BIT_SET_128]: BitSet128;
-    [CopyableIsaacAPIClassType.COLOR]: Color;
-    [CopyableIsaacAPIClassType.K_COLOR]: KColor;
-    [CopyableIsaacAPIClassType.RNG]: RNG;
-    [CopyableIsaacAPIClassType.VECTOR]: Vector;
+    readonly [CopyableIsaacAPIClassType.BIT_SET_128]: Readonly<BitSet128>;
+    readonly [CopyableIsaacAPIClassType.COLOR]: Readonly<Color>;
+    readonly [CopyableIsaacAPIClassType.K_COLOR]: Readonly<KColor>;
+    readonly [CopyableIsaacAPIClassType.RNG]: Readonly<RNG>;
+    readonly [CopyableIsaacAPIClassType.VECTOR]: Readonly<Vector>;
 }
 
 /**
@@ -9306,63 +9317,63 @@ export declare enum ISCFeature {
 declare type ISCFeaturesToKeys<T extends readonly ISCFeature[]> = Omit<TupleToIntersection<ISCFeatureTupleToClassTuple<Writeable<T>>>, keyof Feature>;
 
 declare interface ISCFeatureToClass {
-    [ISCFeature.CUSTOM_REVIVE]: CustomRevive;
-    [ISCFeature.ESAU_JR_DETECTION]: EsauJrDetection;
-    [ISCFeature.FLIP_DETECTION]: FlipDetection;
-    [ISCFeature.GRID_ENTITY_COLLISION_DETECTION]: GridEntityCollisionDetection;
-    [ISCFeature.GRID_ENTITY_RENDER_DETECTION]: GridEntityRenderDetection;
-    [ISCFeature.GRID_ENTITY_UPDATE_DETECTION]: GridEntityUpdateDetection;
-    [ISCFeature.GAME_REORDERED_CALLBACKS]: GameReorderedCallbacks;
-    [ISCFeature.ITEM_PICKUP_DETECTION]: ItemPickupDetection;
-    [ISCFeature.PICKUP_CHANGE_DETECTION]: PickupChangeDetection;
-    [ISCFeature.PLAYER_COLLECTIBLE_DETECTION]: PlayerCollectibleDetection;
-    [ISCFeature.PLAYER_REORDERED_CALLBACKS]: PlayerReorderedCallbacks;
-    [ISCFeature.SLOT_DESTROYED_DETECTION]: SlotDestroyedDetection;
-    [ISCFeature.SLOT_RENDER_DETECTION]: SlotRenderDetection;
-    [ISCFeature.SLOT_UPDATE_DETECTION]: SlotUpdateDetection;
-    [ISCFeature.CHARACTER_HEALTH_CONVERSION]: CharacterHealthConversion;
-    [ISCFeature.CHARACTER_STATS]: CharacterStats;
-    [ISCFeature.COLLECTIBLE_ITEM_POOL_TYPE]: CollectibleItemPoolType;
-    [ISCFeature.CUSTOM_GRID_ENTITIES]: CustomGridEntities;
-    [ISCFeature.CUSTOM_ITEM_POOLS]: CustomItemPools;
-    [ISCFeature.CUSTOM_HOTKEYS]: CustomHotkeys;
-    [ISCFeature.CUSTOM_PICKUPS]: CustomPickups;
-    [ISCFeature.CUSTOM_STAGES]: CustomStages;
-    [ISCFeature.CUSTOM_TRAPDOORS]: CustomTrapdoors;
-    [ISCFeature.DEBUG_DISPLAY]: DebugDisplay;
-    [ISCFeature.DEPLOY_JSON_ROOM]: DeployJSONRoom;
-    [ISCFeature.DISABLE_ALL_SOUND]: DisableAllSound;
-    [ISCFeature.DISABLE_INPUTS]: DisableInputs;
-    [ISCFeature.EDEN_STARTING_STATS_HEALTH]: EdenStartingStatsHealth;
-    [ISCFeature.FADE_IN_REMOVER]: FadeInRemover;
-    [ISCFeature.FAST_RESET]: FastReset;
-    [ISCFeature.FLYING_DETECTION]: FlyingDetection;
-    [ISCFeature.FORGOTTEN_SWITCH]: ForgottenSwitch;
-    [ISCFeature.EXTRA_CONSOLE_COMMANDS]: ExtraConsoleCommands;
-    [ISCFeature.ITEM_POOL_DETECTION]: ItemPoolDetection;
-    [ISCFeature.MODDED_ELEMENT_DETECTION]: ModdedElementDetection;
-    [ISCFeature.MODDED_ELEMENT_SETS]: ModdedElementSets;
-    [ISCFeature.NO_SIREN_STEAL]: NoSirenSteal;
-    [ISCFeature.PAUSE]: Pause;
-    [ISCFeature.PERSISTENT_ENTITIES]: PersistentEntities;
-    [ISCFeature.PICKUP_INDEX_CREATION]: PickupIndexCreation;
-    [ISCFeature.PLAYER_COLLECTIBLE_TRACKING]: PlayerCollectibleTracking;
-    [ISCFeature.PONY_DETECTION]: PonyDetection;
-    [ISCFeature.PRESS_INPUT]: PressInput;
-    [ISCFeature.PREVENT_CHILD_ENTITIES]: PreventChildEntities;
-    [ISCFeature.PREVENT_GRID_ENTITY_RESPAWN]: PreventGridEntityRespawn;
-    [ISCFeature.RERUN_DETECTION]: RerunDetection;
-    [ISCFeature.ROOM_CLEAR_FRAME]: RoomClearFrame;
-    [ISCFeature.ROOM_HISTORY]: RoomHistory;
-    [ISCFeature.RUN_IN_N_FRAMES]: RunInNFrames;
-    [ISCFeature.RUN_NEXT_ROOM]: RunNextRoom;
-    [ISCFeature.RUN_NEXT_RUN]: RunNextRun;
-    [ISCFeature.SAVE_DATA_MANAGER]: SaveDataManager;
-    [ISCFeature.SPAWN_ALT_ROCK_REWARDS]: SpawnRockAltRewards;
-    [ISCFeature.STAGE_HISTORY]: StageHistory;
-    [ISCFeature.START_AMBUSH]: StartAmbush;
-    [ISCFeature.TAINTED_LAZARUS_PLAYERS]: TaintedLazarusPlayers;
-    [ISCFeature.UNLOCK_ACHIEVEMENTS_DETECTION]: UnlockAchievementsDetection;
+    readonly [ISCFeature.CUSTOM_REVIVE]: CustomRevive;
+    readonly [ISCFeature.ESAU_JR_DETECTION]: EsauJrDetection;
+    readonly [ISCFeature.FLIP_DETECTION]: FlipDetection;
+    readonly [ISCFeature.GRID_ENTITY_COLLISION_DETECTION]: GridEntityCollisionDetection;
+    readonly [ISCFeature.GRID_ENTITY_RENDER_DETECTION]: GridEntityRenderDetection;
+    readonly [ISCFeature.GRID_ENTITY_UPDATE_DETECTION]: GridEntityUpdateDetection;
+    readonly [ISCFeature.GAME_REORDERED_CALLBACKS]: GameReorderedCallbacks;
+    readonly [ISCFeature.ITEM_PICKUP_DETECTION]: ItemPickupDetection;
+    readonly [ISCFeature.PICKUP_CHANGE_DETECTION]: PickupChangeDetection;
+    readonly [ISCFeature.PLAYER_COLLECTIBLE_DETECTION]: PlayerCollectibleDetection;
+    readonly [ISCFeature.PLAYER_REORDERED_CALLBACKS]: PlayerReorderedCallbacks;
+    readonly [ISCFeature.SLOT_DESTROYED_DETECTION]: SlotDestroyedDetection;
+    readonly [ISCFeature.SLOT_RENDER_DETECTION]: SlotRenderDetection;
+    readonly [ISCFeature.SLOT_UPDATE_DETECTION]: SlotUpdateDetection;
+    readonly [ISCFeature.CHARACTER_HEALTH_CONVERSION]: CharacterHealthConversion;
+    readonly [ISCFeature.CHARACTER_STATS]: CharacterStats;
+    readonly [ISCFeature.COLLECTIBLE_ITEM_POOL_TYPE]: CollectibleItemPoolType;
+    readonly [ISCFeature.CUSTOM_GRID_ENTITIES]: CustomGridEntities;
+    readonly [ISCFeature.CUSTOM_ITEM_POOLS]: CustomItemPools;
+    readonly [ISCFeature.CUSTOM_HOTKEYS]: CustomHotkeys;
+    readonly [ISCFeature.CUSTOM_PICKUPS]: CustomPickups;
+    readonly [ISCFeature.CUSTOM_STAGES]: CustomStages;
+    readonly [ISCFeature.CUSTOM_TRAPDOORS]: CustomTrapdoors;
+    readonly [ISCFeature.DEBUG_DISPLAY]: DebugDisplay;
+    readonly [ISCFeature.DEPLOY_JSON_ROOM]: DeployJSONRoom;
+    readonly [ISCFeature.DISABLE_ALL_SOUND]: DisableAllSound;
+    readonly [ISCFeature.DISABLE_INPUTS]: DisableInputs;
+    readonly [ISCFeature.EDEN_STARTING_STATS_HEALTH]: EdenStartingStatsHealth;
+    readonly [ISCFeature.FADE_IN_REMOVER]: FadeInRemover;
+    readonly [ISCFeature.FAST_RESET]: FastReset;
+    readonly [ISCFeature.FLYING_DETECTION]: FlyingDetection;
+    readonly [ISCFeature.FORGOTTEN_SWITCH]: ForgottenSwitch;
+    readonly [ISCFeature.EXTRA_CONSOLE_COMMANDS]: ExtraConsoleCommands;
+    readonly [ISCFeature.ITEM_POOL_DETECTION]: ItemPoolDetection;
+    readonly [ISCFeature.MODDED_ELEMENT_DETECTION]: ModdedElementDetection;
+    readonly [ISCFeature.MODDED_ELEMENT_SETS]: ModdedElementSets;
+    readonly [ISCFeature.NO_SIREN_STEAL]: NoSirenSteal;
+    readonly [ISCFeature.PAUSE]: Pause;
+    readonly [ISCFeature.PERSISTENT_ENTITIES]: PersistentEntities;
+    readonly [ISCFeature.PICKUP_INDEX_CREATION]: PickupIndexCreation;
+    readonly [ISCFeature.PLAYER_COLLECTIBLE_TRACKING]: PlayerCollectibleTracking;
+    readonly [ISCFeature.PONY_DETECTION]: PonyDetection;
+    readonly [ISCFeature.PRESS_INPUT]: PressInput;
+    readonly [ISCFeature.PREVENT_CHILD_ENTITIES]: PreventChildEntities;
+    readonly [ISCFeature.PREVENT_GRID_ENTITY_RESPAWN]: PreventGridEntityRespawn;
+    readonly [ISCFeature.RERUN_DETECTION]: RerunDetection;
+    readonly [ISCFeature.ROOM_CLEAR_FRAME]: RoomClearFrame;
+    readonly [ISCFeature.ROOM_HISTORY]: RoomHistory;
+    readonly [ISCFeature.RUN_IN_N_FRAMES]: RunInNFrames;
+    readonly [ISCFeature.RUN_NEXT_ROOM]: RunNextRoom;
+    readonly [ISCFeature.RUN_NEXT_RUN]: RunNextRun;
+    readonly [ISCFeature.SAVE_DATA_MANAGER]: SaveDataManager;
+    readonly [ISCFeature.SPAWN_ALT_ROCK_REWARDS]: SpawnRockAltRewards;
+    readonly [ISCFeature.STAGE_HISTORY]: StageHistory;
+    readonly [ISCFeature.START_AMBUSH]: StartAmbush;
+    readonly [ISCFeature.TAINTED_LAZARUS_PLAYERS]: TaintedLazarusPlayers;
+    readonly [ISCFeature.UNLOCK_ACHIEVEMENTS_DETECTION]: UnlockAchievementsDetection;
 }
 
 declare type ISCFeatureTuple<T extends readonly ISCFeature[]> = ISCFeature extends T["length"] ? 'The list of features must be a tuple. Use the "as const" assertion when declaring the array.' : T;
@@ -10486,15 +10497,15 @@ export declare function isVoidDoor(door: GridEntityDoor): boolean;
 export declare const itemConfig: ItemConfig;
 
 declare class ItemPickupDetection extends Feature {
+    private readonly postItemPickup;
+    private readonly preItemPickup;
+    private readonly postPEffectUpdateReordered;
     v: {
         run: {
             playersPickingUpItemMap: DefaultMap<PlayerIndex, PickingUpItem, []>;
         };
     };
-    private readonly postItemPickup;
-    private readonly preItemPickup;
     constructor(postItemPickup: PostItemPickup, preItemPickup: PreItemPickup);
-    private readonly postPEffectUpdateReordered;
     private queueEmpty;
     private queueNotEmpty;
 }
@@ -10586,13 +10597,13 @@ export declare function jsonDecode(jsonString: string): LuaMap<AnyNotNil, unknow
 
 /** Part of `JSONRoomsFile`. */
 export declare interface JSONDoor {
-    $: {
+    readonly $: {
         /** Equal to "True" or "False". Needs to be converted to an `boolean`. */
-        exists: string;
+        readonly exists: string;
         /** Needs to be converted to an `int`. */
-        x: string;
+        readonly x: string;
         /** Needs to be converted to an `int`. */
-        y: string;
+        readonly y: string;
     };
 }
 
@@ -10610,46 +10621,46 @@ export declare function jsonEncode(luaTable: unknown): string;
 
 /** Part of `JSONRoomsFile`. */
 export declare interface JSONEntity {
-    $: {
+    readonly $: {
         /** Needs to be converted to an `int`. */
-        type: string;
+        readonly type: string;
         /** Needs to be converted to an `int`. */
-        variant: string;
+        readonly variant: string;
         /** Needs to be converted to an `int`. */
-        subtype: string;
+        readonly subtype: string;
         /** Needs to be converted to a `float`. */
-        weight: string;
+        readonly weight: string;
     };
 }
 
 /** Part of `JSONRoomsFile`. */
 export declare interface JSONRoom {
-    $: {
+    readonly $: {
         /** Needs to be converted to an `int`. */
-        difficulty: string;
+        readonly difficulty: string;
         /** Needs to be converted to an `int`. */
-        height: string;
-        name: string;
+        readonly height: string;
+        readonly name: string;
         /** Needs to be converted to an `int`. */
-        shape: string;
+        readonly shape: string;
         /** Needs to be converted to an `int`. */
-        subtype: string;
+        readonly subtype: string;
         /** Needs to be converted to an `int`. */
-        type: string;
+        readonly type: string;
         /** Needs to be converted to an `int`. */
-        variant: string;
+        readonly variant: string;
         /** Needs to be converted to a `float`. */
-        weight: string;
+        readonly weight: string;
         /** Needs to be converted to an `int`. */
-        width: string;
+        readonly width: string;
     };
-    door: JSONDoor[];
-    spawn: JSONSpawn[];
+    readonly door: readonly JSONDoor[];
+    readonly spawn: readonly JSONSpawn[];
 }
 
 /** Part of `JSONRoomsFile`. */
 export declare interface JSONRooms {
-    room: JSONRoom[];
+    readonly room: readonly JSONRoom[];
 }
 
 /**
@@ -10668,18 +10679,18 @@ export declare interface JSONRooms {
  * specifically.
  */
 export declare interface JSONRoomsFile {
-    rooms: JSONRooms;
+    readonly rooms: JSONRooms;
 }
 
 /** Part of `JSONRoomsFile`. */
 export declare interface JSONSpawn {
-    $: {
+    readonly $: {
         /** Needs to be converted to an `int`. */
-        x: string;
+        readonly x: string;
         /** Needs to be converted to an `int`. */
-        y: string;
+        readonly y: string;
     };
-    entity: JSONEntity[];
+    readonly entity: readonly JSONEntity[];
 }
 
 /**
@@ -14776,14 +14787,32 @@ export declare const MODIFIER_KEYS: readonly [Keyboard.LEFT_SHIFT, Keyboard.LEFT
  * corresponds to the internal-type `ModUpgradedWithFeatures` type, which extends `ModUpgraded`.)
  */
 export declare class ModUpgraded implements Mod {
-    Name: string;
     /** We store a copy of the original mod object so that we can re-implement its functions. */
     private readonly mod;
     private readonly debug;
     private readonly timeThreshold;
     private readonly callbacks;
     private readonly features;
+    readonly Name: string;
     constructor(mod: Mod, debug: boolean, timeThreshold?: float);
+    /**
+     * This is used to initialize both custom callbacks and "extra features".
+     *
+     * This mirrors the `uninitFeature` method.
+     */
+    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. This is
+     * called from the "upgradeMod" function, but we want to mark it as private so that end-users
+     * don't have access to it.
+     */
+    private initOptionalFeature;
     AddCallback<T extends keyof AddCallbackParameters | string>(modCallback: T, ...args: T extends keyof AddCallbackParameters ? AddCallbackParameters[T] : unknown[]): void;
     AddPriorityCallback<T extends keyof AddCallbackParameters | string>(modCallback: T, priority: CallbackPriority | int, ...args: T extends keyof AddCallbackParameters ? AddCallbackParameters[T] : unknown[]): void;
     HasData(): boolean;
@@ -14821,24 +14850,6 @@ export declare class ModUpgraded implements Mod {
      * profiling.
      */
     logUsedFeatures(): void;
-    /**
-     * This is used to initialize both custom callbacks and "extra features".
-     *
-     * This mirrors the `uninitFeature` method.
-     */
-    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. This is
-     * called from the "upgradeMod" function, but we want to mark it as private so that end-users
-     * don't have access to it.
-     */
-    private initOptionalFeature;
 }
 
 /**
@@ -15440,8 +15451,8 @@ export declare function parseSemanticVersion(versionString: string): {
 declare class Pause extends Feature {
     private readonly disableInputs;
     private readonly postUpdate;
-    private stopTearsAndProjectilesFromMoving;
     private readonly inputActionGetActionValue;
+    private stopTearsAndProjectilesFromMoving;
     /**
      * Helper function to check if the pause feature from `isaacscript-common` is currently
      * pseudo-pausing the game.
@@ -15476,12 +15487,12 @@ declare class Pause extends Feature {
 declare class PersistentEntities extends Feature {
     private readonly roomHistory;
     private readonly postEntityRemove;
+    private readonly postNewRoomReordered;
     /**
      * The persistent entity is despawning because the player is in the process of leaving the room.
      * Keep track of the position for later.
      */
     private trackDespawningPickupPosition;
-    private readonly postNewRoomReordered;
     private spawnAndTrack;
     /**
      * Helper function to stop an entity spawned with the `spawnPersistentEntity` helper function from
@@ -15491,12 +15502,12 @@ declare class PersistentEntities extends Feature {
      *
      * @param persistentEntityIndex The index that was returned by the `spawnPersistentEntity`
      *                              function.
-     * @param removeEntity Optional. True by default. Set to false if you want to stop an entity from
-     *                     being persistent but you don't want to actually remove the
-     *                     currently-spawned entity from the room.
+     * @param shouldRemoveEntity Optional. True by default. Set to false if you want to stop an entity
+     *                           from being persistent but you don't want to actually remove the
+     *                           currently-spawned entity from the room.
      * @public
      */
-    removePersistentEntity(persistentEntityIndex: int, removeEntity?: boolean): void;
+    removePersistentEntity(persistentEntityIndex: int, shouldRemoveEntity?: boolean): void;
     /**
      * Helper function to spawn an entity that will have persistence similar to a pickup.
      *
@@ -15549,16 +15560,16 @@ export declare interface PickingUpItemTrinket {
 }
 
 declare class PickupChangeDetection extends Feature {
+    private readonly postPickupChanged;
+    private readonly pickupIndexCreation;
+    private readonly postPickupUpdate;
     v: {
         room: {
             pickupVariants: Map<PickupIndex, PickupVariant>;
             pickupSubTypes: Map<PickupIndex, int>;
         };
     };
-    private readonly postPickupChanged;
-    private readonly pickupIndexCreation;
     constructor(postPickupChanged: PostPickupChanged, pickupIndexCreation: PickupIndexCreation);
-    private readonly postPickupUpdate;
 }
 
 /**
@@ -15583,9 +15594,9 @@ declare class PickupIndexCreation extends Feature {
     private readonly roomHistory;
     private readonly saveDataManager;
     private readonly postPickupInit;
+    private readonly postEntityRemovePickup;
     private setPickupIndex;
     private getPickupIndexFromPreviousData;
-    private readonly postEntityRemovePickup;
     private checkDespawningFromPlayerLeavingRoom;
     /**
      * This is a pickup that is despawning because the player is in the process of leaving the room.
@@ -15636,6 +15647,19 @@ export declare const PILL_NAME_TO_EFFECT_MAP: ReadonlyMap<string, PillEffect>;
 export declare function playChargeSoundEffect(player: EntityPlayer, activeSlot?: ActiveSlot): void;
 
 declare class PlayerCollectibleDetection extends Feature {
+    private readonly postPlayerCollectibleAdded;
+    private readonly postPlayerCollectibleRemoved;
+    private readonly moddedElementSets;
+    private readonly runInNFrames;
+    private readonly postUseItemD4;
+    /** We need to handle the case of Tainted Eden taking damage. */
+    private readonly entityTakeDmgPlayer;
+    /**
+     * We need to handle TMTRAINER collectibles, since they do not cause the player's collectible
+     * count to change.
+     */
+    private readonly postItemPickup;
+    private readonly postPEffectUpdateReordered;
     v: {
         run: {
             playersCollectibleCount: DefaultMap<PlayerIndex, int, []>;
@@ -15643,10 +15667,6 @@ declare class PlayerCollectibleDetection extends Feature {
             playersActiveItemMap: DefaultMap<PlayerIndex, Map<ActiveSlot, CollectibleType>, []>;
         };
     };
-    private readonly postPlayerCollectibleAdded;
-    private readonly postPlayerCollectibleRemoved;
-    private readonly moddedElementSets;
-    private readonly runInNFrames;
     constructor(postPlayerCollectibleAdded: PostPlayerCollectibleAdded, postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved, moddedElementSets: ModdedElementSets, runInNFrames: RunInNFrames);
     /**
      * This is called when the collectible count changes and in situations where the entire build is
@@ -15661,15 +15681,6 @@ declare class PlayerCollectibleDetection extends Feature {
      *                               rerolled.
      */
     private updateCollectibleMapAndFire;
-    private readonly postUseItemD4;
-    /** We need to handle the case of Tainted Eden taking damage. */
-    private readonly entityTakeDmgPlayer;
-    /**
-     * We need to handle TMTRAINER collectibles, since they do not cause the player's collectible
-     * count to change.
-     */
-    private readonly postItemPickup;
-    private readonly postPEffectUpdateReordered;
     /**
      * Checking for collectible count will work to detect when a player swaps their active item for
      * another active item. This is because the collectible count will decrement by 1 when the item is
@@ -15746,19 +15757,19 @@ export declare function playerHasHealthLeft(player: EntityPlayer): boolean;
 
 /** This is used by the `getPlayerHealth` and `setPlayerHealth` helper functions. */
 export declare interface PlayerHealth {
-    maxHearts: int;
-    hearts: int;
-    eternalHearts: int;
+    readonly maxHearts: int;
+    readonly hearts: int;
+    readonly eternalHearts: int;
     /** For soul hearts to apply, they also have to be specified in the `soulHeartTypes` array. */
-    soulHearts: int;
+    readonly soulHearts: int;
     /** For bone hearts to apply, they also have to be specified in the `soulHeartTypes` array. */
-    boneHearts: int;
-    goldenHearts: int;
-    rottenHearts: int;
-    brokenHearts: int;
-    soulCharges: int;
-    bloodCharges: int;
-    soulHeartTypes: SoulHeartType[];
+    readonly boneHearts: int;
+    readonly goldenHearts: int;
+    readonly rottenHearts: int;
+    readonly brokenHearts: int;
+    readonly soulCharges: int;
+    readonly bloodCharges: int;
+    readonly soulHeartTypes: readonly SoulHeartType[];
 }
 
 /**
@@ -15780,6 +15791,13 @@ export declare type PlayerIndex = int & {
 };
 
 declare class PlayerReorderedCallbacks extends Feature {
+    private readonly postPEffectUpdateReordered;
+    private readonly postPlayerRenderReordered;
+    private readonly postPlayerUpdateReordered;
+    private readonly postPEffectUpdate;
+    private readonly postPlayerUpdate;
+    private readonly postPlayerRender;
+    private readonly postGameStartedReorderedLast;
     v: {
         run: {
             postGameStartedFiredOnThisRun: boolean;
@@ -15788,14 +15806,7 @@ declare class PlayerReorderedCallbacks extends Feature {
             postPlayerRenderQueue: QueueElement[];
         };
     };
-    private readonly postPEffectUpdateReordered;
-    private readonly postPlayerRenderReordered;
-    private readonly postPlayerUpdateReordered;
     constructor(postPEffectUpdateReordered: PostPEffectUpdateReordered, postPlayerRenderReordered: PostPlayerRenderReordered, postPlayerUpdateReordered: PostPlayerUpdateReordered);
-    private readonly postPEffectUpdate;
-    private readonly postPlayerUpdate;
-    private readonly postPlayerRender;
-    private readonly postGameStartedReorderedLast;
 }
 
 /** This represents the kinds of stats that a player can have. */
@@ -15833,26 +15844,26 @@ export declare enum PlayerStat {
  * is a `float` type.
  */
 export declare interface PlayerStats {
-    [PlayerStat.DAMAGE]: float;
-    [PlayerStat.FIRE_DELAY]: float;
-    [PlayerStat.SHOT_SPEED]: float;
-    [PlayerStat.TEAR_HEIGHT]: float;
-    [PlayerStat.TEAR_RANGE]: float;
-    [PlayerStat.TEAR_FALLING_ACCELERATION]: float;
-    [PlayerStat.TEAR_FALLING_SPEED]: float;
-    [PlayerStat.MOVE_SPEED]: float;
-    [PlayerStat.TEAR_FLAG]: BitFlags<TearFlag>;
-    [PlayerStat.TEAR_COLOR]: Color;
-    [PlayerStat.FLYING]: boolean;
-    [PlayerStat.LUCK]: float;
-    [PlayerStat.SIZE]: Vector;
+    readonly [PlayerStat.DAMAGE]: float;
+    readonly [PlayerStat.FIRE_DELAY]: float;
+    readonly [PlayerStat.SHOT_SPEED]: float;
+    readonly [PlayerStat.TEAR_HEIGHT]: float;
+    readonly [PlayerStat.TEAR_RANGE]: float;
+    readonly [PlayerStat.TEAR_FALLING_ACCELERATION]: float;
+    readonly [PlayerStat.TEAR_FALLING_SPEED]: float;
+    readonly [PlayerStat.MOVE_SPEED]: float;
+    readonly [PlayerStat.TEAR_FLAG]: Readonly<BitFlags<TearFlag>>;
+    readonly [PlayerStat.TEAR_COLOR]: Readonly<Color>;
+    readonly [PlayerStat.FLYING]: boolean;
+    readonly [PlayerStat.LUCK]: float;
+    readonly [PlayerStat.SIZE]: Readonly<Vector>;
 }
 
 /** This is used by the `getPocketItems` and related helper functions. */
 export declare interface PocketItemDescription {
-    slot: PocketItemSlot;
-    type: PocketItemType;
-    subType: int;
+    readonly slot: PocketItemSlot;
+    readonly type: PocketItemType;
+    readonly subType: int;
 }
 
 /** Helper function to see if two sets of pocket item descriptions are identical. */
@@ -15897,8 +15908,8 @@ declare class PonyDetection extends Feature {
 export declare type PossibleStatType = number | boolean | BitFlags<TearFlag> | Color | Vector;
 
 declare class PostCustomRevive extends CustomCallback<ModCallbackCustom.POST_CUSTOM_REVIVE> {
-    constructor();
     protected shouldFire: (fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>) => boolean;
+    constructor();
 }
 
 declare class PostEsauJr extends CustomCallback<ModCallbackCustom.POST_ESAU_JR> {
@@ -15918,143 +15929,143 @@ declare class PostFlip extends CustomCallback<ModCallbackCustom.POST_FLIP> {
 }
 
 declare class PostGridEntityBroken extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_BROKEN> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntity;
+    constructor();
 }
 
 declare class PostGridEntityCollision extends CustomCallback<T_2> {
-    constructor();
     protected shouldFire: (fireArgs: FireArgs<T_2>, optionalArgs: OptionalArgs<T_2>) => boolean;
+    constructor();
 }
 
 declare class PostGridEntityCustomBroken extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntityCustom;
+    constructor();
 }
 
 declare class PostGridEntityCustomCollision extends CustomCallback<T_3> {
-    constructor();
     protected shouldFire: (fireArgs: FireArgs<T_3>, optionalArgs: OptionalArgs<T_3>) => boolean;
+    constructor();
 }
 
 declare class PostGridEntityCustomInit extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_INIT> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntityCustom;
+    constructor();
 }
 
 declare class PostGridEntityCustomRemove extends CustomCallback<T_5> {
-    constructor();
     protected shouldFire: (fireArgs: FireArgs<T_5>, optionalArgs: OptionalArgs<T_5>) => boolean;
+    constructor();
 }
 
 declare class PostGridEntityCustomRender extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_RENDER> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntityCustom;
+    constructor();
 }
 
 declare class PostGridEntityCustomStateChanged extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntityCustom;
+    constructor();
 }
 
 declare class PostGridEntityCustomUpdate extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntityCustom;
+    constructor();
 }
 
 declare class PostGridEntityInit extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_INIT> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntity;
+    constructor();
 }
 
 declare class PostGridEntityRemove extends CustomCallback<T_4> {
-    constructor();
     protected shouldFire: (fireArgs: FireArgs<T_4>, optionalArgs: OptionalArgs<T_4>) => boolean;
+    constructor();
 }
 
 declare class PostGridEntityRender extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_RENDER> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntity;
+    constructor();
 }
 
 declare class PostGridEntityStateChanged extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_STATE_CHANGED> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntity;
+    constructor();
 }
 
 declare class PostGridEntityUpdate extends CustomCallback<ModCallbackCustom.POST_GRID_ENTITY_UPDATE> {
-    constructor();
     protected shouldFire: typeof shouldFireGridEntity;
+    constructor();
 }
 
 declare class PostItemPickup extends CustomCallback<ModCallbackCustom.POST_ITEM_PICKUP> {
-    constructor();
     protected shouldFire: typeof shouldFireItemPickup;
+    constructor();
 }
 
 declare class PostPEffectUpdateReordered extends CustomCallback<ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED> {
-    constructor();
     protected shouldFire: typeof shouldFirePlayer;
+    constructor();
 }
 
 declare class PostPickupChanged extends CustomCallback<ModCallbackCustom.POST_PICKUP_CHANGED> {
-    constructor();
     protected shouldFire: typeof shouldFirePickup;
+    constructor();
 }
 
 declare class PostPlayerCollectibleAdded extends CustomCallback<ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED> {
-    constructor();
     protected shouldFire: typeof shouldFireCollectibleType;
+    constructor();
 }
 
 declare class PostPlayerCollectibleRemoved extends CustomCallback<ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED> {
-    constructor();
     protected shouldFire: typeof shouldFireCollectibleType;
+    constructor();
 }
 
 declare class PostPlayerRenderReordered extends CustomCallback<ModCallbackCustom.POST_PLAYER_RENDER_REORDERED> {
-    constructor();
     protected shouldFire: typeof shouldFirePlayer;
+    constructor();
 }
 
 declare class PostPlayerUpdateReordered extends CustomCallback<ModCallbackCustom.POST_PLAYER_UPDATE_REORDERED> {
-    constructor();
     protected shouldFire: typeof shouldFirePlayer;
+    constructor();
 }
 
 declare class PostSlotAnimationChanged extends CustomCallback<ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED> {
-    constructor();
     protected shouldFire: typeof shouldFireSlot;
+    constructor();
 }
 
 declare class PostSlotDestroyed extends CustomCallback<ModCallbackCustom.POST_SLOT_DESTROYED> {
-    constructor();
     protected shouldFire: typeof shouldFireSlot;
+    constructor();
 }
 
 declare class PostSlotInit extends CustomCallback<ModCallbackCustom.POST_SLOT_INIT> {
-    constructor();
     protected shouldFire: typeof shouldFireSlot;
+    constructor();
 }
 
 declare class PostSlotRender extends CustomCallback<ModCallbackCustom.POST_SLOT_RENDER> {
-    constructor();
     protected shouldFire: typeof shouldFireSlot;
+    constructor();
 }
 
 declare class PostSlotUpdate extends CustomCallback<ModCallbackCustom.POST_SLOT_UPDATE> {
-    constructor();
     protected shouldFire: typeof shouldFireSlot;
+    constructor();
 }
 
 declare class PreCustomRevive extends CustomCallback<ModCallbackCustom.PRE_CUSTOM_REVIVE> {
-    constructor();
     protected shouldFire: typeof shouldFirePlayer;
+    constructor();
 }
 
 declare class PreItemPickup extends CustomCallback<ModCallbackCustom.PRE_ITEM_PICKUP> {
-    constructor();
     protected shouldFire: typeof shouldFireItemPickup;
+    constructor();
 }
 
 declare class PressInput extends Feature {
@@ -16162,8 +16173,8 @@ export declare type PublicInterface<T> = Pick<T, keyof T>;
 export declare const QUALITIES: readonly Quality[];
 
 declare interface QueueElement {
-    playerIndex: PlayerIndex;
-    renderOffset: Vector;
+    readonly playerIndex: PlayerIndex;
+    readonly renderOffset: Readonly<Vector>;
 }
 
 /** An alias for the `Map` constructor that returns a read-only map. */
@@ -16990,18 +17001,18 @@ declare class RoomClearFrame extends Feature {
 
 /** This is used by the room history feature of the standard library. */
 export declare interface RoomDescription {
-    startSeedString: string;
-    stage: LevelStage;
-    stageType: StageType;
-    stageID: StageID | -1;
-    dimension: Dimension;
-    roomType: RoomType;
-    roomVariant: int;
-    roomSubType: int;
-    roomName: string;
-    roomGridIndex: int;
-    roomListIndex: int;
-    roomVisitedCount: int;
+    readonly startSeedString: string;
+    readonly stage: LevelStage;
+    readonly stageType: StageType;
+    readonly stageID: StageID | -1;
+    readonly dimension: Dimension;
+    readonly roomType: RoomType;
+    readonly roomVariant: int;
+    readonly roomSubType: int;
+    readonly roomName: string;
+    readonly roomGridIndex: int;
+    readonly roomListIndex: int;
+    readonly roomVisitedCount: int;
 }
 
 /**
@@ -17109,7 +17120,7 @@ export declare function roomUpdateSafe(): void;
 /**
  * If rounding fails, this function returns 0.
  *
- * From: http://lua-users.org/wiki/SimpleRound
+ * From: https://lua-users.org/wiki/SimpleRound
  *
  * @param num The number to round.
  * @param numDecimalPlaces Optional. Default is 0.
@@ -17124,10 +17135,10 @@ export declare function round(num: float, numDecimalPlaces?: number): float;
 export declare function runDeepCopyTests(): void;
 
 declare class RunInNFrames extends Feature {
-    vConditionalFunc: () => boolean;
     private readonly roomHistory;
     private readonly postUpdate;
     private readonly postRender;
+    vConditionalFunc: () => boolean;
     /**
      * Helper function to restart on the next render frame. Useful because it is impossible to restart
      * the game inside of the `POST_NEW_ROOM`, `POST_NEW_LEVEL`, or `POST_GAME_STARTED` callbacks when
@@ -17283,8 +17294,8 @@ declare class RunInNFrames extends Feature {
 export declare function runMergeTests(): void;
 
 declare class RunNextRoom extends Feature {
-    vConditionalFunc: () => boolean;
     private readonly postNewRoomReordered;
+    vConditionalFunc: () => boolean;
     /**
      * Supply a function to run on the next `POST_NEW_ROOM` callback.
      *
@@ -17298,8 +17309,8 @@ declare class RunNextRoom extends Feature {
 }
 
 declare class RunNextRun extends Feature {
-    vConditionalFunc: () => boolean;
     private readonly postGameStartedReorderedFalse;
+    vConditionalFunc: () => boolean;
     /**
      * Supply a function to run on the next `POST_GAME_STARTED` callback.
      *
@@ -17395,6 +17406,10 @@ declare class SaveDataManager extends Feature {
     private readonly preGameExit;
     private readonly postNewLevel;
     private readonly postNewRoomEarly;
+    /**
+     * Recursively traverses an object, collecting all of the class constructors that it encounters.
+     */
+    private storeClassConstructorsFromObject;
     /**
      * This is the entry point to the save data manager, a system which provides two major features:
      *
@@ -17499,10 +17514,6 @@ declare class SaveDataManager extends Feature {
      */
     saveDataManager<Persistent, Run, Level>(key: string | object, v: SaveData<Persistent, Run, Level>, conditionalFunc?: () => boolean): void;
     saveDataManager(key: string | object, v: SaveData, conditionalFunc: false): void;
-    /**
-     * Recursively traverses an object, collecting all of the class constructors that it encounters.
-     */
-    private storeClassConstructorsFromObject;
     /**
      * The save data manager will automatically load variables from disk at the appropriate times
      * (i.e. when a new run is started). Use this function to explicitly force the save data manager
@@ -17666,12 +17677,12 @@ export declare function serializeBitSet128(bitSet128: BitSet128): SerializedBitS
  */
 export declare function serializeColor(color: Color): SerializedColor;
 
-export declare type SerializedBitSet128 = LuaMap<string, unknown> & {
+export declare type SerializedBitSet128 = Readonly<LuaMap<string, unknown>> & {
     readonly __serializedBitSet128Brand: symbol;
     readonly __kind: CopyableIsaacAPIClassType.BIT_SET_128;
 };
 
-export declare type SerializedColor = LuaMap<string, unknown> & {
+export declare type SerializedColor = Readonly<LuaMap<string, unknown>> & {
     readonly __serializedColorBrand: symbol;
     readonly __kind: CopyableIsaacAPIClassType.COLOR;
 };
@@ -17684,17 +17695,17 @@ export declare type SerializedColor = LuaMap<string, unknown> & {
  */
 declare type SerializedIsaacAPIClass = SerializedBitSet128 | SerializedColor | SerializedKColor | SerializedRNG | SerializedVector;
 
-export declare type SerializedKColor = LuaMap<string, unknown> & {
+export declare type SerializedKColor = Readonly<LuaMap<string, unknown>> & {
     readonly __serializedKColorBrand: symbol;
     readonly __kind: CopyableIsaacAPIClassType.K_COLOR;
 };
 
-export declare type SerializedRNG = LuaMap<string, unknown> & {
+export declare type SerializedRNG = Readonly<LuaMap<string, unknown>> & {
     readonly __serializedRNGBrand: symbol;
     readonly __kind: CopyableIsaacAPIClassType.RNG;
 };
 
-export declare type SerializedVector = LuaMap<string, unknown> & {
+export declare type SerializedVector = Readonly<LuaMap<string, unknown>> & {
     readonly __serializedVectorBrand: symbol;
     readonly __kind: CopyableIsaacAPIClassType.VECTOR;
 };
@@ -18207,18 +18218,18 @@ export declare function shuffleArrayInPlace(array: unknown[], seedOrRNG: Seed |
 export declare function sign(n: number): int;
 
 declare class SlotDestroyedDetection extends Feature {
+    private readonly postSlotDestroyed;
+    private readonly roomHistory;
+    private readonly postEntityRemoveSlot;
+    private readonly postSlotUpdate;
     v: {
         room: {
             destroyedSlotSet: Set<PtrHash>;
         };
     };
-    private readonly postSlotDestroyed;
-    private readonly roomHistory;
     constructor(postSlotDestroyed: PostSlotDestroyed, roomHistory: RoomHistory);
-    private readonly postEntityRemoveSlot;
     private postEntityRemoveSlotMachine;
     private postEntityRemoveBeggar;
-    private readonly postSlotUpdate;
     /**
      * Slots normally have an entity collision class of `EntityCollisionClass.ALL` (4) and a grid
      * collision class of `EntityGridCollisionClass.NONE` (0). When they are destroyed with a bomb,
@@ -18248,30 +18259,30 @@ export declare enum SlotDestructionType {
 }
 
 declare class SlotRenderDetection extends Feature {
+    private readonly postSlotRender;
+    private readonly postSlotAnimationChanged;
+    private readonly postRender;
     v: {
         room: {
             slotAnimations: DefaultMap<PtrHash, string, [slot: Entity]>;
             brokenSlots: Set<PtrHash>;
         };
     };
-    private readonly postSlotRender;
-    private readonly postSlotAnimationChanged;
     constructor(postSlotRender: PostSlotRender, postSlotAnimationChanged: PostSlotAnimationChanged);
-    private readonly postRender;
     private checkSlotAnimationChanged;
 }
 
 declare class SlotUpdateDetection extends Feature {
+    private readonly postSlotInit;
+    private readonly postSlotUpdate;
+    private readonly postUpdate;
+    private readonly postNewRoomReordered;
     v: {
         room: {
             initializedSlots: Set<PtrHash>;
         };
     };
-    private readonly postSlotInit;
-    private readonly postSlotUpdate;
     constructor(postSlotInit: PostSlotInit, postSlotUpdate: PostSlotUpdate);
-    private readonly postUpdate;
-    private readonly postNewRoomReordered;
     private checkNewEntity;
 }
 
@@ -18566,12 +18577,12 @@ export declare function spawnGiantPoop(topLeftGridIndex: int): boolean;
  * @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 removeExistingGridEntity Optional. Whether to remove the existing grid entity on the same
- *                                 tile, if it exists. Defaults to true. If false, this function
- *                                 will do nothing, since spawning a grid entity on top of another
- *                                 grid entity will not replace it.
+ * @param shouldRemoveExistingGridEntity Optional. Whether to remove the existing grid entity on the
+ *                                 same tile, if it exists. Defaults to true. If false, this
+ *                                 function will do nothing, since spawning a grid entity on top of
+ *                                 another grid entity will not replace it.
  */
-export declare function spawnGridEntity(gridEntityType: GridEntityType, gridIndexOrPosition: int | Vector, removeExistingGridEntity?: boolean): GridEntity | undefined;
+export declare function spawnGridEntity(gridEntityType: GridEntityType, gridIndexOrPosition: int | Vector, shouldRemoveExistingGridEntity?: boolean): GridEntity | undefined;
 
 /**
  * Helper function to spawn a grid entity with a specific variant.
@@ -18586,12 +18597,12 @@ export declare function spawnGridEntity(gridEntityType: GridEntityType, gridInde
  * @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 removeExistingGridEntity Optional. Whether to remove the existing grid entity on the same
- *                                 tile, if it exists. Defaults to true. If false, this function
- *                                 will do nothing, since spawning a grid entity on top of another
- *                                 grid entity will not replace it.
+ * @param shouldRemoveExistingGridEntity Optional. Whether to remove the existing grid entity on the
+ *                                 same tile, if it exists. Defaults to true. If false, this
+ *                                 function will do nothing, since spawning a grid entity on top of
+ *                                 another grid entity will not replace it.
  */
-export declare function spawnGridEntityWithVariant(gridEntityType: GridEntityType, variant: int, gridIndexOrPosition: int | Vector, removeExistingGridEntity?: boolean): GridEntity | undefined;
+export declare function spawnGridEntityWithVariant(gridEntityType: GridEntityType, variant: int, gridIndexOrPosition: int | Vector, shouldRemoveExistingGridEntity?: boolean): GridEntity | undefined;
 
 /** Helper function to spawn a `EntityType.PICKUP` (5) with variant `PickupVariant.HEART` (10). */
 export declare function spawnHeart(heartSubType: HeartSubType, positionOrGridIndex: Vector | int, velocity?: Vector, spawner?: Entity, seedOrRNG?: Seed | RNG): EntityPickupHeart;
@@ -19032,8 +19043,8 @@ export declare const TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE = 10000;
  * Lazarus.
  */
 declare class TaintedLazarusPlayers extends Feature {
-    vConditionalFunc: () => boolean;
     private readonly postPlayerInit;
+    vConditionalFunc: () => boolean;
     /**
      * Indexes are the `PtrHash`, values are the `EntityPtr` of the *other* Lazarus.
      *
@@ -19165,10 +19176,10 @@ export declare function trinketHasCacheFlag(trinketType: TrinketType, cacheFlag:
 
 /** This is used by the `temporarilyRemoveTrinkets` and related helper functions. */
 export declare interface TrinketSituation {
-    trinketTypeRemoved: TrinketType;
-    trinketType1: TrinketType;
-    trinketType2: TrinketType;
-    numSmeltedTrinkets: int;
+    readonly trinketTypeRemoved: TrinketType;
+    readonly trinketType1: TrinketType;
+    readonly trinketType2: TrinketType;
+    readonly numSmeltedTrinkets: int;
 }
 
 /**
@@ -19186,11 +19197,11 @@ export declare type TSTLClass = LuaMap<AnyNotNil, unknown> & {
  * (TypeScriptToLua transpiles TypeScript classes to a Lua table with a specific kind of metatable.)
  */
 export declare interface TSTLClassMetatable {
-    ____constructor: () => void;
-    __index: unknown;
-    constructor: {
-        name: string;
-        prototype: LuaMetatable<LuaMap<AnyNotNil, unknown>>;
+    readonly ____constructor: () => void;
+    readonly __index: unknown;
+    readonly constructor: {
+        readonly name: string;
+        readonly prototype: Readonly<LuaMetatable<LuaMap<AnyNotNil, unknown>>>;
     };
 }