isaacscript-common 81.0.0 → 81.0.2

package/dist/index.rollup.d.ts

@@ -919,7 +919,7 @@ export declare function addRoomDisplayFlag(roomGridIndex: int | undefined, displ
  *
  * This function is variadic, meaning that you can specify N sets to add to the first set.
  */
-export declare function addSetsToSet<T>(mainSet: Set<T>, ...setsToAdd: Array<Set<T> | ReadonlySet<T>>): void;
+export declare function addSetsToSet<T>(mainSet: Set<T>, ...setsToAdd: ReadonlyArray<ReadonlySet<T>>): void;
 
 /**
  * - Converts the specified amount of tears stat into the format of `EntityPlayer.MaxFireDelay` and
@@ -990,7 +990,7 @@ export declare function anyEasterEggEnabled(exceptions?: SeedEffect[]): boolean;
  */
 export declare type AnyEntity = Entity | EntityBomb | EntityEffect | EntityFamiliar | EntityKnife | EntityLaser | EntityNPC | EntityPickup | EntityPlayer | EntityProjectile | EntityTear;
 
-export declare function anyEntityCloserThan(entities: Entity[] | readonly Entity[], position: Vector, distance: int): boolean;
+export declare function anyEntityCloserThan(entities: readonly Entity[], position: Vector, distance: int): boolean;
 
 /**
  * Helper type to represent any function. This is safer than using the built-in `Function` type, as
@@ -1070,7 +1070,7 @@ declare type Arr_2<N extends number, T extends unknown[] = []> = T["length"] ext
  * Helper function for determining if two arrays contain the exact same elements. Note that this
  * only performs a shallow comparison.
  */
-export declare function arrayEquals<T>(array1: T[] | readonly T[], array2: T[] | readonly T[]): boolean;
+export declare function arrayEquals<T>(array1: readonly T[], array2: readonly T[]): boolean;
 
 /**
  * Builds a new array based on the original array without the specified element(s). Returns the new
@@ -1083,7 +1083,7 @@ export declare function arrayEquals<T>(array1: T[] | readonly T[], array2: T[] |
  * matching element. If you want to remove all of the elements, use the `arrayRemoveAll` function
  * instead.
  */
-export declare function arrayRemove<T>(originalArray: T[] | readonly T[], ...elementsToRemove: T[]): T[];
+export declare function arrayRemove<T>(originalArray: readonly T[], ...elementsToRemove: readonly T[]): T[];
 
 /**
  * Shallow copies and removes the specified element(s) from the array. Returns the copied array. If
@@ -1096,7 +1096,7 @@ export declare function arrayRemove<T>(originalArray: T[] | readonly T[], ...ele
  * element. If you want to only remove the first matching element, use the `arrayRemove` function
  * instead.
  */
-export declare function arrayRemoveAll<T>(originalArray: T[] | readonly T[], ...elementsToRemove: T[]): T[];
+export declare function arrayRemoveAll<T>(originalArray: readonly T[], ...elementsToRemove: readonly T[]): T[];
 
 /**
  * Removes all of the specified element(s) from the array. If the specified element(s) are not found
@@ -1110,7 +1110,7 @@ export declare function arrayRemoveAll<T>(originalArray: T[] | readonly T[], ...
  *
  * @returns True if one or more elements were removed, false otherwise.
  */
-export declare function arrayRemoveAllInPlace<T>(array: T[], ...elementsToRemove: T[]): boolean;
+export declare function arrayRemoveAllInPlace<T>(array: T[], ...elementsToRemove: readonly T[]): boolean;
 
 /**
  * Shallow copies and removes the elements at the specified indexes from the array. Returns the
@@ -1119,7 +1119,7 @@ export declare function arrayRemoveAllInPlace<T>(array: T[], ...elementsToRemove
  *
  * This function is variadic, meaning that you can specify N arguments to remove N elements.
  */
-export declare function arrayRemoveIndex<T>(originalArray: T[] | readonly T[], ...indexesToRemove: int[]): T[];
+export declare function arrayRemoveIndex<T>(originalArray: readonly T[], ...indexesToRemove: readonly int[]): T[];
 
 /**
  * Removes the elements at the specified indexes from the array. If the specified indexes are not
@@ -1143,10 +1143,10 @@ export declare function arrayRemoveIndexInPlace<T>(array: T[], ...indexesToRemov
  *
  * @returns The removed elements. This will be an empty array if no elements were removed.
  */
-export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: T[]): T[];
+export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: readonly T[]): T[];
 
 /** Helper function to convert a set of flags to a single `BitFlags` object. */
-export declare function arrayToBitFlags<T extends BitFlag | BitFlag128>(array: T[] | readonly T[]): BitFlags<T>;
+export declare function arrayToBitFlags<T extends BitFlag | BitFlag128>(array: readonly T[]): BitFlags<T>;
 
 export declare function arrayToString(array: unknown[]): string;
 
