isaacscript-common 71.2.1 → 72.0.1

package/dist/index.rollup.d.ts

@@ -2131,17 +2131,21 @@ declare class CustomItemPools extends Feature {
      * By default, a collectible will not be removed from the pool once it is selected, unless the
      * `decrease` argument is set to true (similar to how a vanilla item pool works).
      *
+     * If you want to get an unseeded collectible type, you must explicitly pass `undefined` to the
+     * `seedOrRNG` parameter.
+     *
      * In order to use this function, you must upgrade your mod with `ISCFeature.CUSTOM_ITEM_POOLS`.
      *
      * @param itemPoolTypeCustom An integer representing the custom item pool to use.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @param decrease Optional. Whether to remove the selected collectible from the item pool.
      *                 Default is true.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
      * @param defaultItem Optional. The collectible to return if the item pool is depleted. Default is
      *                    `CollectibleType.NULL`.
      */
-    getCustomItemPoolCollectible(itemPoolTypeCustom: ItemPoolType, decrease?: boolean, seedOrRNG?: Seed | RNG, defaultItem?: CollectibleType): CollectibleType;
+    getCustomItemPoolCollectible(itemPoolTypeCustom: ItemPoolType, seedOrRNG: Seed | RNG | undefined, decrease?: boolean, defaultItem?: CollectibleType): CollectibleType;
 }
 
 declare class CustomPickups extends Feature {
@@ -3597,15 +3601,19 @@ declare class DeployJSONRoom extends Feature {
      * }
      * ```
      *
+     * If you want to deploy an unseeded room, you must explicitly pass `undefined` to the `seedOrRNG`
+     * parameter.
+     *
      * In order to use this function, you must upgrade your mod with `ISCFeature.DEPLOY_JSON_ROOM`.
      *
      * @param jsonRoom The JSON room to deploy.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @param verbose Optional. If specified, will write entries to the "log.txt" file that describe
      *                what the function is doing. Default is false.
      */
-    deployJSONRoom(jsonRoom: JSONRoom | Readonly<JSONRoom>, seedOrRNG?: Seed | RNG, verbose?: boolean): void;
+    deployJSONRoom(jsonRoom: JSONRoom | Readonly<JSONRoom>, seedOrRNG: Seed | RNG | undefined, verbose?: boolean): void;
 }
 
 /**
@@ -6198,15 +6206,19 @@ export declare function getNewGlobals(): ReadonlyArray<[AnyNotNil, unknown]>;
  * some floors will not have any valid spots. If this is the case, this function will return
  * undefined.
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * If you want to get an unseeded room, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param ensureDeadEnd Optional. Whether to pick a valid dead end attached to a normal room. If
  *                      false, the function will randomly pick from any valid location that would
  *                      have a red door.
  * @returns Either a tuple of adjacent room grid index, `DoorSlot`, and new room grid index, or
  *          undefined.
  */
-export declare function getNewRoomCandidate(seedOrRNG?: Seed | RNG, ensureDeadEnd?: boolean): {
+export declare function getNewRoomCandidate(seedOrRNG: Seed | RNG | undefined, ensureDeadEnd?: boolean): {
     readonly adjacentRoomGridIndex: int;
     readonly doorSlot: DoorSlot;
     readonly newRoomGridIndex: int;
@@ -6770,61 +6782,84 @@ export declare function getProjectiles(projectileVariant?: ProjectileVariant | -
  * Returns a random float between 0 and 1. It is inclusive on the low end, but exclusive on the high
  * end. (This is because the `RNG.RandomFloat` method will never return a value of exactly 1.)
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * If you want to generate an unseeded number, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
-export declare function getRandom(seedOrRNG?: Seed | RNG): float;
+export declare function getRandom(seedOrRNG: Seed | RNG | undefined): float;
 
 /**
  * Helper function to get a random element from the provided array.
  *
+ * If you want to get an unseeded element, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param array The array to get an element from.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  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, exceptions?: T[] | readonly T[]): T;
+export declare function getRandomArrayElement<T>(array: T[] | readonly T[], seedOrRNG: Seed | RNG | undefined, exceptions?: T[] | readonly T[]): T;
 
 /**
  * Helper function to get a random element from the provided array. Once the random element is
  * decided, it is then removed from the array (in-place).
  *
+ * If you want to get an unseeded element, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param array The array to get an element from.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  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, exceptions?: T[] | readonly T[]): T;
+export declare function getRandomArrayElementAndRemove<T>(array: T[], seedOrRNG: Seed | RNG | undefined, exceptions?: T[] | readonly T[]): T;
 
 /**
  * Helper function to get a random index from the provided array.
  *
+ * If you want to get an unseeded index, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param array The array to get the index from.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @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, exceptions?: int[] | readonly int[]): int;
+export declare function getRandomArrayIndex<T>(array: T[] | readonly T[], seedOrRNG: Seed | RNG | undefined, exceptions?: int[] | readonly int[]): int;
 
 /**
- * Helper function to get a random color.
+ * Helper function to get a random `Color` object.
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * If you want to generate an unseeded object, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param alpha Optional. The alpha value to use. Default is 1.
  */
-export declare function getRandomColor(seedOrRNG?: Seed | RNG, alpha?: number): Readonly<Color>;
+export declare function getRandomColor(seedOrRNG: Seed | RNG | undefined, alpha?: number): Readonly<Color>;
 
 /**
  * Helper function to get a random value from the provided enum.
  *
+ * If you want an unseeded value, you must explicitly pass `undefined` to the `seedOrRNG` parameter.
+ *
  * @param transpiledEnum The enum to get the value from.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
-export declare function getRandomEnumValue<T>(transpiledEnum: T, seedOrRNG?: Seed | RNG, exceptions?: Array<T[keyof T]> | ReadonlyArray<T[keyof T]>): T[keyof T];
+export declare function getRandomEnumValue<T>(transpiledEnum: T, seedOrRNG: Seed | RNG | undefined, exceptions?: Array<T[keyof T]> | ReadonlyArray<T[keyof T]>): T[keyof T];
 
 /**
  * Returns a random float between min and max.
@@ -6832,59 +6867,87 @@ export declare function getRandomEnumValue<T>(transpiledEnum: T, seedOrRNG?: See
  * For example:
  *
  * ```ts
- * const realNumberBetweenOneAndThree = getRandomFloat(1, 3);
+ * const realNumberBetweenOneAndThree = getRandomFloat(1, 3, undefined);
  * ```
  *
+ * If you want to generate an unseeded number, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
  * @param min The lower bound for the random number (inclusive).
  * @param max The upper bound for the random number (exclusive).
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
-export declare function getRandomFloat(min: int, max: int, seedOrRNG?: Seed | RNG): float;
+export declare function getRandomFloat(min: int, max: int, seedOrRNG: Seed | RNG | undefined): float;
 
 /**
  * Get a random value from a `WeightedArray`. (A `WeightedArray` is an array of tuples, where the
  * first element in the tuple is a value, and the second element in the tuple is a float
  * corresponding to the value's weight.)
+ *
+ * If you want to get an unseeded element, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
+ * @param weightedArray The array to pick from.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `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): T;
+export declare function getRandomFromWeightedArray<T>(weightedArray: WeightedArray<T>, seedOrRNG: Seed | RNG | undefined): T;
 
 /**
  * Get a random index from a `WeightedArray`. (A `WeightedArray` is an array of tuples, where the
  * first element in the tuple is a value, and the second element in the tuple is a float
  * corresponding to the value's weight.)
+ *
+ * If you want to get an unseeded index, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
+ * @param weightedArray The array to pick from.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `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): int;
+export declare function getRandomIndexFromWeightedArray<T>(weightedArray: WeightedArray<T>, seedOrRNG: Seed | RNG | undefined): int;
 
 /**
  * Returns a random integer between min and max. It is inclusive on both ends.
  *
- * Note that this function will run the `Next` method on the `RNG` object before returning the
- * random number.
- *
  * For example:
  *
  * ```ts
  * const oneTwoOrThree = getRandomInt(1, 3);
  * ```
  *
+ * If you want to generate an unseeded number, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
  * @param min The lower bound for the random number (inclusive).
  * @param max The upper bound for the random number (inclusive).
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param exceptions Optional. An array of elements that will be skipped over when getting the
  *                   random integer. For example, a min of 1, a max of 4, and an exceptions array of
  *                   `[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, exceptions?: int[] | readonly int[]): int;
+export declare function getRandomInt(min: int, max: int, seedOrRNG: Seed | RNG | undefined, exceptions?: int[] | readonly int[]): int;
 
 /**
  * Helper function to get a random item pool. This is not as simple as getting a random value from
  * the `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the
  * Greed Mode item pools should be excluded if not playing in Greed Mode.
+ *
+ * If you want to get an unseeded item pool, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
-export declare function getRandomItemPool(): ItemPoolType;
+export declare function getRandomItemPool(seedOrRNG: Seed | RNG | undefined): ItemPoolType;
 
 /**
  * Helper function to get a random JSON entity from an array of JSON entities.
@@ -6896,13 +6959,17 @@ export declare function getRandomItemPool(): ItemPoolType;
  * properly account for each room weight using the algorithm from:
  * https://stackoverflow.com/questions/1761626/weighted-random-numbers
  *
+ * If you want an unseeded entity, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param jsonEntities The array of entities to randomly choose between.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @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, verbose?: boolean): JSONEntity;
+export declare function getRandomJSONEntity(jsonEntities: JSONEntity[], seedOrRNG: Seed | RNG | undefined, verbose?: boolean): JSONEntity;
 
 /**
  * Helper function to get a random JSON room from an array of JSON rooms.
@@ -6913,22 +6980,29 @@ export declare function getRandomJSONEntity(jsonEntities: JSONEntity[], seedOrRN
  * properly account for each room weight using the algorithm from:
  * https://stackoverflow.com/questions/1761626/weighted-random-numbers
  *
+ * If you want an unseeded room, you must explicitly pass `undefined` to the `seedOrRNG` parameter.
+ *
  * @param jsonRooms The array of rooms to randomly choose between.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @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 getRandomJSONRoom(jsonRooms: JSONRoom[], seedOrRNG?: Seed | RNG, verbose?: boolean): JSONRoom;
+export declare function getRandomJSONRoom(jsonRooms: JSONRoom[], seedOrRNG: Seed | RNG | undefined, verbose?: boolean): JSONRoom;
 
 /**
- * Helper function to get a random color.
+ * Helper function to get a random `KColor` object (for use in fonts).
+ *
+ * If you want to generate an unseeded object, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param alpha Optional. The alpha value to use. Default is 1.
  */
