isaacscript-common 40.0.0 → 41.0.0

package/dist/index.rollup.d.ts

@@ -949,6 +949,12 @@ export declare function addTrinketCostume(player: EntityPlayer, trinketType: Tri
 export declare const ALL_DISPLAY_FLAGS: BitFlags<number & {
     readonly __bitFlagBrand: symbol;
 } & {
+    /**
+     * The combination of the following flags:
+     * - `DisplayFlag.VISIBLE` (1 << 0)
+     * - `DisplayFlag.SHADOW` (1 << 1)
+     * - `DisplayFlag.SHOW_ICON` (1 << 2)
+     */
     readonly __displayFlagBrand: symbol;
 }>;
 
@@ -3584,6 +3590,12 @@ export declare function deserializeVector(vector: SerializedVector): Vector;
 /** For `EntityType.EFFECT` (1000), `EffectVariant.DICE_FLOOR` (76). */
 export declare const DICE_FLOOR_TRIGGER_SQUARE_SIZE = 75;
 
+/**
+ * An array containing every valid `Dimension`, not including `Dimension.CURRENT`. (This is derived
+ * from the `NUM_DIMENSIONS` constant.)
+ */
+export declare const DIMENSIONS: readonly Dimension[];
+
 /**
  * Helper function to convert a direction to degrees. For example, `Direction.LEFT` (0) would return
  * 180 and `Direction.RIGHT` (2) would return 0. (This corresponds to how the
@@ -4695,11 +4707,6 @@ export declare function getAliveNPCs(entityType?: EntityType | -1, variant?: num
  */
 export declare function getAllBossesSet(includeStoryBosses?: boolean): ReadonlySet<string>;
 
-/**
- * Helper function to get an array with every valid `Dimension` (not including `Dimension.CURRENT`).
- */
-export declare function getAllDimensions(): Dimension[];
-
 /**
  * Helper function to get every legal grid index for the current room.
  *
@@ -7510,38 +7517,6 @@ export declare function getUnusedDoorSlots(): DoorSlot[];
  */
 export declare function getUsableActiveItemSlots(player: EntityPlayer, collectibleType: CollectibleType): ActiveSlot[];
 
-/**
- * Helper function to get an array with every valid vanilla card sub-type.
- *
- * Note that unlike collectibles and trinkets, there are no gaps in the card types, so this is a
- * simple range from the first card type to the last vanilla card type.
- */
-export declare function getVanillaCardTypes(): CardType[];
-
-/**
- * Helper function to get an array that represents the range from the first collectible type to the
- * last vanilla collectible type. This will include integers that do not represent any valid
- * collectible types.
- *
- * This function is only useful when building collectible type objects. For most purposes, you
- * should use the `getVanillaCollectibleArray` or `getVanillaCollectibleSet` helper functions
- * instead (which are part of `ISCFeature.MODDED_ELEMENT_SETS`).
- */
-export declare function getVanillaCollectibleTypeRange(): CollectibleType[];
-
-/** Helper function to get an array with every vanilla pill effect. */
-export declare function getVanillaPillEffects(): PillEffect[];
-
-/**
- * Helper function to get an array that represents the range from the first trinket type to the last
- * vanilla trinket type. This will include integers that do not represent any valid trinket types.
- *
- * This function is only useful when building collectible type objects. For most purposes, you
- * should use the `getVanillaTrinketArray` or `getVanillaTrinketSet` helper functions instead (which
- * are part of `ISCFeature.MODDED_ELEMENT_SETS`).
- */
-export declare function getVanillaTrinketTypeRange(): TrinketType[];
-
 /**
  * Get how many hearts are currently being shown on the hearts UI.
  *
@@ -12765,27 +12740,6 @@ declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getLastCollectibleType(): CollectibleType;
-    /**
-     * Helper function to get an array that represents every modded collectible type.
-     *
-     * Returns an empty array if there are no modded collectible types.
-     *
-     * This function is only useful when building collectible type objects. For most purposes, you
-     * should use the `getModdedCollectibleArray` or `getModdedCollectibleSet` helper function
-     * instead.
-     *
-     * (This function is named differently from the `getVanillaCollectibleTypeRange` function because
-     * all modded collectible types are contiguous. Thus, each value represents a real
-     * `CollectibleType`.)
-     *
-     * 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).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getModdedCollectibleTypes(): CollectibleType[];
     /**
      * Returns the total number of collectibles in the item config, including both vanilla and modded
      * items. If you just need the number of vanilla collectible types, use the
@@ -12836,24 +12790,6 @@ declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getLastTrinketType(): TrinketType;
-    /**
-     * Helper function to get an array that represents every modded trinket type.
-     *
-     * Returns an empty array if there are no modded trinket types.
-     *
-     * This function is only useful when building trinket type objects. For most purposes, you should
-     * use the `getModdedTrinketArray` or `getModdedTrinketSet` helper function instead.
-     *
-     * (This function is named differently from the `getVanillaTrinketTypeRange` function because all
-     * modded trinket types are contiguous. Thus, each value represents a real `TrinketType`.)
-     *
-     * 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).
-     *
-     * In order to use this function, you must upgrade your mod with
-     * `ISCFeature.MODDED_ELEMENT_DETECTION`.
-     */
-    getModdedTrinketTypes(): TrinketType[];
     /**
      * Returns the total number of trinkets in the item config, including both vanilla and modded
      * items. If you just need the number of vanilla trinket types, use the
@@ -12876,16 +12812,6 @@ declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getNumModdedTrinketTypes(): int;
-    /**
-     * Helper function to get an array with every valid card sub-type. This includes modded cards.
-     *
-     * 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_DETECTION`.
-     */
-    getAllCardTypes(): CardType[];
     /**
      * Returns the first modded card sub-type, or undefined if there are no modded cards.
      *
@@ -12909,18 +12835,6 @@ declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getLastCardType(): CardType;
-    /**
-     * Helper function to get an array with every modded card sub-type.
-     *
-     * Returns an empty array if there are no modded cards.
-     *
-     * 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_DETECTION`.
-     */
-    getModdedCardTypes(): CardType[];
     /**
      * Will change depending on how many modded cards there are.
      *
@@ -12941,18 +12855,6 @@ declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getNumModdedCardTypes(): int;
-    /**
-     * Helper function to get an array with every valid pill effect. This includes modded pill
-     * effects.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * 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_DETECTION`.
-     */
-    getAllPillEffects(): PillEffect[];
     /**
      * Returns the first modded pill effect, or undefined if there are no modded pill effects.
      *
@@ -12978,19 +12880,6 @@ declare class ModdedElementDetection extends Feature {
      * `ISCFeature.MODDED_ELEMENT_DETECTION`.
      */
     getLastPillEffect(): PillEffect;
-    /**
-     * Helper function to get an array with every modded pill effect.
-     *
-     * Returns an empty array if there are no modded pill effects.
-     *
-     * This function can only be called if at least one callback has been executed. This is because
-     * 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_DETECTION`.
-     */
-    getModdedPillEffects(): PillEffect[];
     /**
      * Will change depending on how many modded pill effects there are.
      *
@@ -13016,37 +12905,43 @@ declare class ModdedElementDetection extends Feature {
     getNumModdedPillEffects(): int;
 }
 
+/**
+ * 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`.
+ */
 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
@@ -13054,12 +12949,10 @@ 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;
@@ -13068,250 +12961,246 @@ 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.
+     * Iterates over every collectible in the game and returns a map containing the number of each
+     * item that the player has.
      *
-     * For example, to get all of the collectible types that count towards Guppy:
-     *
-     * ```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`.
@@ -13331,187 +13220,226 @@ 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;
 }
 
 /**
@@ -13889,6 +13817,10 @@ declare class NoSirenSteal extends Feature {
     setFamiliarNoSirenSteal(familiarVariant: FamiliarVariant, familiarSubType?: int): void;
 }
 
+/**
+ * The number of dimensions, not including `Dimension.CURRENT`. (This is derived from the
+ * `Dimension` enum.)
+ */
 export declare const NUM_DIMENSIONS: number;
 
 export declare const NUM_NORMAL_PILL_COLORS: number;