@@ -1467,7 +1467,7 @@ declare class CharacterStats extends Feature {
      *
      * @public
      */
-    registerCharacterStats(playerType: PlayerType, statMap: Map<CacheFlag, number> | ReadonlyMap<CacheFlag, number>): void;
+    registerCharacterStats(playerType: PlayerType, statMap: ReadonlyMap<CacheFlag, number>): void;
 }
 
 /**
@@ -1705,14 +1705,14 @@ export declare const COLORS: {
  * This function is variadic, meaning that you can specify N arguments to combine N arrays. Note
  * that this will only perform a shallow copy of the array elements.
  */
-export declare function combineArrays<T>(...arrays: Array<T[] | readonly T[]>): T[];
+export declare function combineArrays<T>(...arrays: ReadonlyArray<readonly T[]>): T[];
 
 /**
  * Helper function to create a new set that is the composition of two or more sets.
  *
  * This function is variadic, meaning that you can specify N sets.
  */
-export declare function combineSets<T>(...sets: Array<Set<T> | ReadonlySet<T>>): Set<T>;
+export declare function combineSets<T>(...sets: ReadonlyArray<ReadonlySet<T>>): Set<T>;
 
 /**
  * Helper type to validate that a union of interfaces with a field of `type` that is based on an
@@ -1793,7 +1793,7 @@ declare type CopyableIsaacAPIClass = BitSet128 | Color | KColor | RNG | Vector;
  * @param numElements Optional. If specified, will only copy the first N elements. By default, the
  *                    entire array will be copied.
  */
-export declare function copyArray<T>(oldArray: T[] | readonly T[], numElements?: int): T[];
+export declare function copyArray<T>(oldArray: readonly T[], numElements?: int): T[];
 
 /** Helper function to copy a `BitSet128` Isaac API class. */
 export declare function copyBitSet128(bitSet128: BitSet128): BitSet128;
@@ -1813,16 +1813,16 @@ 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: Map<K, V> | ReadonlyMap<K, V>): Map<K, V>;
+export declare function copyMap<K, V>(oldMap: ReadonlyMap<K, V>): Map<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: Set<T> | ReadonlySet<T>): Set<T>;
+export declare function copySet<T>(oldSet: ReadonlySet<T>): Set<T>;
 
 /** Helper function to copy specific values from a userdata object (e.g. `Vector`) to a table. */
-export declare function copyUserdataValuesToTable(object: unknown, keys: string[] | readonly string[], luaMap: LuaMap<string, unknown>): void;
+export declare function copyUserdataValuesToTable(object: unknown, keys: readonly string[], luaMap: LuaMap<string, unknown>): void;
 
 /** Helper function to copy a `Vector` Isaac API class. */
 export declare function copyVector(vector: Vector): Vector;
