isaacscript-common 81.0.4 → 82.0.0

package/dist/index.rollup.d.ts

@@ -797,7 +797,7 @@ export declare function addCharge(player: EntityPlayer, activeSlot?: ActiveSlot,
  * This function is variadic, meaning that you can supply as many collectible types as you want to
  * add.
  */
-export declare function addCollectible(player: EntityPlayer, ...collectibleTypes: CollectibleType[]): void;
+export declare function addCollectible(player: EntityPlayer, ...collectibleTypes: readonly CollectibleType[]): void;
 
 export declare function addCollectibleCostume(player: EntityPlayer, collectibleType: CollectibleType): void;
 
@@ -826,7 +826,7 @@ export declare function addCollectibleCostume(player: EntityPlayer, collectibleT
  * @param flagsToAdd One or more bit flags to add, each as a separate argument.
  * @returns The combined bit flags.
  */
-export declare function addFlag<T extends BitFlag | BitFlag128>(flags: T | BitFlags<T>, ...flagsToAdd: T[]): BitFlags<T>;
+export declare function addFlag<T extends BitFlag | BitFlag128>(flags: T | BitFlags<T>, ...flagsToAdd: readonly T[]): BitFlags<T>;
 
 export declare function addPlayerHealthType(player: EntityPlayer, healthType: HealthType, numHearts: int): void;
 
@@ -981,7 +981,7 @@ export declare function angleToDirection(angleDegrees: int): Direction;
 export declare type AnyClass = new () => object;
 
 /** Alias for the `anySeedEffectEnabled` function. */
-export declare function anyEasterEggEnabled(exceptions?: SeedEffect[]): boolean;
+export declare function anyEasterEggEnabled(exceptions?: readonly SeedEffect[]): boolean;
 
 /**
  * A type union that matches `Entity`, `EntityBomb`, `EntityEffect`, and so on.
@@ -996,7 +996,7 @@ export declare function anyEntityCloserThan(entities: readonly Entity[], positio
  * Helper type to represent any function. This is safer than using the built-in `Function` type, as
  * it does not completely turn off all type safety.
  */
-export declare type AnyFunction = (...args: unknown[]) => unknown;
+export declare type AnyFunction = (...args: readonly unknown[]) => unknown;
 
 /**
  * A type union that matches `GridEntity`, `GridEntityDoor`, `GridEntityPit`, and so on.
@@ -1053,14 +1053,14 @@ export declare function anyPlayerHoldingItem(): boolean;
  * This function is variadic, meaning that you can supply as many characters as you want to check
  * for. Returns true if any of the characters supplied are present.
  */
-export declare function anyPlayerIs(...matchingCharacters: PlayerType[]): boolean;
+export declare function anyPlayerIs(...matchingCharacters: readonly PlayerType[]): boolean;
 
 /**
  * Helper function to see if any seed effects (i.e. Easter Eggs) are enabled for the current run.
  *
  * @param exceptions Optional. An array of seed effects to ignore.
  */
-export declare function anySeedEffectEnabled(exceptions?: SeedEffect[]): boolean;
+export declare function anySeedEffectEnabled(exceptions?: readonly SeedEffect[]): boolean;
 
 declare type Arr<N extends number, T extends unknown[] = []> = T["length"] extends N ? T : Arr<N, [...T, unknown]>;
 
@@ -1129,7 +1129,7 @@ export declare function arrayRemoveIndex<T>(originalArray: readonly T[], ...inde
  *
  * @returns The removed elements. This will be an empty array if no elements were removed.
  */
-export declare function arrayRemoveIndexInPlace<T>(array: T[], ...indexesToRemove: int[]): T[];
+export declare function arrayRemoveIndexInPlace<T>(array: T[], ...indexesToRemove: readonly int[]): T[];
 
 /**
  * Removes the specified element(s) from the array. If the specified element(s) are not found in the
@@ -1148,7 +1148,7 @@ export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: r
 /** Helper function to convert a set of flags to a single `BitFlags` object. */
 export declare function arrayToBitFlags<T extends BitFlag | BitFlag128>(array: readonly T[]): BitFlags<T>;
 
-export declare function arrayToString(array: unknown[]): string;
+export declare function arrayToString(array: readonly unknown[]): string;
 
 /**
  * Helper function to safely cast an `int` to a `CardType`. (This is better than using the `as`
@@ -1293,7 +1293,7 @@ export declare const AZAZEL_DEFAULT_BRIMSTONE_DISTANCE = 75.125;
  * @returns An array containing the average time in milliseconds for each function. (This will also
  *          be printed to the log.)
  */
-export declare function benchmark(numTrials: int, ...functions: Array<() => void>): readonly int[];
+export declare function benchmark(numTrials: int, ...functions: ReadonlyArray<() => void>): readonly int[];
 
 /**
  * Helper function for casting a flag enum value to a `BitFlags` object.
@@ -1763,7 +1763,7 @@ export declare function controllerToString(controller: Controller): string | und
 export declare type ConversionHeartSubType = HeartSubType.SOUL | HeartSubType.BLACK;
 
 /** Helper function to convert an array of bits to the resulting decimal number. */
-export declare function convertBinaryToDecimal(bits: int[]): number;
+export declare function convertBinaryToDecimal(bits: readonly int[]): number;
 
 /**
  * Helper function to convert a number to an array of bits.
@@ -2144,7 +2144,7 @@ declare class CustomItemPools extends Feature {
      *                     of the collectible.
      * @public
      */
-    registerCustomItemPool(itemPoolTypeCustom: ItemPoolType, collectibles: WeightedArray<CollectibleType>): void;
+    registerCustomItemPool(itemPoolTypeCustom: ItemPoolType, collectibles: Readonly<WeightedArray<CollectibleType>>): void;
     /**
      * Helper function to get a new collectible from a custom item pool created with the
      * `registerCustomItemPool` function. This function has the same format as the
@@ -3868,7 +3868,7 @@ declare class DisableInputs extends Feature {
      * @param buttonActions An array of the actions to action.
      * @public
      */
-    disableInputs(key: string, ...buttonActions: ButtonAction[]): void;
+    disableInputs(key: string, ...buttonActions: readonly ButtonAction[]): void;
     /**
      * Helper function to disable all inputs. This is useful because `EntityPlayer.ControlsEnabled`
      * can be changed by the game under certain conditions.
@@ -4396,9 +4396,9 @@ declare class EsauJrDetection extends Feature {
  * Helper function for non-TypeScript users to check if every element in the array is equal to a
  * condition.
  *
- * Internally, this just calls `array.every`.
+ * Internally, this just calls `Array.every`.
  */
-export declare function every<T>(array: T[], func: (value: T, index: number, array: T[]) => boolean): boolean;
+export declare function every<T>(array: readonly T[], func: (value: T, index: number, array: readonly T[]) => boolean): boolean;
 
 /**
  * When you enable this feature, many custom commands will be added to the in-game console. See the
@@ -4552,9 +4552,9 @@ export declare function fillLevelWithRedRooms(): void;
  * Helper function for non-TypeScript users to filter the elements in an array. Returns the filtered
  * array.
  *
- * Internally, this just calls `array.filter`.
+ * Internally, this just calls `Array.filter`.
  */
-export declare function filter<T>(array: T[], func: (value: T, index: number, array: T[]) => boolean): readonly T[];
+export declare function filter<T>(array: readonly T[], func: (value: T, index: number, array: readonly T[]) => boolean): readonly T[];
 
 /**
  * Helper function to perform a map and a filter at the same time. Similar to `Array.map`, provide a
@@ -4572,9 +4572,9 @@ export declare function filterMap<OldT, NewT>(array: readonly OldT[], func: (ele
 /**
  * Helper function for non-TypeScript users to find an element in an array.
  *
- * Internally, this just calls `array.find`.
+ * Internally, this just calls `Array.find`.
  */
-export declare function find<T>(array: T[], func: (value: T, index: number, array: T[]) => boolean): T | undefined;
+export declare function find<T>(array: readonly T[], func: (value: T, index: number, array: readonly T[]) => boolean): T | undefined;
 
 /**
  * Helper function to get a room position that is not overlapping with a grid entity, a heaven door,
@@ -4705,9 +4705,9 @@ export declare const fonts: {
 /**
  * Helper function for non-TypeScript users to iterate over an array.
  *
- * Internally, this just calls `array.forEach`.
+ * Internally, this just calls `Array.forEach`.
  */
-export declare function forEach<T>(array: T[], func: (value: T, index: number, array: T[]) => void): void;
+export declare function forEach<T>(array: readonly T[], func: (value: T, index: number, array: readonly T[]) => void): void;
 
 declare class ForgottenSwitch extends Feature {
     private readonly pressInput;
@@ -5092,7 +5092,7 @@ export declare function getBombs(bombVariant?: BombVariant | -1, subType?: numbe
  *
  * This function is variadic, meaning that you can specify N arguments to get N values.
  */
-export declare function getBooleansFromTable(luaMap: LuaMap<string, unknown>, objectName: string, ...keys: string[]): readonly boolean[];
+export declare function getBooleansFromTable(luaMap: LuaMap<string, unknown>, objectName: string, ...keys: readonly string[]): readonly boolean[];
 
 /**
  * Helper function to get all of the bosses in the room.
@@ -5154,7 +5154,10 @@ export declare function getBossRushDoor(): GridEntityDoor | undefined;
  *
  * Also see the `getAllBossesSet` and `getCombinedBossSet` functions.
  */
-export declare function getBossSet(stage: LevelStage, stageType: StageType): ReadonlySet<BossID> | undefined;
+export declare function getBossSet(stageID: StageID): ReadonlySet<BossID> | undefined;
+
+/** Helper function to get the set of stage IDs that a particular boss naturally appears in. */
+export declare function getBossStageIDs(bossID: BossID): ReadonlySet<StageID>;
 
 /**
  * Helper function to get a card description from a `CardType` value. Returns "Unknown" if the
@@ -5374,7 +5377,7 @@ export declare function getClosestPlayer(position: Vector): EntityPlayer;
  * @param referenceVector The vector to compare against.
  * @param vectors The array of vectors to look through.
  */
-export declare function getClosestVectorTo(referenceVector: Vector, vectors: Vector[]): Vector | undefined;
+export declare function getClosestVectorTo(referenceVector: Vector, vectors: readonly Vector[]): Vector | undefined;
 
 /**
  * Helper function to get the name of a coin, as listed in the "entities2.xml" file. Returns
@@ -5619,7 +5622,7 @@ export declare function getDoorEnterPosition(door: GridEntityDoor): Readonly<Vec
  *
  * @allowEmptyVariadic
  */
-export declare function getDoors(...roomTypes: RoomType[]): readonly GridEntityDoor[];
+export declare function getDoors(...roomTypes: readonly RoomType[]): readonly GridEntityDoor[];
 
 /**
  * Helper function to get the position that a player will enter a room at corresponding to a door
@@ -5649,7 +5652,7 @@ export declare function getDoorSlotsForRoomShape(roomShape: RoomShape): Readonly
  * This function is variadic, meaning that you can specify N arguments to return all of the doors
  * that match any of the N room grid indexes.
  */
-export declare function getDoorsToRoomIndex(...roomGridIndex: int[]): readonly GridEntityDoor[];
+export declare function getDoorsToRoomIndex(...roomGridIndex: readonly int[]): readonly GridEntityDoor[];
 
 /**
  * Helper function to account for Repentance floors being offset by 1. For example, Downpour 2 is
@@ -5922,7 +5925,7 @@ export declare function getFirstPill(player: EntityPlayer): PocketItemDescriptio
  * use the reverse mapping to find the associated key of a given enum value. Use this helper
  * function instead of indexing the enum directly.)
  */
-export declare function getFlagName<T extends BitFlag | BitFlag128>(flag: BitFlag, flagEnum: Record<string, T>): string | undefined;
+export declare function getFlagName<T extends BitFlag | BitFlag128>(flag: BitFlag, flagEnum: ReadonlyRecord<string, T>): string | undefined;
 
 /**
  * Helper function to get the minimap `DisplayFlag` value for every room on the floor. Returns a map
@@ -5983,7 +5986,7 @@ export declare function getGotoCommand(roomType: RoomType, roomVariant: int, use
  *
  * @allowEmptyVariadic
  */
-export declare function getGridEntities(...gridEntityTypes: GridEntityType[]): readonly GridEntity[];
+export declare function getGridEntities(...gridEntityTypes: readonly GridEntityType[]): readonly GridEntity[];
 
 /**
  * Helper function to get every grid entity in the current room except for certain specific types.
@@ -5991,7 +5994,7 @@ export declare function getGridEntities(...gridEntityTypes: GridEntityType[]): r
  * This function is variadic, meaning that you can specify as many grid entity types as you want to
  * exclude.
  */
-export declare function getGridEntitiesExcept(...gridEntityTypes: GridEntityType[]): readonly GridEntity[];
+export declare function getGridEntitiesExcept(...gridEntityTypes: readonly GridEntityType[]): readonly GridEntity[];
 
 /** Helper function to get all grid entities in a given radius around a given point. */
 export declare function getGridEntitiesInRadius(targetPosition: Vector, radius: number): readonly GridEntity[];
@@ -6005,7 +6008,7 @@ export declare function getGridEntitiesInRadius(targetPosition: Vector, radius:
  *
  * @allowEmptyVariadic
  */
-export declare function getGridEntitiesMap(...gridEntityTypes: GridEntityType[]): ReadonlyMap<int, GridEntity>;
+export declare function getGridEntitiesMap(...gridEntityTypes: readonly GridEntityType[]): ReadonlyMap<int, GridEntity>;
 
 /** Helper function to get the ANM2 path for a grid entity type. */
 export declare function getGridEntityANM2Path(gridEntityType: GridEntityType): string | undefined;
@@ -6077,7 +6080,7 @@ export declare function getHeartsUIWidth(): int;
  * Helper function to get the highest value in an array. Returns undefined if there were no elements
  * in the array.
  */
-export declare function getHighestArrayElement(array: number[]): number | undefined;
+export declare function getHighestArrayElement(array: readonly number[]): number | undefined;
 
 /**
  * Helper function to get the enum value with the highest value.
@@ -6276,7 +6279,7 @@ export declare function getLevelName(stage?: LevelStage, stageType?: StageType):
  * Helper function to get the lowest value in an array. Returns undefined if there were no elements
  * in the array.
  */
-export declare function getLowestArrayElement(array: number[]): number | undefined;
+export declare function getLowestArrayElement(array: readonly number[]): number | undefined;
 
 /**
  * Helper function to get the enum value with the lowest value.
@@ -6499,7 +6502,7 @@ export declare function getNPCs(entityType?: EntityType | -1, variant?: number,
  *
  * This function is variadic, meaning that you can specify N arguments to get N values.
  */
-export declare function getNumbersFromTable(luaMap: LuaMap<string, unknown>, objectName: string, ...keys: string[]): readonly number[];
+export declare function getNumbersFromTable(luaMap: LuaMap<string, unknown>, objectName: string, ...keys: readonly string[]): readonly number[];
 
 /** Helper function to get the number of bits in a binary representation of a number. */
 export declare function getNumBitsOfN(n: int): int;
@@ -6533,7 +6536,7 @@ export declare function getNumRooms(): int;
  * @returns If a match was found, returns a tuple of the map key and value. If a match was not
  *          found, returns undefined.
  */
-export declare function getObjectPartialMatch<T>(searchText: string, object: Record<string, T>): [string, T] | undefined;
+export declare function getObjectPartialMatch<T>(searchText: string, object: ReadonlyRecord<string, T>): [string, T] | undefined;
 
 /**
  * Returns the slot number corresponding to where a trinket can be safely inserted.
@@ -6712,7 +6715,7 @@ export declare function getPlayerCloserThan(position: Vector, distance: float):
  *
  * Note that this will filter out non-real collectibles like Lilith's Incubus.
  */
-export declare function getPlayerCollectibleCount(player: EntityPlayer, ...collectibleTypes: CollectibleType[]): int;
+export declare function getPlayerCollectibleCount(player: EntityPlayer, ...collectibleTypes: readonly CollectibleType[]): int;
 
 /** Helper function to get only the familiars that belong to a specific player. */
 export declare function getPlayerFamiliars(player: EntityPlayer): readonly EntityFamiliar[];
@@ -6849,7 +6852,7 @@ export declare function getPlayers(performCharacterExclusions?: boolean): readon
  * This function is variadic, meaning that you can supply as many characters as you want to check
  * for. Returns true if any of the characters supplied are present.
  */
-export declare function getPlayersOfType(...characters: PlayerType[]): readonly EntityPlayer[];
+export declare function getPlayersOfType(...characters: readonly PlayerType[]): readonly EntityPlayer[];
 
 /**
  * Helper function to get all of the players that are using keyboard (i.e.
@@ -6883,7 +6886,7 @@ export declare function getPlayerStats(player: EntityPlayer): PlayerStats;
  * This function is variadic, meaning that you can supply as many collectible types as you want to
  * check for. It only returns the players that have all of the collectibles.
  */
-export declare function getPlayersWithCollectible(...collectibleTypes: CollectibleType[]): readonly EntityPlayer[];
+export declare function getPlayersWithCollectible(...collectibleTypes: readonly CollectibleType[]): readonly EntityPlayer[];
 
 /**
  * Helper function to get all of the players that match the provided controller index. This function
@@ -6901,7 +6904,7 @@ export declare function getPlayersWithControllerIndex(controllerIndex: Controlle
  * This function is variadic, meaning that you can supply as many trinket types as you want to check
  * for. It only returns the players that have all of the trinkets.
  */
-export declare function getPlayersWithTrinket(...trinketTypes: TrinketType[]): readonly EntityPlayer[];
+export declare function getPlayersWithTrinket(...trinketTypes: readonly TrinketType[]): readonly EntityPlayer[];
 
 /** Returns a set of the player's current transformations. */
 export declare function getPlayerTransformations(player: EntityPlayer): ReadonlySet<PlayerForm>;
@@ -7075,7 +7078,7 @@ export declare function getRandomFloat(min: int, max: int, seedOrRNG: Seed | RNG
  *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
  *                  a random seed.
  */
-export declare function getRandomFromWeightedArray<T>(weightedArray: WeightedArray<T>, seedOrRNG: Seed | RNG | undefined): T;
+export declare function getRandomFromWeightedArray<T>(weightedArray: Readonly<WeightedArray<T>>, seedOrRNG: Seed | RNG | undefined): T;
 
 /**
  * Get a random index from a `WeightedArray`. (A `WeightedArray` is an array of tuples, where the
@@ -7090,7 +7093,7 @@ export declare function getRandomFromWeightedArray<T>(weightedArray: WeightedArr
  *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
  *                  a random seed.
  */
-export declare function getRandomIndexFromWeightedArray<T>(weightedArray: WeightedArray<T>, seedOrRNG: Seed | RNG | undefined): int;
+export declare function getRandomIndexFromWeightedArray<T>(weightedArray: Readonly<WeightedArray<T>>, seedOrRNG: Seed | RNG | undefined): int;
 
 /**
  * Returns a random integer between min and max. It is inclusive on both ends.
@@ -7150,7 +7153,7 @@ export declare function getRandomItemPool(seedOrRNG: Seed | RNG | undefined): It
  * @param verbose Optional. If specified, will write entries to the "log.txt" file that describe
  *                what the function is doing. Default is false.
  */
-export declare function getRandomJSONEntity(jsonEntities: JSONEntity[], seedOrRNG: Seed | RNG | undefined, verbose?: boolean): JSONEntity;
+export declare function getRandomJSONEntity(jsonEntities: readonly JSONEntity[], seedOrRNG: Seed | RNG | undefined, verbose?: boolean): JSONEntity;
 
 /**
  * Helper function to get a random JSON room from an array of JSON rooms.
@@ -7388,7 +7391,7 @@ export declare function getRoomDescriptorReadOnly(): Readonly<RoomDescriptor>;
  * This function is variadic, meaning that you can specify N arguments to get the combined room
  * descriptors for N room types.
  */
-export declare function getRoomDescriptorsForType(...roomTypes: RoomType[]): readonly RoomDescriptor[];
+export declare function getRoomDescriptorsForType(...roomTypes: readonly RoomType[]): readonly RoomDescriptor[];
 
 /**
  * Helper function to get a particular room's minimap display flags (e.g. whether it is visible and
@@ -7431,7 +7434,7 @@ export declare function getRoomGridIndex(): int;
  * This function is variadic, meaning that you can specify N arguments to get the combined grid
  * indexes for N room types.
  */
-export declare function getRoomGridIndexesForType(...roomTypes: RoomType[]): readonly int[];
+export declare function getRoomGridIndexesForType(...roomTypes: readonly RoomType[]): readonly int[];
 
 /**
  * Helper function to get the item pool type for the current room. For example, this returns
@@ -7917,7 +7920,7 @@ export declare function getStartSeedString(): string;
  *
  * This function is variadic, meaning that you can specify N arguments to get N values.
  */
-export declare function getStringsFromTable(luaMap: LuaMap<string, unknown>, objectName: string, ...keys: string[]): readonly string[];
+export declare function getStringsFromTable(luaMap: LuaMap<string, unknown>, objectName: string, ...keys: readonly string[]): readonly string[];
 
 /**
  * Helper function to get a parent `EntityPlayer` object for a given `EntitySubPlayer` object. This
@@ -8333,7 +8336,7 @@ export declare function hasArmor(entity: Entity): boolean;
  * This function is variadic, meaning that you can pass as many cards as you want to check for. The
  * function will return true if the player has any of the cards.
  */
-export declare function hasCard(player: EntityPlayer, ...cardTypes: CardType[]): boolean;
+export declare function hasCard(player: EntityPlayer, ...cardTypes: readonly CardType[]): boolean;
 
 /**
  * Helper function to check to see if a player has one or more collectibles.
@@ -8343,7 +8346,7 @@ export declare function hasCard(player: EntityPlayer, ...cardTypes: CardType[]):
  *
  * This function always passes `false` to the `ignoreModifiers` argument.
  */
-export declare function hasCollectible(player: EntityPlayer, ...collectibleTypes: CollectibleType[]): boolean;
+export declare function hasCollectible(player: EntityPlayer, ...collectibleTypes: readonly CollectibleType[]): boolean;
 
 /**
  * Helper function to check to see if a player has a specific collectible in one or more active
@@ -8353,7 +8356,7 @@ export declare function hasCollectible(player: EntityPlayer, ...collectibleTypes
  * for. This function will return true if the collectible type is located in any of the active slots
  * provided.
  */
-export declare function hasCollectibleInActiveSlot(player: EntityPlayer, collectibleType: CollectibleType, ...activeSlots: ActiveSlot[]): boolean;
+export declare function hasCollectibleInActiveSlot(player: EntityPlayer, collectibleType: CollectibleType, ...activeSlots: readonly ActiveSlot[]): boolean;
 
 /**
  * Helper function to check if the current floor has a particular curse.
@@ -8363,7 +8366,7 @@ export declare function hasCollectibleInActiveSlot(player: EntityPlayer, collect
  *
  * Under the hood, this function uses the `Level.GetCurses` method.
  */
-export declare function hasCurse(...curses: LevelCurse[]): boolean;
+export declare function hasCurse(...curses: readonly LevelCurse[]): boolean;
 
 /**
  * Helper function to check if the current room has one or more doors that lead to the given room
@@ -8372,7 +8375,7 @@ export declare function hasCurse(...curses: LevelCurse[]): boolean;
  * This function is variadic, meaning that you can supply as many door types as you want to check
  * for. This function will return true if one or more room types match.
  */
-export declare function hasDoorType(...roomTypes: RoomType[]): boolean;
+export declare function hasDoorType(...roomTypes: readonly RoomType[]): boolean;
 
 /**
  * Helper function to determine if a particular bit flag is set to true.
@@ -8392,7 +8395,7 @@ export declare function hasDoorType(...roomTypes: RoomType[]): boolean;
  * @param flags The existing set of bit flags.
  * @param flagsToCheck One or more bit flags to check for, each as a separate argument.
  */
-export declare function hasFlag<T extends BitFlag | BitFlag128>(flags: T | BitFlags<T>, ...flagsToCheck: T[]): boolean;
+export declare function hasFlag<T extends BitFlag | BitFlag128>(flags: T | BitFlags<T>, ...flagsToCheck: readonly T[]): boolean;
 
 export declare function hasFlyingTransformation(player: EntityPlayer): boolean;
 
@@ -8402,7 +8405,7 @@ export declare function hasFlyingTransformation(player: EntityPlayer): boolean;
  * This function is variadic, meaning that you can supply as many transformations as you want to
  * check for. Returns true if the player has any of the supplied transformations.
  */
-export declare function hasForm(player: EntityPlayer, ...playerForms: PlayerForm[]): boolean;
+export declare function hasForm(player: EntityPlayer, ...playerForms: readonly PlayerForm[]): boolean;
 
 /** Helper type to check if an object or class has one or more functions/methods. */
 export declare type HasFunction<T> = Record<string, unknown> extends {
@@ -8471,7 +8474,7 @@ export declare function hasSpectral(player: EntityPlayer): boolean;
  *
  * This function always passes `false` to the `ignoreModifiers` argument.
  */
-export declare function hasTrinket(player: EntityPlayer, ...trinketTypes: TrinketType[]): boolean;
+export declare function hasTrinket(player: EntityPlayer, ...trinketTypes: readonly TrinketType[]): boolean;
 
 /**
  * Helper function to check if the current room has one or more open door slots that can be used to
@@ -8755,14 +8758,14 @@ export declare function inRedKeyRoom(): boolean;
  *
  * This function is variadic, which means you can pass as many room shapes as you want to match for.
  */
-export declare function inRoomShape(...roomShapes: RoomShape[]): boolean;
+export declare function inRoomShape(...roomShapes: readonly RoomShape[]): boolean;
 
 /**
  * Helper function to check if the current room matches one of the given room types.
  *
  * This function is variadic, which means you can pass as many room types as you want to match for.
  */
-export declare function inRoomType(...roomTypes: RoomType[]): boolean;
+export declare function inRoomType(...roomTypes: readonly RoomType[]): boolean;
 
 /**
  * Helper function for checking if the current room is a secret exit that leads to a Repentance
@@ -8859,7 +8862,7 @@ declare interface IsaacAPIClassTypeToType {
  * This is a variadic version of `Input.IsActionPressed`, meaning that you can pass as many buttons
  * as you want to check for. This function will return true if any of the buttons are pressed.
  */
-export declare function isActionPressed(controllerIndex: ControllerIndex, ...buttonActions: ButtonAction[]): boolean;
+export declare function isActionPressed(controllerIndex: ControllerIndex, ...buttonActions: readonly ButtonAction[]): boolean;
 
 /**
  * Helper function to iterate over all inputs to determine if a specific button is pressed (i.e.
@@ -8868,7 +8871,7 @@ export declare function isActionPressed(controllerIndex: ControllerIndex, ...but
  * This function is variadic, meaning you can pass as many buttons as you want to check for. This
  * function will return true if any of the buttons are pressed.
  */
-export declare function isActionPressedOnAnyInput(...buttonActions: ButtonAction[]): boolean;
+export declare function isActionPressedOnAnyInput(...buttonActions: readonly ButtonAction[]): boolean;
 
 /**
  * Helper function to check if a player is triggering a specific button (i.e. pressing and releasing
@@ -8878,7 +8881,7 @@ export declare function isActionPressedOnAnyInput(...buttonActions: ButtonAction
  * buttons as you want to check for. This function will return true if any of the buttons are
  * triggered.
  */
-export declare function isActionTriggered(controllerIndex: ControllerIndex, ...buttonActions: ButtonAction[]): boolean;
+export declare function isActionTriggered(controllerIndex: ControllerIndex, ...buttonActions: readonly ButtonAction[]): boolean;
 
 /**
  * Iterates over all inputs to determine if a specific button is triggered (i.e. held down and then
@@ -8887,7 +8890,7 @@ export declare function isActionTriggered(controllerIndex: ControllerIndex, ...b
  * This function is variadic, meaning you can pass as many buttons as you want to check for. This
  * function will return true if any of the buttons are pressed.
  */
-export declare function isActionTriggeredOnAnyInput(...buttonActions: ButtonAction[]): boolean;
+export declare function isActionTriggeredOnAnyInput(...buttonActions: readonly ButtonAction[]): boolean;
 
 /** Returns true if the item type in the item config is equal to `ItemType.ACTIVE`. */
 export declare function isActiveCollectible(collectibleType: CollectibleType): boolean;
@@ -8997,7 +9000,7 @@ export declare function isArray(object: unknown, ensureContiguousValues?: boolea
  *
  * For example, `[2, 3, 4]` would return true, and `[2, 3, 5]` would return false.
  */
-export declare function isArrayContiguous(array: int[]): boolean;
+export declare function isArrayContiguous(array: readonly int[]): boolean;
 
 /** Checks if an array is in the provided 2-dimensional array. */
 export declare function isArrayInArray<T>(arrayToMatch: readonly T[], parentArray: ReadonlyArray<readonly T[]>): boolean;
@@ -9248,7 +9251,7 @@ declare type ISCFeatureTupleToClassTuple<T extends ISCFeature[]> = {
  * This function is variadic, meaning that you can supply as many characters as you want to check
  * for. Returns true if the player is any of the supplied characters.
  */
-export declare function isCharacter(player: EntityPlayer, ...characters: PlayerType[]): boolean;
+export declare function isCharacter(player: EntityPlayer, ...characters: readonly PlayerType[]): boolean;
 
 /** Helper function to test if the provided pickup matches one of the various chest variants. */
 export declare function isChest(pickup: EntityPickup): boolean;
@@ -9646,7 +9649,7 @@ export declare function isKey(pickup: EntityPickup): pickup is EntityPickupKey;
  * This function is variadic, meaning you can pass as many keyboard values as you want to check for.
  * This function will return true if any of the values are pressed.
  */
-export declare function isKeyboardPressed(...keys: Keyboard[]): boolean;
+export declare function isKeyboardPressed(...keys: readonly Keyboard[]): boolean;
 
 /** Helper function to detect if a variable is of type `EntityKnife`. */
 export declare function isKnife(variable: unknown): variable is EntityKnife;
@@ -9949,7 +9952,7 @@ export declare function isRoomInsideGrid(roomGridIndex?: int): boolean;
  *
  * This function is variadic, which means you can pass as many room shapes as you want to match for.
  */
-export declare function isRoomShape(roomData: RoomConfig, ...roomShapes: RoomShape[]): boolean;
+export declare function isRoomShape(roomData: RoomConfig, ...roomShapes: readonly RoomShape[]): boolean;
 
 /**
  * Helper function to see if a given room shape will grant a single charge or a double charge to the
@@ -9964,7 +9967,7 @@ export declare function isRoomShapeDoubleCharge(roomShape: RoomShape): boolean;
  *
  * This function is variadic, which means you can pass as many room types as you want to match for.
  */
-export declare function isRoomType(roomData: RoomConfig, ...roomTypes: RoomType[]): boolean;
+export declare function isRoomType(roomData: RoomConfig, ...roomTypes: readonly RoomType[]): boolean;
 
 /**
  * Helper function to check if a given room is visible on the minimap.
@@ -10393,9 +10396,9 @@ export declare function iterateTableInOrder<K extends AnyNotNil, V>(luaMap: LuaM
  * Helper function for non-TypeScript users to convert an array to a string with the specified
  * separator.
  *
- * Internally, this just calls `array.join`.
+ * Internally, this just calls `Array.join`.
  */
-export declare function join<T>(array: T[], separator: string): string;
+export declare function join<T>(array: readonly T[], separator: string): string;
 
 /**
  * Converts a JSON string to a Lua table.
@@ -10637,7 +10640,7 @@ export declare const LEVEL_GRID_ROW_WIDTH = 13;
  * This function is variadic, meaning that you can pass as many boss IDs as you want to check for.
  * It will return true if one or more of the boss IDs are matched.
  */
-export declare function levelHasBossID(...bossIDs: BossID[]): boolean;
+export declare function levelHasBossID(...bossIDs: readonly BossID[]): boolean;
 
 /**
  * Helper function to check to see if the current floor has one or more of a specific room type in
@@ -10646,7 +10649,7 @@ export declare function levelHasBossID(...bossIDs: BossID[]): boolean;
  * This function is variadic, meaning that you can pass as many room types as you want to check for.
  * This function will return true if any of the room types are found.
  */
-export declare function levelHasRoomType(...roomTypes: RoomType[]): boolean;
+export declare function levelHasRoomType(...roomTypes: readonly RoomType[]): boolean;
 
 /**
  * Helper function to reset an unlocked door back to a locked state. Doing this is non-trivial
@@ -10726,7 +10729,7 @@ export declare function logDamageFlags(this: void, damageFlags: DamageFlag | Bit
 export declare function logDisplayFlags(this: void, displayFlags: DisplayFlag | BitFlags<DisplayFlag>): void;
 
 /** Helper function for logging an array of specific entities. */
-export declare function logEntities(this: void, entities: Entity[]): void;
+export declare function logEntities(this: void, entities: readonly Entity[]): void;
 
 /** Helper function to log information about a specific entity. */
 export declare function logEntity(this: void, entity: Entity): void;
@@ -10745,13 +10748,13 @@ export declare function logEntityID(this: void, entity: Entity): void;
 export declare function logError(this: void, msg: string): void;
 
 /** Helper function for logging every flag that is turned on. Useful when debugging. */
-export declare function logFlags<T extends BitFlag | BitFlag128>(this: void, flags: T | BitFlags<T>, flagEnum: Record<string, T>, description?: string): void;
+export declare function logFlags<T extends BitFlag | BitFlag128>(this: void, flags: T | BitFlags<T>, flagEnum: ReadonlyRecord<string, T>, description?: string): void;
 
 /** Helper function for logging every game state flag that is turned on. Useful when debugging. */
 export declare function logGameStateFlags(this: void): void;
 
 /** Helper function for logging an array of specific grid entities. */
-export declare function logGridEntities(this: void, gridEntities: GridEntity[]): void;
+export declare function logGridEntities(this: void, gridEntities: readonly GridEntity[]): void;
 
 /** Helper function for log information about a specific grid entity. */
 export declare function logGridEntity(this: void, gridEntity: GridEntity): void;
@@ -10805,7 +10808,7 @@ export declare function logPtrHash(this: void, ptrHash: PtrHash): void;
  * Helper function to log information about the entity that corresponding to one or more pointer
  * hashes. (Only use this when debugging, since retrieving the corresponding entity is expensive.)
  */
-export declare function logPtrHashes(this: void, ptrHashes: PtrHash[]): void;
+export declare function logPtrHashes(this: void, ptrHashes: readonly PtrHash[]): void;
 
 /** Helper function for logging information about the current room. */
 export declare function logRoom(this: void): void;
@@ -10897,9 +10900,9 @@ export declare const MAIN_CHARACTERS: readonly [PlayerType.ISAAC, PlayerType.MAG
  * Helper function for non-TypeScript users to convert all of the elements in an array to something
  * else.
  *
- * Internally, this just calls `array.map`.
+ * Internally, this just calls `Array.map`.
  */
-export declare function map<T, U>(array: T[], func: (value: T, index: number, array: T[]) => U): readonly U[];
+export declare function map<T, U>(array: readonly T[], func: (value: T, index: number, array: readonly T[]) => U): readonly U[];
 
 /**
  * Helper function to make using maps with an type of `PtrHash` easier. Use this instead of the
@@ -10933,7 +10936,7 @@ export declare function mapDeletePlayer(map: Map<PlayerIndex, unknown>, player:
  * }
  * ```
  */
-export declare function mapGetNPC<V>(map: Map<PtrHash, V>, npc: EntityNPC): V | undefined;
+export declare function mapGetNPC<V>(map: ReadonlyMap<PtrHash, V>, npc: EntityNPC): V | undefined;
 
 /**
  * Helper function to make using maps with an index of `PlayerIndex` easier. Use this instead of the
@@ -10955,19 +10958,19 @@ export declare function mapGetNPC<V>(map: Map<PtrHash, V>, npc: EntityNPC): V |
  * }
  * ```
  */
-export declare function mapGetPlayer<V>(map: Map<PlayerIndex, V>, player: EntityPlayer): V | undefined;
+export declare function mapGetPlayer<V>(map: ReadonlyMap<PlayerIndex, V>, player: EntityPlayer): V | undefined;
 
 /**
  * Helper function to make using maps with an index of `PtrHash` easier. Use this instead of the
  * `Map.has` method if you have a map of this type.
  */
-export declare function mapHasNPC<V>(map: Map<PtrHash, V>, npc: EntityNPC): boolean;
+export declare function mapHasNPC<V>(map: ReadonlyMap<PtrHash, V>, npc: EntityNPC): boolean;
 
 /**
  * Helper function to make using maps with an index of `PlayerIndex` easier. Use this instead of the
  * `Map.has` method if you have a map of this type.
  */
-export declare function mapHasPlayer<V>(map: Map<PlayerIndex, V>, player: EntityPlayer): boolean;
+export declare function mapHasPlayer<V>(map: ReadonlyMap<PlayerIndex, V>, player: EntityPlayer): boolean;
 
 /**
  * All of the collectibles that grant vision on the map.
@@ -11109,7 +11112,7 @@ export declare const MAX_TAINTED_SAMSON_BERSERK_CHARGE = 100000;
  *                          object, it will use this map to instantiate a new class. Default is an
  *                          empty Lua table.
  */
-export declare function merge(oldObject: LuaMap<AnyNotNil, unknown> | Map<AnyNotNil, unknown> | Set<AnyNotNil>, newTable: LuaMap<AnyNotNil, unknown>, traversalDescription: string, classConstructors?: LuaMap<string, AnyClass>): void;
+export declare function merge(oldObject: Readonly<LuaMap<AnyNotNil, unknown>> | ReadonlyMap<AnyNotNil, unknown> | ReadonlySet<AnyNotNil>, newTable: LuaMap<AnyNotNil, unknown>, traversalDescription: string, classConstructors?: LuaMap<string, AnyClass>): void;
 
 /** If you set `EntityPlayer.ShotSpeed` lower than this value, it will have no effect. */
 export declare const MIN_PLAYER_SHOT_SPEED_STAT = 0.6;
@@ -14428,7 +14431,7 @@ declare class ModdedElementSets extends Feature {
      *
      * @public
      */
-    getCardTypesOfType(...itemConfigCardTypes: ItemConfigCardType[]): readonly CardType[];
+    getCardTypesOfType(...itemConfigCardTypes: readonly ItemConfigCardType[]): readonly CardType[];
     /**
      * Helper function to get a random card type that matches the provided `ItemConfigCardType`.
      *
@@ -14448,7 +14451,7 @@ declare class ModdedElementSets extends Feature {
      * @param exceptions Optional. An array of cards to not select.
      * @public
      */
-    getRandomCardTypeOfType(itemConfigCardType: ItemConfigCardType, seedOrRNG: Seed | RNG | undefined, exceptions?: CardType[]): CardType;
+    getRandomCardTypeOfType(itemConfigCardType: ItemConfigCardType, seedOrRNG: Seed | RNG | undefined, exceptions?: readonly CardType[]): CardType;
     /**
      * Has an equal chance of returning any card (e.g. Fool, Reverse Fool, Wild Card, etc.).
      *
@@ -14470,7 +14473,7 @@ declare class ModdedElementSets extends Feature {
      * @param exceptions Optional. An array of cards to not select.
      * @public
      */
-    getRandomCard(seedOrRNG: Seed | RNG | undefined, exceptions?: CardType[]): CardType;
+    getRandomCard(seedOrRNG: Seed | RNG | undefined, exceptions?: readonly CardType[]): CardType;
     /**
      * Has an equal chance of returning any rune (e.g. Rune of Hagalaz, Blank Rune, Black Rune, Soul
      * of Isaac, etc.). This will never return a Rune Shard.
@@ -14489,7 +14492,7 @@ declare class ModdedElementSets extends Feature {
      * @param exceptions Optional. An array of runes to not select.
      * @public
      */
-    getRandomRune(seedOrRNG: Seed | RNG | undefined, exceptions?: CardType[]): CardType;
+    getRandomRune(seedOrRNG: Seed | RNG | undefined, exceptions?: readonly CardType[]): CardType;
 }
 
 /**
@@ -14541,7 +14544,7 @@ export declare class ModFeature {
      * ) => boolean;
      * ```
      */
-    protected shouldCallbackMethodsFire: (<T extends boolean>(vanilla: T, modCallback: T extends true ? ModCallback : ModCallbackCustom, ...callbackArgs: unknown[]) => boolean) | null;
+    protected shouldCallbackMethodsFire: (<T extends boolean>(vanilla: T, modCallback: T extends true ? ModCallback : ModCallbackCustom, ...callbackArgs: readonly unknown[]) => boolean) | null;
     /**
      * Whether the feature has registered its callbacks yet.
      *
@@ -14990,7 +14993,7 @@ export declare function onCathedral(): boolean;
  * This function is variadic, meaning that you can specify as many challenges as you want to check
  * for.
  */
-export declare function onChallenge(...challenges: Challenge[]): boolean;
+export declare function onChallenge(...challenges: readonly Challenge[]): boolean;
 
 export declare function onChest(): boolean;
 
@@ -15004,7 +15007,7 @@ export declare const ONE_BY_ONE_ROOM_GRID_SIZE = 135;
  *
  * This function is variadic, which means you can pass as many stages as you want to match for.
  */
-export declare function onEffectiveStage(...effectiveStages: LevelStage[]): boolean;
+export declare function onEffectiveStage(...effectiveStages: readonly LevelStage[]): boolean;
 
 /**
  * Returns whether the player is on the "final floor" of the particular run. The final floor is
@@ -15107,7 +15110,7 @@ export declare function onSheol(): boolean;
  *
  * This function is variadic, which means you can pass as many stages as you want to match for.
  */
-export declare function onStage(...stages: LevelStage[]): boolean;
+export declare function onStage(...stages: readonly LevelStage[]): boolean;
 
 /** Helper function to check if the current stage is equal to or higher than the given stage. */
 export declare function onStageOrHigher(stage: LevelStage): boolean;
@@ -15120,7 +15123,7 @@ export declare function onStageOrLower(stage: LevelStage): boolean;
  *
  * This function is variadic, which means you can pass as many room types as you want to match for.
  */
-export declare function onStageType(...stageTypes: StageType[]): boolean;
+export declare function onStageType(...stageTypes: readonly StageType[]): boolean;
 
 /**
  * Helper function to check if the current stage is one that has the possibility to grant a natural
@@ -15974,6 +15977,8 @@ declare interface ReadonlyMapConstructor {
     readonly prototype: ReadonlyMap<any, any>;
 }
 
+export declare type ReadonlyRecord<K extends string | number | symbol, V> = Readonly<Record<K, V>>;
+
 /** An alias for the `Set` constructor that returns a read-only set. */
 declare const ReadonlySet_2: ReadonlySetConstructor;
 export { ReadonlySet_2 as ReadonlySet }
@@ -16006,7 +16011,7 @@ declare interface ReadonlySetConstructor {
  *
  * @see https://github.com/Rchardon/RebirthItemTracker
  */
-export declare function rebirthItemTrackerRemoveCollectible(...collectibleTypes: CollectibleType[]): void;
+export declare function rebirthItemTrackerRemoveCollectible(...collectibleTypes: readonly CollectibleType[]): void;
 
 /**
  * Helper function to let the Rebirth Item Tracker know that it should write the submitted text
@@ -16132,7 +16137,7 @@ export declare function removeAllCrawlSpaces(crawlSpaceVariant?: CrawlSpaceVaria
  * @returns The number of doors removed.
  * @allowEmptyVariadic
  */
-export declare function removeAllDoors(...roomTypes: RoomType[]): int;
+export declare function removeAllDoors(...roomTypes: readonly RoomType[]): int;
 
 /**
  * Helper function to remove all of the effects in the room.
@@ -16176,7 +16181,7 @@ export declare function removeAllFamiliars(familiarVariant?: FamiliarVariant | -
  *
  * @returns The grid entities that were removed.
  */
-export declare function removeAllGridEntitiesExcept(...gridEntityTypes: GridEntityType[]): readonly GridEntity[];
+export declare function removeAllGridEntitiesExcept(...gridEntityTypes: readonly GridEntityType[]): readonly GridEntity[];
 
 /**
  * Helper function to remove all of the heart pickup entities in the room.
@@ -16253,7 +16258,7 @@ export declare function removeAllMatchingEntities(entityType: EntityType, entity
  *
  * @returns An array of the grid entities removed.
  */
-export declare function removeAllMatchingGridEntities(...gridEntityType: GridEntityType[]): readonly GridEntity[];
+export declare function removeAllMatchingGridEntities(...gridEntityType: readonly GridEntityType[]): readonly GridEntity[];
 
 /**
  * Helper function to remove all of the NPCs in the room.
@@ -16486,7 +16491,7 @@ export declare function removeCharactersBefore(string: string, substring: string
  * This function is variadic, meaning that you can supply as many collectible types as you want to
  * remove.
  */
-export declare function removeCollectible(player: EntityPlayer, ...collectibleTypes: CollectibleType[]): void;
+export declare function removeCollectible(player: EntityPlayer, ...collectibleTypes: readonly CollectibleType[]): void;
 
 /**
  * Helper function to remove a collectible costume from a player. Use this helper function to avoid
@@ -16501,14 +16506,14 @@ export declare function removeCollectibleCostume(player: EntityPlayer, collectib
  * This function is variadic, meaning that you can specify as many collectibles as you want to
  * remove.
  */
-export declare function removeCollectibleFromAllPlayers(...collectibleTypes: CollectibleType[]): void;
+export declare function removeCollectibleFromAllPlayers(...collectibleTypes: readonly CollectibleType[]): void;
 
 /**
  * Helper function to remove one or more collectibles from all item pools.
  *
  * This function is variadic, meaning you can pass as many collectible types as you want to remove.
  */
-export declare function removeCollectibleFromPools(...collectibleTypes: CollectibleType[]): void;
+export declare function removeCollectibleFromPools(...collectibleTypes: readonly CollectibleType[]): void;
 
 /**
  * Helper function to remove all pickup delay on a collectible. By default, collectibles have a 20
@@ -16532,7 +16537,7 @@ export declare function removeDoor(door: GridEntityDoor): void;
  *
  * This function is variadic, meaning that you can specify as many doors as you want to remove.
  */
-export declare function removeDoors(...doors: GridEntityDoor[]): void;
+export declare function removeDoors(...doors: readonly GridEntityDoor[]): void;
 
 /**
  * Helper function to remove all of the entities in the supplied array.
@@ -16569,7 +16574,7 @@ export declare function removeEntitiesSpawnedFromGridEntity(entities: readonly E
  * @param flagsToRemove One or more bit flags to remove, each as a separate argument.
  * @returns The combined bit flags.
  */
-export declare function removeFlag<T extends BitFlag | BitFlag128>(flags: T | BitFlags<T>, ...flagsToRemove: T[]): BitFlags<T>;
+export declare function removeFlag<T extends BitFlag | BitFlag128>(flags: T | BitFlags<T>, ...flagsToRemove: readonly T[]): BitFlags<T>;
 
 /**
  * Helper function to remove all of the grid entities in the supplied array.
@@ -16610,7 +16615,7 @@ export declare function removeNonAlphanumericCharacters(str: string): string;
  *
  * This function is variadic, meaning that you can pass as many substrings as you want to remove.
  */
-export declare function removeSubstring(string: string, ...substrings: string[]): string;
+export declare function removeSubstring(string: string, ...substrings: readonly string[]): string;
 
 /**
  * Helper function to remove a trinket costume from a player. Use this helper function to avoid
@@ -16623,7 +16628,7 @@ export declare function removeTrinketCostume(player: EntityPlayer, trinketType:
  *
  * This function is variadic, meaning you can pass as many trinket types as you want to remove.
  */
-export declare function removeTrinketFromPools(...trinketTypes: TrinketType[]): void;
+export declare function removeTrinketFromPools(...trinketTypes: readonly TrinketType[]): void;
 
 /**
  * Helper function to remove all coins, trinkets, and so on that spawned from breaking an urn.
@@ -17346,7 +17351,7 @@ declare class SaveDataManager extends Feature {
      *
      * @public
      */
-    saveDataManagerRegisterClass(...tstlClasses: AnyClass[]): void;
+    saveDataManagerRegisterClass(...tstlClasses: readonly AnyClass[]): void;
     /**
      * Removes a previously registered key from the save data manager. This is the opposite of the
      * "saveDataManager" method.
@@ -17575,13 +17580,13 @@ export declare function setAllDisplayFlags(displayFlags: BitFlags<DisplayFlag>):
  * Helper function to iterate over the provided object and set the seed for all of the values that
  * are RNG objects equal to a particular seed.
  */
-export declare function setAllRNGToSeed(object: unknown, seed: Seed): void;
+export declare function setAllRNGToSeed(object: ReadonlyRecord<string, RNG>, seed: Seed): void;
 
 /**
  * Helper function to iterate over the provided object and set the seed for all of the values that
  * are RNG objects equal to the start seed for the current run.
  */
-export declare function setAllRNGToStartSeed(object: unknown): void;
+export declare function setAllRNGToStartSeed(object: ReadonlyRecord<string, RNG>): void;
 
 /** Helper function to set the backdrop (i.e. background) of the current room. */
 export declare function setBackdrop(backdropType: BackdropType): void;
@@ -17768,13 +17773,13 @@ export declare function setHas<T>(set: ReadonlySet<T>, ...elements: readonly T[]
  * Helper function to make using sets with an type of `PtrHash` easier. Use this instead of the
  * `Set.has` method if you have a set of this type.
  */
-export declare function setHasNPC(set: Set<PtrHash>, npc: EntityNPC): boolean;
+export declare function setHasNPC(set: ReadonlySet<PtrHash>, npc: EntityNPC): boolean;
 
 /**
  * Helper function to make using sets with an type of `PlayerIndex` easier. Use this instead of the
  * `Set.has` method if you have a set of this type.
  */
-export declare function setHasPlayer(set: Set<PlayerIndex>, player: EntityPlayer): boolean;
+export declare function setHasPlayer(set: ReadonlySet<PlayerIndex>, player: EntityPlayer): boolean;
 
 /**
  * Converts every `isaacscript-common` function that begins with "log" to a global function.
@@ -18094,15 +18099,15 @@ export declare function smeltTrinket(player: EntityPlayer, trinketType: TrinketT
  * @param player The player to smelt the trinkets to.
  * @param trinketTypes The trinket types to smelt.
  */
-export declare function smeltTrinkets(player: EntityPlayer, ...trinketTypes: TrinketType[]): void;
+export declare function smeltTrinkets(player: EntityPlayer, ...trinketTypes: readonly TrinketType[]): void;
 
 /**
  * Helper function for non-TypeScript users to check if one or more elements in the array is equal
  * to a condition.
  *
- * Internally, this just calls `array.some`.
+ * Internally, this just calls `Array.some`.
  */
-export declare function some<T>(array: T[], func: (value: T, index: number, array: T[]) => boolean): boolean;
+export declare function some<T>(array: readonly T[], func: (value: T, index: number, array: readonly T[]) => boolean): boolean;
 
 /**
  * Helper function to sort an array of objects by one of the object keys.
@@ -18141,7 +18146,7 @@ export declare function sortObjectArrayByKey(key: string): (a: unknown, b: unkno
  * From:
  * https://stackoverflow.com/questions/16096872/how-to-sort-2-dimensional-array-by-column-value
  */
-export declare function sortTwoDimensionalArray<T>(a: T[], b: T[]): -1 | 0 | 1;
+export declare function sortTwoDimensionalArray<T>(a: readonly T[], b: readonly T[]): -1 | 0 | 1;
 
 export declare type SoulHeartType = HeartSubType.SOUL | HeartSubType.BLACK | HeartSubType.BONE;
 
@@ -18811,7 +18816,7 @@ declare type T_5 = ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_REMOVE;
  * This function is variadic, meaning that you can specify as many arguments as you want to check
  * for.
  */
-export declare function tableHasKeys(luaMap: LuaMap<AnyNotNil, unknown>, ...keys: string[]): boolean;
+export declare function tableHasKeys(luaMap: LuaMap<AnyNotNil, unknown>, ...keys: readonly string[]): boolean;
 
 /** After taking damage, `EntityPlayer.SamsonBerserkCharge` is incremented by this amount. */
 export declare const TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE = 10000;
@@ -18916,7 +18921,7 @@ export declare const TIME_GAME_OPENED: int;
  *
  * @allowEmptyVariadic
  */
-export declare function todo(...args: unknown[]): void;
+export declare function todo(...args: readonly unknown[]): void;
 
 /**
  * Helper function to log a stack trace to the "log.txt" file, similar to JavaScript's