-export declare function getRandomKColor(seedOrRNG?: Seed | RNG, alpha?: number): Readonly<KColor>;
+export declare function getRandomKColor(seedOrRNG: Seed | RNG | undefined, alpha?: number): Readonly<KColor>;
 
 /**
  * Helper function to get a random `Seed` value to be used in spawning entities and so on. Use this
@@ -6940,12 +7014,16 @@ export declare function getRandomSeed(): Seed;
 /**
  * Helper function to get a random element from the provided set.
  *
+ * If you want to get an unseeded element, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param set The set to get an element from.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  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, exceptions?: T[] | readonly T[]): T;
+export declare function getRandomSetElement<T>(set: Set<T> | ReadonlySet<T>, seedOrRNG: Seed | RNG | undefined, exceptions?: T[] | readonly T[]): T;
 
 /**
  * Helper function to get a random vector between (-1, -1) and (1, 1).
@@ -6954,10 +7032,14 @@ export declare function getRandomSetElement<T>(set: Set<T> | ReadonlySet<T>, see
  *
  * Use this over the `RandomVector` function when you need the vector to be seeded.
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * If you want to generate an unseeded vector, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
-export declare function getRandomVector(seedOrRNG?: Seed | RNG): Readonly<Vector>;
+export declare function getRandomVector(seedOrRNG: Seed | RNG | undefined): Readonly<Vector>;
 
 /**
  * Helper function to get a read-only copy of the room descriptor for every room on the level. This
@@ -13935,13 +14017,17 @@ declare class ModdedElementSets extends Feature {
      * not all collectible types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
+     * If you want to get an unseeded collectible type, you must explicitly pass `undefined` to the
+     * `seedOrRNG` parameter.
+     *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      *
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @param exceptions Optional. An array of runes to not select.
      */