@@ -3661,7 +3661,7 @@ export declare function defaultMapSetPlayer<V>(map: Map<PlayerIndex, V>, player:
  *
  * This function is variadic, meaning that you can specify N sets to remove from the first set.
  */
-export declare function deleteSetsFromSet<T>(mainSet: Set<T>, ...setsToRemove: Array<Set<T> | ReadonlySet<T>>): void;
+export declare function deleteSetsFromSet<T>(mainSet: Set<T>, ...setsToRemove: ReadonlyArray<ReadonlySet<T>>): void;
 
 declare class DeployJSONRoom extends Feature {
     private readonly preventGridEntityRespawn;
@@ -3704,7 +3704,7 @@ declare class DeployJSONRoom extends Feature {
      *                what the function is doing. Default is false.
      * @public
      */
-    deployJSONRoom(jsonRoom: JSONRoom | Readonly<JSONRoom>, seedOrRNG: Seed | RNG | undefined, verbose?: boolean): void;
+    deployJSONRoom(jsonRoom: Readonly<JSONRoom>, seedOrRNG: Seed | RNG | undefined, verbose?: boolean): void;
 }
 
 /**
@@ -3899,7 +3899,7 @@ declare class DisableInputs extends Feature {
      * @param blacklist A set of ButtonActions to disallow.
      * @public
      */
-    enableAllInputsExceptFor(key: string, blacklist: Set<ButtonAction> | ReadonlySet<ButtonAction>): void;
+    enableAllInputsExceptFor(key: string, blacklist: ReadonlySet<ButtonAction>): void;
     /**
      * Helper function to disable all inputs besides the ones provided. This is useful because
      * `EntityPlayer.ControlsEnabled` can be changed by the game under certain conditions.
@@ -3915,7 +3915,7 @@ declare class DisableInputs extends Feature {
      * @param whitelist A set of ButtonActions to allow.
      * @public
      */
-    disableAllInputsExceptFor(key: string, whitelist: Set<ButtonAction> | ReadonlySet<ButtonAction>): void;
+    disableAllInputsExceptFor(key: string, whitelist: ReadonlySet<ButtonAction>): void;
     /**
      * Helper function to disable only the inputs used for moving the character (or moving the cursor
      * in the UI). This is useful because `EntityPlayer.ControlsEnabled` can be changed by the game
@@ -3960,7 +3960,7 @@ export declare const DISTANCE_OF_GRID_TILE = 40;
  *                    true if any of the provided entity types exist.
  * @param ignoreFriendly Optional. Default is false.
  */
-export declare function doesAnyEntityExist(entityTypes: EntityType[] | readonly EntityType[] | Set<EntityType> | ReadonlySet<EntityType>, ignoreFriendly?: boolean): boolean;
+export declare function doesAnyEntityExist(entityTypes: readonly EntityType[] | ReadonlySet<EntityType>, ignoreFriendly?: boolean): boolean;
 
 /**
  * Helper function to check if one or more of a specific kind of entity is present in the current
@@ -4036,7 +4036,7 @@ export declare function doorSlotFlagToDoorSlot(doorSlotFlag: DoorSlotFlag): Door
  * Helper function to convert an array of door slots or a set of door slots to the resulting bit
  * flag number.
  */
-export declare function doorSlotsToDoorSlotFlags(doorSlots: DoorSlot[] | readonly DoorSlot[] | Set<DoorSlot> | ReadonlySet<DoorSlot>): BitFlags<DoorSlotFlag>;
+export declare function doorSlotsToDoorSlotFlags(doorSlots: readonly DoorSlot[] | ReadonlySet<DoorSlot>): BitFlags<DoorSlotFlag>;
 
 export declare function doorSlotToDirection(doorSlot: DoorSlot): Direction;
 
@@ -4567,7 +4567,7 @@ export declare function filter<T>(array: T[], func: (value: T, index: number, ar
  * This is named `filterMap` after the Rust function:
  * https://doc.rust-lang.org/std/iter/struct.FilterMap.html
  */
-export declare function filterMap<OldT, NewT>(array: OldT[] | readonly OldT[], func: (element: OldT) => NewT | undefined): NewT[];
+export declare function filterMap<OldT, NewT>(array: readonly OldT[], func: (element: OldT) => NewT | undefined): NewT[];
 
 /**
  * Helper function for non-TypeScript users to find an element in an array.
@@ -4997,7 +4997,7 @@ export declare function getAngleDifference(angle1: float, angle2: float): float;
  * @param max Optional. The maximum number of elements to include in each combination. Default is
  *            the length of the array.
  */
-export declare function getArrayCombinations<T>(array: T[] | readonly T[], includeEmptyArray: boolean, min?: int, max?: int): ReadonlyArray<readonly T[]>;
+export declare function getArrayCombinations<T>(array: readonly T[], includeEmptyArray: boolean, min?: int, max?: int): ReadonlyArray<readonly T[]>;
 
 /**
  * Helper function to get an array containing the indexes of an array.
@@ -5008,7 +5008,7 @@ export declare function getArrayCombinations<T>(array: T[] | readonly T[], inclu
  * due to implementation details of TypeScriptToLua, this results in an array of 1 through N
  * (instead of an array of 0 through N -1).
  */
-export declare function getArrayIndexes<T>(array: T[] | readonly T[]): readonly int[];
+export declare function getArrayIndexes<T>(array: readonly T[]): readonly int[];
 
 /**
  * Helper function to get how long Azazel's Brimstone laser should be. You can pass either an
@@ -5358,7 +5358,7 @@ export declare function getCircleDiscretizedPoints(centerPos: Vector, radius: fl
  * @param filterFunc Optional. A function to filter for a specific type of entity, like e.g. an
  *                   enemy with a certain amount of HP left.
  */
-export declare function getClosestEntityTo<T extends AnyEntity>(referenceEntity: Entity, entities: T[], filterFunc?: (entity: T) => boolean): T | undefined;
+export declare function getClosestEntityTo<T extends AnyEntity>(referenceEntity: Entity, entities: readonly T[], filterFunc?: (entity: T) => boolean): T | undefined;
 
 /**
  * Helper function to get the closest player to a certain position. Note that this will never
@@ -5555,7 +5555,7 @@ export declare function getCurseIDByName(name: string): LevelCurse;
  * Helper function to get the collectibles that are in a particular item pool at the beginning of a
  * vanilla run.
  */
-export declare function getDefaultCollectibleTypesInItemPool(itemPoolType: ItemPoolType): Set<CollectibleType>;
+export declare function getDefaultCollectibleTypesInItemPool(itemPoolType: ItemPoolType): ReadonlySet<CollectibleType>;
 
 /**
  * Helper function to get a set containing all of the global variable names that are contained
@@ -5763,7 +5763,7 @@ export declare function getEntityIDFromConstituents(entityType: EntityType, vari
  *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
  *                 multiple times.
  */
-export declare function getEntityPositions(entities?: Entity[] | readonly Entity[]): Map<PtrHash, Vector>;
+export declare function getEntityPositions(entities?: readonly Entity[]): ReadonlyMap<PtrHash, Vector>;
 
 export declare function getEntityTypeVariantFromBossID(bossID: BossID): readonly [EntityType, int];
 
@@ -5776,7 +5776,7 @@ export declare function getEntityTypeVariantFromBossID(bossID: BossID): readonly
  *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
  *                 multiple times.
  */
-export declare function getEntityVelocities(entities?: Entity[] | readonly Entity[]): Map<PtrHash, Vector>;
+export declare function getEntityVelocities(entities?: readonly Entity[]): ReadonlyMap<PtrHash, Vector>;
 
 /**
  * TypeScriptToLua will transpile TypeScript number enums to Lua tables that have a double mapping.
@@ -5887,7 +5887,7 @@ export declare function getFamiliars(familiarVariant?: FamiliarVariant | -1, sub
  * Helper function to compare two different arrays of entities. Returns the entities that are in the
  * second array but not in the first array.
  */
-export declare function getFilteredNewEntities<T extends AnyEntity>(oldEntities: T[] | readonly T[], newEntities: T[] | readonly T[]): readonly T[];
+export declare function getFilteredNewEntities<T extends AnyEntity>(oldEntities: readonly T[], newEntities: readonly T[]): readonly T[];
 
 /**
  * Helper function to return the player with the highest ID, according to the `Isaac.GetPlayer`
@@ -5932,7 +5932,7 @@ export declare function getFlagName<T extends BitFlag | BitFlag128>(flag: BitFla
  *
  * @param minimapAPI Optional. If MinimapAPI should be used, if present. Default is true.
  */
-export declare function getFloorDisplayFlags(minimapAPI?: boolean): Map<int, BitFlags<DisplayFlag>>;
+export declare function getFloorDisplayFlags(minimapAPI?: boolean): ReadonlyMap<int, BitFlags<DisplayFlag>>;
 
 /**
  * Helper function to get the corresponding golden trinket type from a normal trinket type.
@@ -6005,7 +6005,7 @@ export declare function getGridEntitiesInRadius(targetPosition: Vector, radius:
  *
  * @allowEmptyVariadic
  */
-export declare function getGridEntitiesMap(...gridEntityTypes: GridEntityType[]): Map<int, GridEntity>;
+export declare function getGridEntitiesMap(...gridEntityTypes: GridEntityType[]): ReadonlyMap<int, GridEntity>;
 
 /** Helper function to get the ANM2 path for a grid entity type. */
 export declare function getGridEntityANM2Path(gridEntityType: GridEntityType): string | undefined;
@@ -6157,7 +6157,7 @@ export declare function getJSONRoomDoorSlotFlags(jsonRoom: JSONRoom): BitFlags<D
  * @param variant The room variant to select. (The room variant can be thought of as the ID of the
  *                room.)
  */
-export declare function getJSONRoomOfVariant(jsonRooms: JSONRoom[] | readonly JSONRoom[], variant: int): JSONRoom | undefined;
+export declare function getJSONRoomOfVariant(jsonRooms: readonly JSONRoom[], variant: int): JSONRoom | undefined;
 
 /**
  * Helper function to find all of the JSON rooms that match the sub-type provided.
@@ -6167,7 +6167,7 @@ export declare function getJSONRoomOfVariant(jsonRooms: JSONRoom[] | readonly JS
  * @param jsonRooms The array of rooms to search through.
  * @param subType The sub-type to match.
  */
-export declare function getJSONRoomsOfSubType(jsonRooms: JSONRoom[] | readonly JSONRoom[], subType: int): readonly JSONRoom[];
+export declare function getJSONRoomsOfSubType(jsonRooms: readonly JSONRoom[], subType: int): readonly JSONRoom[];
 
 /** Helper function to get the value of a specific but in a binary representation of a number. */
 export declare function getKBitOfN(k: int, n: int): int;
@@ -6590,7 +6590,7 @@ export declare function getParentFunctionDescription(this: void, levels?: number
  * found, returns undefined.
  * ```
  */
-export declare function getPartialMatch(searchText: string, array: string[]): string | undefined;
+export declare function getPartialMatch(searchText: string, array: readonly string[]): string | undefined;
 
 /**
  * Helper function to get the associated pill effect after PHD is acquired. If a pill effect is not
@@ -6904,7 +6904,7 @@ export declare function getPlayersWithControllerIndex(controllerIndex: Controlle
 export declare function getPlayersWithTrinket(...trinketTypes: TrinketType[]): readonly EntityPlayer[];
 
 /** Returns a set of the player's current transformations. */
-export declare function getPlayerTransformations(player: EntityPlayer): Set<PlayerForm>;
+export declare function getPlayerTransformations(player: EntityPlayer): ReadonlySet<PlayerForm>;
 
 /**
  * Helper function to get all of the trinkets that the player is currently holding. This will not
@@ -6984,7 +6984,7 @@ export declare function getRandom(seedOrRNG: Seed | RNG | undefined): float;
  *                  a random seed.
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
-export declare function getRandomArrayElement<T>(array: T[] | readonly T[], seedOrRNG: Seed | RNG | undefined, exceptions?: T[] | readonly T[]): T;
+export declare function getRandomArrayElement<T>(array: readonly T[], seedOrRNG: Seed | RNG | undefined, exceptions?: readonly T[]): T;
 
 /**
  * Helper function to get a random element from the provided array. Once the random element is
@@ -6999,7 +6999,7 @@ export declare function getRandomArrayElement<T>(array: T[] | readonly T[], seed
  *                  a random seed.
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
-export declare function getRandomArrayElementAndRemove<T>(array: T[], seedOrRNG: Seed | RNG | undefined, exceptions?: T[] | readonly T[]): T;
+export declare function getRandomArrayElementAndRemove<T>(array: T[], seedOrRNG: Seed | RNG | undefined, exceptions?: readonly T[]): T;
 
 /**
  * Helper function to get a random index from the provided array.
@@ -7014,7 +7014,7 @@ export declare function getRandomArrayElementAndRemove<T>(array: T[], seedOrRNG:
  * @param exceptions Optional. An array of indexes that will be skipped over when getting the random
  *                   index. Default is an empty array.
  */
-export declare function getRandomArrayIndex<T>(array: T[] | readonly T[], seedOrRNG: Seed | RNG | undefined, exceptions?: int[] | readonly int[]): int;
+export declare function getRandomArrayIndex<T>(array: readonly T[], seedOrRNG: Seed | RNG | undefined, exceptions?: readonly int[]): int;
 
 /**
  * Helper function to get a random `Color` object.
@@ -7040,7 +7040,7 @@ export declare function getRandomColor(seedOrRNG: Seed | RNG | undefined, alpha?
  *                  a random seed.
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
-export declare function getRandomEnumValue<T extends TranspiledEnum>(transpiledEnum: T, seedOrRNG: Seed | RNG | undefined, exceptions?: Array<T[keyof T]> | ReadonlyArray<T[keyof T]>): T[keyof T];
+export declare function getRandomEnumValue<T extends TranspiledEnum>(transpiledEnum: T, seedOrRNG: Seed | RNG | undefined, exceptions?: ReadonlyArray<T[keyof T]>): T[keyof T];
 
 /**
  * Returns a random float between min and max.
@@ -7114,7 +7114,7 @@ export declare function getRandomIndexFromWeightedArray<T>(weightedArray: Weight
  *                   `[2]` would cause the function to return either 1, 3, or 4. Default is an empty
  *                   array.
  */
-export declare function getRandomInt(min: int, max: int, seedOrRNG: Seed | RNG | undefined, exceptions?: int[] | readonly int[]): int;
+export declare function getRandomInt(min: int, max: int, seedOrRNG: Seed | RNG | undefined, exceptions?: readonly int[]): int;
 
 /**
  * Helper function to get a random item pool. This is not as simple as getting a random value from
@@ -7204,7 +7204,7 @@ export declare function getRandomSeed(): Seed;
  *                  a random seed.
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
-export declare function getRandomSetElement<T>(set: Set<T> | ReadonlySet<T>, seedOrRNG: Seed | RNG | undefined, exceptions?: T[] | readonly T[]): T;
+export declare function getRandomSetElement<T>(set: ReadonlySet<T>, seedOrRNG: Seed | RNG | undefined, exceptions?: readonly T[]): T;
 
 /**
  * Helper function to get a random vector between (-1, -1) and (1, 1).
@@ -7267,8 +7267,6 @@ export declare function getRepentanceDoor(): GridEntityDoor | undefined;
  * ]);
  * ```
  */
-export declare function getReversedMap<K, V>(map: Map<K, V>): Map<V, K>;
-
 export declare function getReversedMap<K, V>(map: ReadonlyMap<K, V>): ReadonlyMap<V, K>;
 
 /**
@@ -7321,7 +7319,7 @@ export declare function getRoomAdjacentGridIndexes(roomGridIndex?: int): Readonl
  * Helper function to get the set of allowed door slots for the room at the supplied grid index.
  * This corresponds to the doors that are enabled in the STB/XML file for the room.
  */
-export declare function getRoomAllowedDoors(roomGridIndex?: int): Set<DoorSlot>;
+export declare function getRoomAllowedDoors(roomGridIndex?: int): ReadonlySet<DoorSlot>;
 
 /**
  * Helper function to get the room data for the current room.
@@ -7821,7 +7819,7 @@ export declare function getSeedEffects(): readonly SeedEffect[];
  * @param set The set to get the combinations of.
  * @param includeEmptyArray Whether to include an empty array in the combinations.
  */
-export declare function getSetCombinations<T>(set: Set<T> | ReadonlySet<T>, includeEmptyArray: boolean): ReadonlyArray<ReadonlySet<T>>;
+export declare function getSetCombinations<T>(set: ReadonlySet<T>, includeEmptyArray: boolean): ReadonlyArray<ReadonlySet<T>>;
 
 /**
  * Helper function to get the shooting actions that the specified `ControllerIndex` is currently
@@ -7879,7 +7877,7 @@ export declare function getSlots(slotVariant?: SlotVariant | -1, subType?: numbe
  * Normally, set values are returned in insertion order, so use this function when the ordering of
  * the contents is important.
  */
-export declare function getSortedSetValues<T>(set: Set<T> | ReadonlySet<T>): T[];
+export declare function getSortedSetValues<T>(set: ReadonlySet<T>): T[];
 
 /** Helper function to get all of the `GridEntitySpikes` in the room. */
 export declare function getSpikes(variant?: number): readonly GridEntitySpikes[];
@@ -8082,7 +8080,7 @@ export declare function getTransformationName(playerForm: PlayerForm): string;
  * Returns a set containing all of the transformations that the given collectible types contribute
  * towards.
  */
-export declare function getTransformationsForCollectibleType(collectibleType: CollectibleType): Set<PlayerForm>;
+export declare function getTransformationsForCollectibleType(collectibleType: CollectibleType): ReadonlySet<PlayerForm>;
 
 /**
  * Helper function to get all of the grid entities of type `GridEntityType.TRAPDOOR` (17) in the
@@ -8837,7 +8835,7 @@ export declare function is2x1RoomShape(roomShape: RoomShape): boolean;
  * Helper function to check if an instantiated Isaac API class is equal to another one of the same
  * type. You must provide the list of keys to check for.
  */
-export declare function isaacAPIClassEquals(object1: unknown, object2: unknown, keys: string[] | readonly string[]): boolean;
+export declare function isaacAPIClassEquals(object1: unknown, object2: unknown, keys: readonly string[]): boolean;
 
 declare interface IsaacAPIClassTypeToSerializedType {
     [CopyableIsaacAPIClassType.BIT_SET_128]: SerializedBitSet128;
@@ -8969,7 +8967,7 @@ export declare function isAllPressurePlatesPushed(): boolean;
  *                               false.
  * @allowEmptyVariadic
  */
-export declare function isAllRoomsClear(onlyCheckRoomTypes?: RoomType[] | readonly RoomType[], includeSecretRoom?: boolean, includeSuperSecretRoom?: boolean, includeUltraSecretRoom?: boolean): boolean;
+export declare function isAllRoomsClear(onlyCheckRoomTypes?: readonly RoomType[], includeSecretRoom?: boolean, includeSuperSecretRoom?: boolean, includeUltraSecretRoom?: boolean): boolean;
 
 export declare function isAngelRoomDoor(door: GridEntityDoor): boolean;
 
@@ -9002,7 +9000,7 @@ export declare function isArray(object: unknown, ensureContiguousValues?: boolea
 export declare function isArrayContiguous(array: int[]): boolean;
 
 /** Checks if an array is in the provided 2-dimensional array. */
-export declare function isArrayInArray<T>(arrayToMatch: T[] | readonly T[], parentArray: Array<T[] | readonly T[]>): boolean;
+export declare function isArrayInArray<T>(arrayToMatch: readonly T[], parentArray: ReadonlyArray<readonly T[]>): boolean;
 
 /** For `PickupVariant.LIL_BATTERY` (90). */
 export declare function isBattery(pickup: EntityPickup): pickup is EntityPickupBattery;
@@ -10703,7 +10701,7 @@ export declare function logAndPrint(msg: string): void;
  * @param array The array to log.
  * @param name Optional. The name of the array, which will be logged before the elements.
  */
-export declare function logArray<T>(this: void, array: T[] | readonly T[], name?: string): void;
+export declare function logArray<T>(this: void, array: readonly T[], name?: string): void;
 
 /**
  * Helper function to log the names of a collectible type array.
@@ -10711,7 +10709,7 @@ export declare function logArray<T>(this: void, array: T[] | readonly T[], name?
  * @param collectibleTypes The collectible types to log.
  * @param name Optional. The name of the array, which will be logged before the elements.
  */
-export declare function logCollectibleTypes(this: void, collectibleTypes: CollectibleType[] | readonly CollectibleType[], name?: string): void;
+export declare function logCollectibleTypes(this: void, collectibleTypes: readonly CollectibleType[], name?: string): void;
 
 /**
  * Helper function to log a `Color` object.
@@ -10764,7 +10762,7 @@ export declare function logGridEntity(this: void, gridEntity: GridEntity): void;
  * @param itemPoolTypes The item pool types to log.
  * @param name Optional. The name of the array, which will be logged before the elements.
  */
-export declare function logItemPoolTypes(this: void, itemPoolTypes: ItemPoolType[] | readonly ItemPoolType[], name?: string): void;
+export declare function logItemPoolTypes(this: void, itemPoolTypes: readonly ItemPoolType[], name?: string): void;
 
 /**
  * Helper function to log a `KColor` object.
@@ -10783,7 +10781,7 @@ export declare function logLevelStateFlags(this: void): void;
  * @param map The TSTL `Map` to log.
  * @param name Optional. The name of the map, which will be logged before the elements.
  */
-export declare function logMap(this: void, map: Map<AnyNotNil, unknown> | ReadonlyMap<AnyNotNil, unknown>, name?: string): void;
+export declare function logMap(this: void, map: ReadonlyMap<AnyNotNil, unknown>, name?: string): void;
 
 export declare function logMusic(this: void): void;
 
@@ -10824,7 +10822,7 @@ export declare function logSeedEffects(this: void): void;
  * @param set The TSTL `Set` to log.
  * @param name Optional. The name of the set, which will be logged before the elements.
  */
-export declare function logSet(this: void, set: Set<AnyNotNil> | ReadonlySet<AnyNotNil>, name?: string): void;
+export declare function logSet(this: void, set: ReadonlySet<AnyNotNil>, name?: string): void;
 
 /** Helper function for logging every sound effect that is currently playing. */
 export declare function logSounds(this: void): void;
@@ -14372,7 +14370,7 @@ declare class ModdedElementSets extends Feature {
      * @param exceptions Optional. An array of runes to not select.
      * @public
      */
-    getRandomEdenActiveCollectibleType(seedOrRNG: Seed | RNG | undefined, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
+    getRandomEdenActiveCollectibleType(seedOrRNG: Seed | RNG | undefined, exceptions?: readonly CollectibleType[]): CollectibleType;
     /**
      * Returns a random passive collectible type that that is a valid starting item for Eden
      * (including familiars).
@@ -14392,7 +14390,7 @@ declare class ModdedElementSets extends Feature {
      * @param exceptions Optional. An array of runes to not select.
      * @public
      */
-    getRandomEdenPassiveCollectibleType(seedOrRNG: Seed | RNG | undefined, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
+    getRandomEdenPassiveCollectibleType(seedOrRNG: Seed | RNG | undefined, exceptions?: readonly CollectibleType[]): CollectibleType;
     /**
      * Returns an array containing every collectible type with the given quality.
      *
@@ -15656,7 +15654,7 @@ export declare interface PocketItemDescription {
 }
 
 /** Helper function to see if two sets of pocket item descriptions are identical. */
-export declare function pocketItemsEquals(pocketItems1: PocketItemDescription[] | readonly PocketItemDescription[], pocketItems2: PocketItemDescription[] | readonly PocketItemDescription[]): boolean;
+export declare function pocketItemsEquals(pocketItems1: readonly PocketItemDescription[], pocketItems2: readonly PocketItemDescription[]): boolean;
 
 /** This is used in the various pocket item helper functions. */
 export declare enum PocketItemType {
@@ -16543,7 +16541,7 @@ export declare function removeDoors(...doors: GridEntityDoor[]): void;
  * @param cap Optional. If specified, will only remove the given amount of entities.
  * @returns An array of the entities that were removed.
  */
-export declare function removeEntities<T extends AnyEntity>(entities: T[] | readonly T[], cap?: int): readonly T[];
+export declare function removeEntities<T extends AnyEntity>(entities: readonly T[], cap?: int): readonly T[];
 
 /**
  * Helper function to remove all entities that just spawned from a grid entity breaking.
@@ -16552,7 +16550,7 @@ export declare function removeEntities<T extends AnyEntity>(entities: T[] | read
  *
  * You must specify an array of entities to look through.
  */
-export declare function removeEntitiesSpawnedFromGridEntity(entities: Entity[] | readonly Entity[], gridEntity: GridEntity): void;
+export declare function removeEntitiesSpawnedFromGridEntity(entities: readonly Entity[], gridEntity: GridEntity): void;
 
 /**
  * Helper function to remove a bit flag from an existing set of bit flags.
@@ -16585,7 +16583,7 @@ export declare function removeFlag<T extends BitFlag | BitFlag128>(flags: T | Bi
  * @param cap Optional. If specified, will only remove the given amount of entities.
  * @returns An array of the entities that were removed.
  */
-export declare function removeGridEntities<T extends AnyGridEntity>(gridEntities: T[] | readonly T[], updateRoom: boolean, cap?: int): readonly T[];
+export declare function removeGridEntities<T extends AnyGridEntity>(gridEntities: readonly T[], updateRoom: boolean, cap?: int): readonly T[];
 
 /**
  * Helper function to remove a grid entity by providing the grid entity object or the grid index
@@ -17546,19 +17544,19 @@ export declare function setActiveItem(player: EntityPlayer, collectibleType: Col
  *
  * This function is variadic, meaning that you can pass as many things as you want to add.
  */
-export declare function setAdd<T>(set: Set<T>, ...elements: T[]): void;
+export declare function setAdd<T>(set: Set<T>, ...elements: readonly T[]): void;
 
 /**
  * Helper function to make using sets with an type of `PtrHash` easier. Use this instead of the
  * `Set.add` method if you have a set of this type.
  */
-export declare function setAddNPC(set: Set<PtrHash>, npc: EntityNPC): Set<PtrHash>;
+export declare function setAddNPC(set: Set<PtrHash>, npc: EntityNPC): void;
 
 /**
  * Helper function to make using sets with an type of `PlayerIndex` easier. Use this instead of the
  * `Set.add` method if you have a set of this type.
  */
-export declare function setAddPlayer(set: Set<PlayerIndex>, player: EntityPlayer): Set<PlayerIndex>;
+export declare function setAddPlayer(set: Set<PlayerIndex>, player: EntityPlayer): void;
 
 /** Helper function to set every element in an array to a specific value. */
 export declare function setAllArrayElements<T>(array: T[], value: T): void;
@@ -17708,7 +17706,7 @@ export declare function setEntityOpacity(entity: Entity, alpha: float): void;
  *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
  *                 multiple times.
  */
-export declare function setEntityPositions(entityPositions: Map<PtrHash, Vector>, entities?: Entity[] | readonly Entity[]): void;
+export declare function setEntityPositions(entityPositions: ReadonlyMap<PtrHash, Vector>, entities?: readonly Entity[]): void;
 
 export declare function setEntityRandomColor(entity: Entity): void;
 
@@ -17725,7 +17723,7 @@ export declare function setEntityRandomColor(entity: Entity): void;
  *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
  *                 multiple times.
  */
-export declare function setEntityVelocities(entityVelocities: Map<PtrHash, Vector>, entities?: Entity[] | readonly Entity[]): void;
+export declare function setEntityVelocities(entityVelocities: ReadonlyMap<PtrHash, Vector>, entities?: readonly Entity[]): void;
 
 /**
  * Helper function to set the minimap `DisplayFlag` value for multiple rooms at once.
@@ -17764,7 +17762,7 @@ export declare function setGridEntityType(gridEntity: GridEntity, gridEntityType
  * This function is variadic, meaning that you can pass as many things as you want to check for. It
  * will return true if one or more elements are found.
  */
-export declare function setHas<T>(set: Set<T> | ReadonlySet<T>, ...elements: T[]): boolean;
+export declare function setHas<T>(set: ReadonlySet<T>, ...elements: readonly T[]): boolean;
 
 /**
  * Helper function to make using sets with an type of `PtrHash` easier. Use this instead of the
@@ -17870,7 +17868,7 @@ export declare function setSpriteOpacity(sprite: Sprite, alpha: float): void;
 export declare function setStage(stage: LevelStage, stageType: StageType, reseed?: boolean): void;
 
 /** Helper function to convert a set of flags to a single `BitFlags` object. */
-export declare function setToBitFlags<T extends BitFlag | BitFlag128>(set: Set<T> | ReadonlySet<T>): BitFlags<T>;
+export declare function setToBitFlags<T extends BitFlag | BitFlag128>(set: ReadonlySet<T>): BitFlags<T>;
 
 /**
  * Sets the `traceback` and `getTraceback` functions to be global functions.
@@ -17983,7 +17981,7 @@ export declare function shouldWhoreOfBabylonBeActive(player: EntityPlayer): bool
  *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
  *                  a random seed.
  */
-export declare function shuffleArray<T>(originalArray: T[] | readonly T[], seedOrRNG: Seed | RNG | undefined): T[];
+export declare function shuffleArray<T>(originalArray: readonly T[], seedOrRNG: Seed | RNG | undefined): T[];
 
 /**
  * Shuffles the provided array in-place using the Fisher-Yates algorithm.
@@ -18784,13 +18782,13 @@ export declare type StoryBossID = (typeof STORY_BOSS_IDS)[number];
 export declare type Subtract<A extends number, B extends number> = A extends A ? BuildTuple<A> extends [...infer U, ...BuildTuple<B>] ? Length<U> : never : never;
 
 /** Helper function to sum every value in an array together. */
-export declare function sumArray(array: number[] | readonly number[]): number;
+export declare function sumArray(array: readonly number[]): number;
 
 /** Helper function to sum every value in a map together. */
-export declare function sumMap(map: Map<unknown, number> | ReadonlyMap<unknown, number>): number;
+export declare function sumMap(map: ReadonlyMap<unknown, number>): number;
 
 /** Helper function to sum every value in a set together. */
-export declare function sumSet(set: Set<number> | ReadonlySet<number>): number;
+export declare function sumSet(set: ReadonlySet<number>): number;
 
 /**
  * Helper function to swap two different array elements. (The elements will be swapped in-place.)
@@ -19017,7 +19015,7 @@ export declare type TupleToUnion<T extends unknown[]> = T[number];
  *
  * For example, `TupleWithLengthBetween<string, 2, 4>` will allow string tuples of size 2, 3, or 4.
  */
-export declare type TupleWithLengthBetween<T, MinLength extends number, MaxLength extends number> = (T[] | readonly T[]) & {
+export declare type TupleWithLengthBetween<T, MinLength extends number, MaxLength extends number> = readonly T[] & {
     length: IRange<MinLength, MaxLength>;
 };
 
@@ -19026,7 +19024,7 @@ export declare type TupleWithLengthBetween<T, MinLength extends number, MaxLengt
  *
  * For example, `TupleWithMaxLength<string, 3>` will allow string tuples of size 0, 1, 2, or 3.
  */
-export declare type TupleWithMaxLength<T, MaxLength extends number> = (T[] | readonly T[]) & {
+export declare type TupleWithMaxLength<T, MaxLength extends number> = readonly T[] & {
     length: IRange<0, MaxLength>;
 };