isaacscript-common 40.0.0 → 41.0.0

package/dist/src/classes/features/other/ModdedElementSets.d.ts

@@ -1,36 +1,43 @@
+import type { PillEffect } from "isaac-typescript-definitions";
 import { CacheFlag, CardType, CollectibleType, ItemConfigCardType, ItemConfigTag, PlayerForm, TrinketType } from "isaac-typescript-definitions";
 import { Feature } from "../../private/Feature";
+/**
+ * A feature that lazy-inits and caches various arrays and sets that include both vanilla and modded
+ * elements. This is useful for performance purposes (so that we do not have to reconstruct the
+ * arrays/sets multiple times).
+ *
+ * The modded arrays/sets are created using the functions from
+ * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+ */
 export declare class ModdedElementSets extends Feature {
     private arraysInitialized;
     private readonly allCollectibleTypesArray;
     private readonly allCollectibleTypesSet;
-    private readonly vanillaCollectibleTypesArray;
-    private readonly vanillaCollectibleTypesSet;
     private readonly moddedCollectibleTypesArray;
     private readonly moddedCollectibleTypesSet;
     private readonly allTrinketTypesArray;
     private readonly allTrinketTypesSet;
-    private readonly vanillaTrinketTypesArray;
-    private readonly vanillaTrinketTypesSet;
     private readonly moddedTrinketTypesArray;
     private readonly moddedTrinketTypesSet;
     private readonly allCardTypesArray;
     private readonly allCardTypesSet;
-    private readonly vanillaCardTypesArray;
-    private readonly vanillaCardTypesSet;
     private readonly moddedCardTypesArray;
     private readonly moddedCardTypesSet;
-    private readonly tagToCollectibleTypesMap;
+    private readonly allPillEffectsArray;
+    private readonly allPillEffectsSet;
+    private readonly moddedPillEffectsArray;
+    private readonly moddedPillEffectsSet;
     private readonly cacheFlagToCollectibleTypesMap;
     private readonly cacheFlagToTrinketTypesMap;
     private flyingCollectibleTypesSet;
     private readonly permanentFlyingCollectibleTypesSet;
     private flyingTrinketTypesSet;
+    private readonly tagToCollectibleTypesMap;
     private readonly edenActiveCollectibleTypesSet;
     private readonly edenPassiveCollectibleTypesSet;
     private readonly itemConfigCardTypeToCardTypeMap;
     /**
-     * The set of cards that are not:
+     * The set of card types that are not:
      *
      * - ItemConfigCardType.RUNE
      * - ItemConfigCardType.SPECIAL_OBJECT
@@ -38,12 +45,10 @@ export declare class ModdedElementSets extends Feature {
     private readonly cardSet;
     private readonly moddedElementDetection;
     private lazyInit;
-    private lazyInitVanillaCollectibleTypes;
     private lazyInitModdedCollectibleTypes;
-    private lazyInitVanillaTrinketTypes;
     private lazyInitModdedTrinketTypes;
-    private lazyInitVanillaCardTypes;
     private lazyInitModdedCardTypes;
+    private lazyInitModdedPillEffects;
     private lazyInitTagToCollectibleTypesMap;
     private lazyInitCacheFlagToCollectibleTypesMap;
     private lazyInitCacheFlagToTrinketTypesMap;
@@ -52,250 +57,246 @@ export declare class ModdedElementSets extends Feature {
     private lazyInitEdenCollectibleTypesSet;
     private lazyInitCardTypes;
     /**
-     * Returns an array containing every valid card type in the game, including modded cards.
-     *
-     * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
-     * use the `getCardSet` helper function instead.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getCardArray(): readonly CardType[];
-    /**
-     * Returns a set containing every valid card type in the game, including modded cards.
+     * Returns an array containing every valid collectible type in the game, including modded
+     * collectibles.
      *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
-     * use the `getCardArray` helper function instead.
+     * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
+     * then use the `getCollectibleTypesSet` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getCardSet(): ReadonlySet<CardType>;
+    getCollectibleTypes(): readonly CollectibleType[];
     /**
-     * Helper function to get a set of card types matching the `ItemConfigCardType`.
+     * Returns a set containing every valid collectible type in the game, including modded
+     * collectibles.
      *
-     * This function is variadic, meaning that you can you can specify N card types to get a set
-     * containing cards that match any of the specified types.
+     * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
+     * then use the `getCollectibleTypes` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getCardTypesOfType(...itemConfigCardTypes: ItemConfigCardType[]): Set<CardType>;
+    getCollectibleTypeSet(): ReadonlySet<CollectibleType>;
     /**
-     * Returns an array containing every valid collectible type in the game, including modded
-     * collectibles.
+     * Returns an array containing every modded collectible type in the game.
      *
      * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
-     * then use the `getCollectibleSet` helper function instead.
+     * then use the `getModdedCollectibleTypesSet` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getCollectibleArray(): readonly CollectibleType[];
+    getModdedCollectibleTypes(): readonly CollectibleType[];
     /**
-     * Returns a set containing every valid collectible type in the game, including modded
-     * collectibles.
+     * Returns a set containing every modded collectible type in the game.
      *
      * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
-     * then use the `getCollectibleArray` helper function instead.
+     * then use the `getModdedCollectibleTypes` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getCollectibleSet(): ReadonlySet<CollectibleType>;
+    getModdedCollectibleTypesSet(): ReadonlySet<CollectibleType>;
     /**
-     * Helper function to get all of the collectible types in the game that count towards a particular
-     * transformation.
-     *
-     * For example, to get all of the collectible types that count towards Guppy:
+     * Iterates over every collectible in the game and returns a map containing the number of each
+     * item that the player has.
      *
-     * ```ts
-     * const guppyCollectibleTypes = getCollectiblesForTransformation(PlayerForm.GUPPY);
-     * ```
+     * Note that this will filter out non-real collectibles like Lilith's Incubus.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getCollectiblesForTransformation(playerForm: PlayerForm): ReadonlySet<CollectibleType>;
+    getPlayerCollectibleMap(player: EntityPlayer): Map<CollectibleType, int>;
     /**
-     * Returns a set containing every collectible type with the given cache flag, including modded
-     * collectibles.
+     * Returns an array containing every modded trinket type in the game.
      *
-     * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
+     * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
+     * then use the `getModdedTrinketTypesSet` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all trinket types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getCollectiblesWithCacheFlag(cacheFlag: CacheFlag): ReadonlySet<CollectibleType>;
+    getTrinketTypes(): readonly TrinketType[];
     /**
-     * Returns a set containing every collectible type with the given tag.
-     *
-     * For example, to get all of the collectible types that count as offensive for the purposes of
-     * Tainted Lost:
+     * Returns a set containing every modded trinket type in the game.
      *
-     * ```ts
-     * const offensiveCollectibleTypes = getCollectibleTypesWithTag(ItemConfigTag.OFFENSIVE);
-     * ```
+     * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
+     * then use the `getModdedTrinketTypes` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all trinket types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getCollectiblesWithTag(itemConfigTag: ItemConfigTag): ReadonlySet<CollectibleType>;
+    getTrinketTypesSet(): ReadonlySet<TrinketType>;
     /**
-     * Returns a set containing every valid passive item that can be randomly granted to Eden as a
-     * starting item.
+     * Returns an array containing every modded trinket type in the game.
+     *
+     * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
+     * then use the `getModdedTrinketTypesSet` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all trinket types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getEdenActiveCollectibles(): ReadonlySet<CollectibleType>;
+    getModdedTrinketTypes(): readonly TrinketType[];
     /**
-     * Returns a set containing every valid passive item that can be randomly granted to Eden as a
-     * starting item.
+     * Returns a set containing every modded trinket type in the game.
+     *
+     * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
+     * then use the `getModdedTrinketTypes` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all trinket types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getEdenPassiveCollectibles(): ReadonlySet<CollectibleType>;
+    getModdedTrinketTypesSet(): ReadonlySet<TrinketType>;
     /**
-     * Returns a set of all of the collectibles that grant flight. This is derived from collectibles
-     * that have `CacheFlag.FLYING` set in the "items.xml" file.
+     * Returns an array containing every valid card type in the game, including modded cards.
      *
-     * Collectibles that only grant flight conditionally are manually pruned. Collectibles such as
-     * Empty Vessel should be checked for via the `hasFlyingTemporaryEffect` function.
+     * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
+     * use the `getCardTypesSet` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
-     * order).
+     * not all card types will necessarily be present when a mod first loads (due to mod load order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     *
-     * @param includeConditionalItems Whether collectibles that only grant flight conditionally should
-     *                                be included in the set (like Empty Vessel).
      */
-    getFlyingCollectibles(includeConditionalItems: boolean): ReadonlySet<CollectibleType>;
+    getCardTypes(): readonly CardType[];
     /**
-     * Returns a set of all of the trinkets that grant flight. (All trinkets that grant flight do so
-     * conditionally, like Bat Wing and Azazel's Stump.)
+     * Returns a set containing every valid card type in the game, including modded cards.
+     *
+     * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
+     * use the `getCardTypes` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
+     * not all card types will necessarily be present when a mod first loads (due to mod load order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getFlyingTrinkets(): ReadonlySet<TrinketType>;
+    getCardTypesSet(): ReadonlySet<CardType>;
     /**
      * Returns an array containing every modded card type in the game.
      *
      * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
-     * use the `getModdedCardSet` helper function instead.
+     * use the `getModdedCardTypesSet` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
+     * not all card types will necessarily be present when a mod first loads (due to mod load order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getModdedCardArray(): readonly CardType[];
+    getModdedCardTypes(): readonly CardType[];
     /**
      * Returns a set containing every modded card type in the game.
      *
      * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
-     * use the `getModdedCardArray` helper function instead.
+     * use the `getModdedCardTypes` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all cards will necessarily be present when a mod first loads (due to mod load order).
+     * not all card types will necessarily be present when a mod first loads (due to mod load order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getModdedCardSet(): ReadonlySet<CardType>;
+    getModdedCardTypesSet(): ReadonlySet<CardType>;
     /**
-     * Returns an array containing every modded collectible type in the game.
+     * Returns an array containing every valid pill effect in the game, including modded pill effects.
      *
-     * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
-     * then use the `getModdedCollectibleSet` helper function instead.
+     * Use this if you need to iterate over the pill effects in order. If you need to do O(1) lookups,
+     * then use the `getPillEffectSet` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all pill effects will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getModdedCollectibleArray(): readonly CollectibleType[];
+    getPillEffects(): readonly PillEffect[];
     /**
-     * Returns a set containing every modded collectible type in the game.
+     * Returns a set containing every valid pill effect in the game, including modded pill effects.
      *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
-     * then use the `getModdedCollectibleArray` helper function instead.
+     * Use this if you need to do O(1) lookups. If you need to iterate over the pill effects in order,
+     * then use the `getPillEffects` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all pill effects will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getModdedCollectibleSet(): ReadonlySet<CollectibleType>;
+    getPillEffectsSet(): ReadonlySet<PillEffect>;
     /**
-     * Returns an array containing every modded trinket type in the game.
+     * Returns an array containing every modded pill effect in the game.
      *
-     * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
-     * then use the `getModdedTrinketSet` helper function instead.
+     * Use this if you need to iterate over the pill effects in order. If you need to do O(1) lookups,
+     * then use the `getModdedPillEffectsSet` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
+     * not all pill effects will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getModdedTrinketArray(): readonly TrinketType[];
+    getModdedPillEffects(): readonly PillEffect[];
     /**
-     * Returns a set containing every modded trinket type in the game.
+     * Returns a set containing every modded pill effect in the game.
      *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
-     * then use the `getModdedTrinketArray` helper function instead.
+     * Use this if you need to do O(1) lookups. If you need to iterate over the pill effects in order,
+     * then use the `getModdedPillEffects` helper function instead.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
+     * not all pill effects will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getModdedTrinketSet(): ReadonlySet<TrinketType>;
+    getModdedPillEffectsSet(): ReadonlySet<PillEffect>;
     /**
-     * Iterates over every item in the game and returns a map containing the number of each item that
-     * the player has.
+     * Returns a set containing every collectible type with the given cache flag, including modded
+     * collectibles.
      *
-     * Note that this will filter out non-real collectibles like Lilith's Incubus.
+     * This function can only be called if at least one callback has been executed. This is because
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getPlayerCollectibleMap(player: EntityPlayer): Map<CollectibleType, int>;
+    getCollectibleTypesWithCacheFlag(cacheFlag: CacheFlag): ReadonlySet<CollectibleType>;
+    /**
+     * Returns a set containing every trinket type with the given cache flag, including modded
+     * trinkets.
+     *
+     * This function can only be called if at least one callback has been executed. This is because
+     * not all trinket types will necessarily be present when a mod first loads (due to mod load
+     * order).
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+     */
+    getTrinketsTypesWithCacheFlag(cacheFlag: CacheFlag): ReadonlySet<TrinketType>;
     /**
      * Returns an array containing every collectible type that the player has that matches the
      * provided `CacheFlag`.
@@ -315,186 +316,225 @@ export declare class ModdedElementSets extends Feature {
      * Lilith's Incubus.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
     getPlayerCollectiblesWithCacheFlag(player: EntityPlayer, cacheFlag: CacheFlag): CollectibleType[];
-    /**
-     * Returns the number of items that a player has towards a particular transformation.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getPlayerCollectiblesWithTag(player: EntityPlayer, itemConfigTag: ItemConfigTag): CollectibleType[];
-    /**
-     * Returns the number of items that a player has towards a particular transformation.
-     *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-     */
-    getPlayerCollectiblesForTransformation(player: EntityPlayer, playerForm: PlayerForm): CollectibleType[];
     /**
      * Returns a map containing every trinket type that the player has that matches the provided
      * `CacheFlag`. The values of the map correspond to the multiplier for that trinket.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
+     * not all trinket types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
     getPlayerTrinketsWithCacheFlag(player: EntityPlayer, cacheFlag: CacheFlag): Map<TrinketType, int>;
     /**
-     * Has an equal chance of returning any card (e.g. Fool, Reverse Fool, Wild Card, etc.).
+     * Returns a set of all of the collectibles that grant flight. This is derived from collectibles
+     * that have `CacheFlag.FLYING` set in the "items.xml" file.
      *
-     * This will not return:
-     * - any runes
-     * - any objects like Dice Shard
+     * Vanilla collectibles that only grant flight conditionally are manually pruned. Collectibles
+     * such as Empty Vessel should be checked for via the `hasFlyingTemporaryEffect` function.
+     *
+     * Under the hood, this is determined by looking at the collectibles that have `CacheFlag.FLYING`
+     * and excluding the ones that have `CacheFlag.ALL`. (None of the collectibles with
+     * `CacheFlag.ALL` grant flying, including all of the 3 Dollar Bill collectibles and all of the
+     * Birthright effects.)
+     *
+     * This function can only be called if at least one callback has been executed. This is because
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * 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 exceptions Optional. An array of cards to not select.
+     * @param includeConditionalItems Whether collectibles that only grant flight conditionally should
+     *                                be included in the set (like Empty Vessel).
      */
-    getRandomCard(seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
+    getFlyingCollectibleTypes(includeConditionalItems: boolean): ReadonlySet<CollectibleType>;
     /**
-     * Helper function to get a random card type that matches the provided `ItemConfigCardType`.
+     * Returns a set of all of the trinkets that grant flight. (All vanilla trinkets that grant flight
+     * do so conditionally, like Bat Wing and Azazel's Stump.)
      *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+     * Under the hood, this is determined by looking at the trinkets that have `CacheFlag.FLYING` and
+     * excluding the ones that have `CacheFlag.ALL`. (None of the trinket with `CacheFlag.ALL` grant
+     * flying except for Azazel's Stump.)
      *
-     * @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 exceptions Optional. An array of cards to not select.
+     * This function can only be called if at least one callback has been executed. This is because
+     * not all trinket types will necessarily be present when a mod first loads (due to mod load
+     * order).
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getRandomCardTypeOfType(itemConfigCardType: ItemConfigCardType, seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
+    getFlyingTrinketTypes(): ReadonlySet<TrinketType>;
     /**
-     * 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.
+     * Returns a set containing every collectible type with the given tag.
      *
-     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+     * For example, to get all of the collectible types that count as offensive for the purposes of
+     * Tainted Lost:
      *
-     * @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 exceptions Optional. An array of runes to not select.
+     * ```ts
+     * const offensiveCollectibleTypes = getCollectibleTypesWithTag(ItemConfigTag.OFFENSIVE);
+     * ```
+     *
+     * This function can only be called if at least one callback has been executed. This is because
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getRandomRune(seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
+    getCollectibleTypesWithTag(itemConfigTag: ItemConfigTag): ReadonlySet<CollectibleType>;
     /**
-     * Returns a random active collectible type that that is a valid starting item for Eden.
+     * Returns the number of items that a player has towards a particular transformation.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * 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 exceptions Optional. An array of runes to not select.
      */
-    getRandomEdenActiveCollectible(seedOrRNG?: Seed | RNG, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
+    getPlayerCollectiblesWithTag(player: EntityPlayer, itemConfigTag: ItemConfigTag): CollectibleType[];
     /**
-     * Returns a random passive collectible type that that is a valid starting item for Eden.
+     * Helper function to get all of the collectible types in the game that count towards a particular
+     * transformation.
+     *
+     * For example, to get all of the collectible types that count towards Guppy:
+     *
+     * ```ts
+     * const guppyCollectibleTypes = getCollectiblesForTransformation(PlayerForm.GUPPY);
+     * ```
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all collectibles will necessarily be present when a mod first loads (due to mod load
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
      * order).
      *
      * 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 exceptions Optional. An array of runes to not select.
      */
-    getRandomEdenPassiveCollectible(seedOrRNG?: Seed | RNG, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
+    getCollectibleTypesForTransformation(playerForm: PlayerForm): ReadonlySet<CollectibleType>;
     /**
-     * Returns an array containing every modded trinket type in the game.
-     *
-     * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
-     * then use the `getModdedTrinketSet` helper function instead.
+     * Returns the number of items that a player has towards a particular transformation.
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getTrinketArray(): readonly TrinketType[];
+    getPlayerCollectiblesForTransformation(player: EntityPlayer, playerForm: PlayerForm): CollectibleType[];
     /**
-     * Returns a set containing every modded trinket type in the game.
+     * Returns a set containing every valid passive item that can be randomly granted to Eden as a
+     * starting item.
      *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
-     * then use the `getModdedTrinketArray` helper function instead.
+     * Under the hood, this is determined by looking at the "noeden" tag in "items_metadata.xml".
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getTrinketSet(): ReadonlySet<TrinketType>;
+    getEdenActiveCollectibleTypes(): ReadonlySet<CollectibleType>;
     /**
-     * Returns a set containing every trinket type with the given cache flag, including modded
-     * trinkets.
+     * Returns a set containing every valid passive item that can be randomly granted to Eden as a
+     * starting item.
+     *
+     * Under the hood, this is determined by looking at the "noeden" tag in "items_metadata.xml".
      *
      * This function can only be called if at least one callback has been executed. This is because
-     * not all trinkets will necessarily be present when a mod first loads (due to mod load order).
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getTrinketsWithCacheFlag(cacheFlag: CacheFlag): ReadonlySet<TrinketType>;
+    getEdenPassiveCollectibleTypes(): ReadonlySet<CollectibleType>;
     /**
-     * Returns an array containing every valid vanilla card type in the game.
+     * Returns a random active collectible type that that is a valid starting item for Eden.
      *
-     * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
-     * use the `getVanillaCardSet` helper function instead.
+     * This function can only be called if at least one callback has been executed. This is because
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * 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 exceptions Optional. An array of runes to not select.
      */
-    getVanillaCardArray(): readonly CardType[];
+    getRandomEdenActiveCollectibleType(seedOrRNG?: Seed | RNG, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
     /**
-     * Returns a set containing every valid vanilla card type in the game.
+     * Returns a random passive collectible type that that is a valid starting item for Eden.
      *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
-     * use the `getVanillaCardArray` helper function instead.
+     * This function can only be called if at least one callback has been executed. This is because
+     * not all collectible types will necessarily be present when a mod first loads (due to mod load
+     * order).
      *
      * 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 exceptions Optional. An array of runes to not select.
      */
-    getVanillaCardSet(): ReadonlySet<CardType>;
+    getRandomEdenPassiveCollectibleType(seedOrRNG?: Seed | RNG, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;
     /**
-     * Returns an array containing every valid vanilla collectible type in the game.
+     * Helper function to get a set of card types matching the `ItemConfigCardType`.
      *
-     * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
-     * then use the `getVanillaCollectibleSet` helper function instead.
+     * This function is variadic, meaning that you can you can specify N card types to get a set
+     * containing cards that match any of the specified types.
+     *
+     * 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).
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
      */
-    getVanillaCollectibleArray(): readonly CollectibleType[];
+    getCardTypesOfType(...itemConfigCardTypes: ItemConfigCardType[]): Set<CardType>;
     /**
-     * Returns a set containing every valid vanilla collectible type in the game.
+     * Helper function to get a random card type that matches the provided `ItemConfigCardType`.
      *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
-     * then use the `getVanillaCollectibleArray` helper function instead.
+     * 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).
      *
      * 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 exceptions Optional. An array of cards to not select.
      */
-    getVanillaCollectibleSet(): ReadonlySet<CollectibleType>;
+    getRandomCardTypeOfType(itemConfigCardType: ItemConfigCardType, seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
     /**
-     * Returns an array containing every valid vanilla trinket type in the game.
+     * Has an equal chance of returning any card (e.g. Fool, Reverse Fool, Wild Card, etc.).
      *
-     * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
-     * then use the `getVanillaTrinketSet` helper function instead.
+     * This will not return:
+     * - any runes
+     * - any objects like Dice Shard
+     *
+     * 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).
      *
      * 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 exceptions Optional. An array of cards to not select.
      */
-    getVanillaTrinketArray(): readonly TrinketType[];
+    getRandomCard(seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
     /**
-     * Returns a set containing every valid vanilla trinket type in the game.
+     * 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.
      *
-     * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
-     * then use the `getVanillaTrinketArray` helper function instead.
+     * 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).
      *
      * 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 exceptions Optional. An array of runes to not select.
      */
-    getVanillaTrinketSet(): ReadonlySet<TrinketType>;
+    getRandomRune(seedOrRNG?: Seed | RNG, exceptions?: CardType[]): CardType;
 }
 //# sourceMappingURL=ModdedElementSets.d.ts.map