-    getRandomEdenActiveCollectibleType(seedOrRNG?: Seed | RNG, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
+    getRandomEdenActiveCollectibleType(seedOrRNG: Seed | RNG | undefined, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
     /**
      * Returns a random passive collectible type that that is a valid starting item for Eden
      * (including familiars).
@@ -13950,13 +14036,17 @@ declare class ModdedElementSets extends Feature {
      * not all collectible types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
+     * If you want to get an unseeded collectible type, you must explicitly pass `undefined` to the
+     * `seedOrRNG` parameter.
+     *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      *
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @param exceptions Optional. An array of runes to not select.
      */
-    getRandomEdenPassiveCollectibleType(seedOrRNG?: Seed | RNG, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
+    getRandomEdenPassiveCollectibleType(seedOrRNG: Seed | RNG | undefined, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
     /**
      * Returns a set containing every collectible type with the given quality.
      *
@@ -13995,15 +14085,19 @@ declare class ModdedElementSets extends Feature {
      * This function can only be called if at least one callback has been executed. This is because
      * not all card types will necessarily be present when a mod first loads (due to mod load order).
      *
+     * If you want to get an unseeded card type, you must explicitly pass `undefined` to the
+     * `seedOrRNG` parameter.
+     *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      *
      * @param itemConfigCardType The item config card type that represents the pool of cards to select
      *                           from.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @param exceptions Optional. An array of cards to not select.
      */
-    getRandomCardTypeOfType(itemConfigCardType: ItemConfigCardType, seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
+    getRandomCardTypeOfType(itemConfigCardType: ItemConfigCardType, seedOrRNG: Seed | RNG | undefined, exceptions?: CardType[]): CardType;
     /**
      * Has an equal chance of returning any card (e.g. Fool, Reverse Fool, Wild Card, etc.).
      *
@@ -14014,13 +14108,17 @@ declare class ModdedElementSets extends Feature {
      * This function can only be called if at least one callback has been executed. This is because
      * not all card types will necessarily be present when a mod first loads (due to mod load order).
      *
+     * If you want to get an unseeded card type, you must explicitly pass `undefined` to the
+     * `seedOrRNG` parameter.
+     *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      *
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @param exceptions Optional. An array of cards to not select.
      */
-    getRandomCard(seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
+    getRandomCard(seedOrRNG: Seed | RNG | undefined, exceptions?: 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.
@@ -14028,13 +14126,17 @@ declare class ModdedElementSets extends Feature {
      * This function can only be called if at least one callback has been executed. This is because
      * not all card types will necessarily be present when a mod first loads (due to mod load order).
      *
+     * If you want to get an unseeded card type, you must explicitly pass `undefined` to the
+     * `seedOrRNG` parameter.
+     *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      *
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @param exceptions Optional. An array of runes to not select.
      */
-    getRandomRune(seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
+    getRandomRune(seedOrRNG: Seed | RNG | undefined, exceptions?: CardType[]): CardType;
 }
 
 /**
@@ -14340,16 +14442,19 @@ export declare function newReadonlyVector(x: float, y: float): Readonly<Vector>;
 /**
  * Helper function to initialize a new RNG object using Blade's recommended shift index.
  *
- * @param seed The seed to initialize it with. Default is `getRandomSeed()`.
+ * @param seed Optional. The seed to initialize it with. Default is a random seed.
  */
 export declare function newRNG(seed?: Seed): RNG;
 
 /**
  * Helper function to generate a new room on the floor.
  *
+ * If you want to generate an unseeded room, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * Under the hood, this function uses the `Level.MakeRedRoomDoor` method to create the room.
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
  *                  `RNG.Next` method will be called. Default is `Level.GetDungeonPlacementSeed`.
  *                  Note that the RNG is only used to select the random location to put the room on
  *                  the floor; it does not influence the randomly chosen room contents. (That is
@@ -14363,7 +14468,7 @@ export declare function newRNG(seed?: Seed): RNG;
  * @returns The room grid index of the new room or undefined if the floor had no valid dead ends to
  *          place a room.
  */
-export declare function newRoom(seedOrRNG?: Seed | RNG, ensureDeadEnd?: boolean, customRoomData?: RoomConfig): int | undefined;
+export declare function newRoom(seedOrRNG: Seed | RNG | undefined, ensureDeadEnd?: boolean, customRoomData?: RoomConfig): int | undefined;
 
 /**
  * Helper function to load a new sprite and play its default animation.
@@ -17321,24 +17426,32 @@ declare function shouldFireSlot(fireArgs: [slot: EntitySlot] | [slot: EntitySlot
 /**
  * Shallow copies and shuffles the array using the Fisher-Yates algorithm. Returns the copied array.
  *
+ * If you want an unseeded shuffle, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * From: https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
  *
  * @param originalArray The array to shuffle.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `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): T[];
+export declare function shuffleArray<T>(originalArray: T[] | readonly T[], seedOrRNG: Seed | RNG | undefined): T[];
 
 /**
  * Shuffles the provided array in-place using the Fisher-Yates algorithm.
  *
+ * If you want an unseeded shuffle, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * From: https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
  *
  * @param array The array to shuffle.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
-export declare function shuffleArrayInPlace<T>(array: T[], seedOrRNG?: Seed | RNG): void;
+export declare function shuffleArrayInPlace<T>(array: T[], seedOrRNG: Seed | RNG | undefined): void;
 
 /** @returns 1 if n is positive, -1 if n is negative, or 0 if n is 0. */
 export declare function sign(n: number): int;
@@ -17581,19 +17694,23 @@ declare class SpawnCollectible extends Feature {
      * to be a quest item), then you can use the `spawnCollectibleUnsafe` helper function instead
      * (which does not require an upgraded mod).
      *
+     * If you want to spawn an unseeded collectible, you must explicitly pass `undefined` to the
+     * `seedOrRNG` parameter.
+     *
      * In order to use this function, you must upgrade your mod with `ISCFeature.SPAWN_COLLECTIBLE`.
      *
      * @param collectibleType The collectible type to spawn.
      * @param positionOrGridIndex The position or grid index to spawn the collectible at.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @param options Optional. Set to true to make the collectible a "There's Options" style
      *                collectible. Default is false.
      * @param forceFreeItem Optional. Set to true to disable the logic that gives the item a price for
      *                      Tainted Keeper. Default is false.
      * @param spawner Optional.
      */
-    spawnCollectible(collectibleType: CollectibleType, positionOrGridIndex: Vector | int, seedOrRNG?: Seed | RNG, options?: boolean, forceFreeItem?: boolean, spawner?: Entity): EntityPickupCollectible;
+    spawnCollectible(collectibleType: CollectibleType, positionOrGridIndex: Vector | int, seedOrRNG: Seed | RNG | undefined, options?: boolean, forceFreeItem?: boolean, spawner?: Entity): EntityPickupCollectible;
     /**
      * Helper function to spawn a collectible from a specific item pool.
      *
@@ -17601,19 +17718,23 @@ declare class SpawnCollectible extends Feature {
      * collectibles costing coins and preventing quest items from being rotated by Tainted Isaac's
      * rotation mechanic.
      *
+     * If you want to spawn an unseeded collectible, you must explicitly pass `undefined` to the
+     * `seedOrRNG` parameter.
+     *
      * In order to use this function, you must upgrade your mod with `ISCFeature.SPAWN_COLLECTIBLE`.
      *
      * @param itemPoolType The item pool to draw the collectible type from.
      * @param positionOrGridIndex The position or grid index to spawn the collectible at.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @param options Optional. Set to true to make the collectible a "There's Options" style
      *                collectible. Default is false.
      * @param forceFreeItem Optional. Set to true to disable the logic that gives the item a price for
      *                      Tainted Keeper. Default is false.
      * @param spawner Optional.
      */
-    spawnCollectibleFromPool(itemPoolType: ItemPoolType, positionOrGridIndex: Vector | int, seedOrRNG?: Seed | RNG, options?: boolean, forceFreeItem?: boolean, spawner?: Entity): EntityPickupCollectible;
+    spawnCollectibleFromPool(itemPoolType: ItemPoolType, positionOrGridIndex: Vector | int, seedOrRNG: Seed | RNG | undefined, options?: boolean, forceFreeItem?: boolean, spawner?: Entity): EntityPickupCollectible;
 }
 
 /**
@@ -17626,17 +17747,21 @@ declare class SpawnCollectible extends Feature {
  * Isaac's rotation mechanic. To handle that, use the `spawnCollectible` helper function instead
  * (which is provided by `ISCFeature.SPAWN_COLLECTIBLE`).
  *
+ * If you want to spawn an unseeded collectible, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
  * @param collectibleType The collectible type to spawn.
  * @param positionOrGridIndex The position or grid index to spawn the collectible at.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param options Optional. Set to true to make the collectible a "There's Options" style
  *                collectible. Default is false.
  * @param forceFreeItem Optional. Set to true to disable the logic that gives the item a price for
  *                      Tainted Keeper. Default is false.
  * @param spawner Optional.
  */
-export declare function spawnCollectibleUnsafe(collectibleType: CollectibleType, positionOrGridIndex: Vector | int, seedOrRNG?: Seed | RNG, options?: boolean, forceFreeItem?: boolean, spawner?: Entity): EntityPickupCollectible;
+export declare function spawnCollectibleUnsafe(collectibleType: CollectibleType, positionOrGridIndex: Vector | int, seedOrRNG: Seed | RNG | undefined, options?: boolean, forceFreeItem?: boolean, spawner?: Entity): EntityPickupCollectible;
 
 /** Helper function to spawn a `GridEntityType.CRAWL_SPACE` (18). */
 export declare function spawnCrawlSpace(gridIndexOrPosition: int | Vector): GridEntity | undefined;
@@ -17666,11 +17791,15 @@ export declare function spawnEffectWithSeed(effectVariant: EffectVariant, subTyp
  * Onion because it is a quest collectible and quest collectibles will prevent Damocles from
  * duplicating the pedestal.)
  *
+ * If you want to spawn an unseeded collectible, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
  * @param positionOrGridIndex The position or grid index to spawn the empty collectible at.
  * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
-export declare function spawnEmptyCollectible(positionOrGridIndex: Vector | int, seedOrRNG?: Seed | RNG): EntityPickup;
+export declare function spawnEmptyCollectible(positionOrGridIndex: Vector | int, seedOrRNG: Seed | RNG | undefined): EntityPickup;
 
 /**
  * Helper function to spawn the entity corresponding to an `EntityID`.
@@ -17853,18 +17982,22 @@ declare class SpawnRockAltRewards extends Feature {
      * The logic in this function is based on the rewards listed on the wiki:
      * https://bindingofisaacrebirth.fandom.com/wiki/Rocks
      *
+     * If you want to spawn an unseeded reward, you must explicitly pass `undefined` to the
+     * `seedOrRNG` parameter.
+     *
      * In order to use this function, you must upgrade your mod with
      * `ISCFeature.SPAWN_ALT_ROCK_REWARDS`.
      *
      * @param positionOrGridIndex The position or grid index to spawn the reward.
      * @param rockAltType The type of reward to spawn. For example, `RockAltType.URN` will have a
      *                    chance at spawning coins and spiders.
-     * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-     *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`. Normally,
-     *                  you should pass the `InitSeed` of the grid entity that was broken.
+     * @param seedOrRNG The `Seed` or `RNG` object to use. Normally, you should pass the `InitSeed` of
+     *                  the grid entity that was broken. If an `RNG` object is provided, the
+     *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+     *                  to a random seed.
      * @returns Whether this function spawned something.
      */
-    spawnRockAltReward(positionOrGridIndex: Vector | int, rockAltType: RockAltType, seedOrRNG?: Seed | RNG): boolean;
+    spawnRockAltReward(positionOrGridIndex: Vector | int, rockAltType: RockAltType, seedOrRNG: Seed | RNG | undefined): boolean;
     /**
      * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
      * breaks of `RockAltType.URN`.