@@ -13897,7 +13829,7 @@ export declare const NUM_NORMAL_PILL_COLORS: number;
  * The pill pool for each run is comprised of one effect for each unique pill color (minus gold and
  * horse pills.)
  */
-export declare const NUM_PILLS_IN_POOL: number;
+export declare const NUM_PILL_COLORS_IN_POOL: number;
 
 /** Calculated from the `Card` enum. `Card.NULL` is not included. */
 export declare const NUM_VANILLA_CARD_TYPES: number;
@@ -17751,6 +17683,104 @@ export declare function validateEnumContiguous<T>(transpiledEnumName: string, tr
  */
 export declare function validateInterfaceMatchesEnum<T extends Record<Enum, unknown>, Enum extends string | number>(): void;
 
+/**
+ * An array that represents the range from the first vanilla card type to the last vanilla card
+ * type.
+ *
+ * This function is only useful when building card type objects. For most purposes, you should use
+ * the `VANILLA_CARD_TYPES` or `VANILLA_CARD_TYPES_SET` constants instead.
+ */
+export declare const VANILLA_CARD_TYPE_RANGE: readonly int[];
+
+/**
+ * An array that contains every valid vanilla card type, as verified by the `ItemConfig.GetCard`
+ * method. Vanilla card types are contiguous, but we validate every entry to double check.
+ *
+ * If you need to do O(1) lookups, use the `VANILLA_CARD_TYPES_SET` constant instead.
+ */
+export declare const VANILLA_CARD_TYPES: readonly CardType[];
+
+/**
+ * A set that contains every valid vanilla card type, as verified by the `ItemConfig.GetCard`
+ * method. Vanilla card types are contiguous, but we validate every entry to double check.
+ */
+export declare const VANILLA_CARD_TYPES_SET: ReadonlySet<CardType>;
+
+/**
+ * An array that represents the range from the first vanilla collectible type to the last vanilla
+ * collectible type. This will include integers that do not represent any valid collectible types.
+ *
+ * This function is only useful when building collectible type objects. For most purposes, you
+ * should use the `VANILLA_COLLECTIBLE_TYPES` or `VANILLA_COLLECTIBLE_TYPES_SET` constants instead.
+ */
+export declare const VANILLA_COLLECTIBLE_TYPE_RANGE: readonly int[];
+
+/**
+ * An array that contains every valid vanilla collectible type, as verified by the
+ * `ItemConfig.GetCollectible` method. Vanilla collectible types are not contiguous, so every valid
+ * must be verified. (There are several gaps, e.g. 666.)
+ *
+ * If you need to do O(1) lookups, use the `VANILLA_COLLECTIBLE_TYPES_SET` constant instead.
+ */
+export declare const VANILLA_COLLECTIBLE_TYPES: readonly CollectibleType[];
+
+/**
+ * A set that contains every valid vanilla collectible type, as verified by the
+ * `ItemConfig.GetCollectible` method. Vanilla collectible types are not contiguous, so every valid
+ * must be verified. (There are several gaps, e.g. 666.)
+ */
+export declare const VANILLA_COLLECTIBLE_TYPES_SET: ReadonlySet<CollectibleType>;
+
+/**
+ * An array that represents the range from the first vanilla pill effect to the last vanilla pill
+ * effect.
+ *
+ * This function is only useful when building pill effect objects. For most purposes, you should use
+ * the `VANILLA_PILL_EFFECTS` or `VANILLA_PILL_EFFECTS_SET` constants instead.
+ */
+export declare const VANILLA_PILL_EFFECT_RANGE: readonly int[];
+
+/**
+ * An array that contains every valid vanilla pill effect, as verified by the
+ * `ItemConfig.GetPillEffect` method. Vanilla pill effects are contiguous, but we validate every
+ * entry to double check.
+ *
+ * If you need to do O(1) lookups, use the `VANILLA_PILL_EFFECT_SET` constant instead.
+ */
+export declare const VANILLA_PILL_EFFECTS: readonly PillEffect[];
+
+/**
+ * A set that contains every valid vanilla pill effect, as verified by the
+ * `ItemConfig.GetPillEffect` method. Vanilla pill effects are contiguous, but we validate every
+ * entry to double check.
+ */
+export declare const VANILLA_PILL_EFFECTS_SET: ReadonlySet<PillEffect>;
+
+/**
+ * An array that represents the range from the first vanilla trinket type to the last vanilla
+ * trinket type. This will include integers that do not represent any valid trinket types.
+ *
+ * This function is only useful when building trinket type objects. For most purposes, you should
+ * use the `VANILLA_TRINKET_TYPES` or `VANILLA_TRINKET_TYPES_SET` constants instead.
+ */
+export declare const VANILLA_TRINKET_TYPE_RANGE: readonly int[];
+
+/**
+ * An array that contains every valid vanilla trinket type, as verified by the
+ * `ItemConfig.GetTrinket` method. Vanilla trinket types are not contiguous, so every valid must be
+ * verified. (The only gap is 47 for `POLAROID_OBSOLETE`.)
+ *
+ * If you need to do O(1) lookups, use the `VANILLA_TRINKET_TYPES_SET` constant instead.
+ */
+export declare const VANILLA_TRINKET_TYPES: readonly TrinketType[];
+
+/**
+ * A set that contains every valid vanilla trinket type, as verified by the `ItemConfig.GetTrinket`
+ * method. Vanilla trinket types are not contiguous, so every valid must be verified. (The only gap
+ * is 47 for `POLAROID_OBSOLETE`.)
+ */
+export declare const VANILLA_TRINKET_TYPES_SET: ReadonlySet<TrinketType>;
+
 /**
  * Helper function to compare two vectors for equality.
  *