isaacscript-common 14.2.0 → 15.0.0

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

@@ -0,0 +1,223 @@
+import { CardType, CollectibleType, PillEffect, TrinketType } from "isaac-typescript-definitions";
+import { Feature } from "../../private/Feature";
+/**
+ * Mods can add extra things to the game (e.g. collectibles, trinkets, and so on). Since mods load
+ * in alphabetical order, the total number of things can't be properly be known until at least one
+ * callback fires (which indicates that all mods have been loaded).
+ *
+ * This feature gates all such functions behind a callback check. Subsequently, these functions will
+ * throw a runtime error if they are called in the menu, before any callbacks have occurred. This
+ * ensures that the proper values are always returned and allows you to get immediate feedback if
+ * you accidentally access them from the menu.
+ */
+export declare class ModdedElementDetection extends Feature {
+    private atLeastOneCallbackFired;
+    private postPlayerInit;
+    private errorIfNoCallbacksFired;
+    /**
+     * Returns the first modded collectible type, or undefined if there are no modded collectibles.
+     *
+     * 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).
+     */
+    getFirstModdedCollectibleType(): CollectibleType | undefined;
+    /**
+     * Will change depending on how many modded collectibles there are.
+     *
+     * Equal to `itemConfig.GetCollectibles().Size - 1`. (`Size` includes invalid collectibles, like
+     * 666. We subtract one to account for `CollectibleType.NULL`.)
+     *
+     * 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).
+     */
+    getLastCollectibleType(): CollectibleType;
+    /**
+     * Helper function to get an array that represents the all modded collectible types.
+     *
+     * 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).
+     */
+    getModdedCollectibleTypes(): 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).
+     */
+    getNumCollectibleTypes(): int;
+    /**
+     * Unlike vanilla collectible types, modded collectible types are always contiguous.
+     *
+     * 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).
+     */
+    getNumModdedCollectibleTypes(): int;
+    /**
+     * Returns the first modded trinket type, or undefined if there are no modded trinkets.
+     *
+     * 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).
+     */
+    getFirstModdedTrinketType(): TrinketType | undefined;
+    /**
+     * Will change depending on how many modded trinkets there are.
+     *
+     * This is equal to the number of trinket types, since all trinket types are contiguous (unlike
+     * collectibles).
+     *
+     * 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).
+     */
+    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 collectible type objects. For most purposes, you
+     * should use the `getModdedCollectibleArray` or `getModdedCollectibleSet` 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).
+     */
+    getModdedTrinketTypes(): TrinketType[];
+    /**
+     * Will change depending on how many modded trinkets there are.
+     *
+     * Equal to `itemConfig.GetTrinkets().Size - 1`. (We subtract one to account for
+     * `TrinketType.NULL`.)
+     *
+     * 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).
+     */
+    getNumTrinketTypes(): int;
+    /**
+     * 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).
+     */
+    getNumModdedTrinketTypes(): int;
+    /**
+     * Helper function to get an array that contains every trinket type.
+     *
+     * 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).
+     */
+    getTrinketTypes(): TrinketType[];
+    /**
+     * 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).
+     */
+    getAllCardTypes(): CardType[];
+    /**
+     * Returns the first modded card sub-type, or undefined 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).
+     */
+    getFirstModdedCardType(): CardType | undefined;
+    /**
+     * Will change depending on how many modded cards there are.
+     *
+     * This is equal to the number of cards, since all card sub-types are contiguous (unlike
+     * collectibles).
+     *
+     * 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).
+     */
+    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).
+     */
+    getModdedCardTypes(): CardType[];
+    /**
+     * Will change depending on how many modded cards there are.
+     *
+     * Equal to `itemConfig.GetCards().Size - 1`. (We subtract one to account for `Card.NULL`.)
+     *
+     * 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).
+     */
+    getNumCardTypes(): int;
+    /**
+     * 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).
+     */
+    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).
+     */
+    getAllPillEffects(): PillEffect[];
+    /**
+     * Returns the first modded pill effect, or undefined 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).
+     */
+    getFirstModdedPillEffect(): PillEffect | undefined;
+    /**
+     * Will change depending on how many modded pill effects there are.
+     *
+     * This is equal to the number of pill effects, since all pill effects are contiguous (unlike
+     * collectibles).
+     *
+     * 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).
+     */
+    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).
+     */
+    getModdedPillEffects(): PillEffect[];
+    /**
+     * Will change depending on how many modded pill effects there are.
+     *
+     * Equal to `itemConfig.GetPillEffects().Size`. (We do not have to subtract one, because the first
+     * pill effect has an ID of 0 and there is no `PillEffect.NULL`.)
+     *
+     * 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).
+     */
+    getNumPillEffects(): int;
+    /**
+     * 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).
+     */
+    getNumModdedPillEffects(): int;
+}
+//# sourceMappingURL=ModdedElementDetection.d.ts.map

package/dist/src/classes/features/other/ModdedElementDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModdedElementDetection.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/ModdedElementDetection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,eAAe,EAEf,UAAU,EACV,WAAW,EACZ,MAAM,8BAA8B,CAAC;AAwBtC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD;;;;;;;;;GASG;AACH,qBAAa,sBAAuB,SAAQ,OAAO;IACjD,OAAO,CAAC,uBAAuB,CAAS;IAYxC,OAAO,CAAC,cAAc,CAEpB;IAEF,OAAO,CAAC,uBAAuB;IAY/B;;;;;;OAMG;IAEI,6BAA6B,IAAI,eAAe,GAAG,SAAS;IAcnE;;;;;;;;;OASG;IAEI,sBAAsB,IAAI,eAAe;IAMhD;;;;;;;;;;;;;;;;OAgBG;IAEI,yBAAyB,IAAI,eAAe,EAAE;IAYrD;;;;OAIG;IAEI,sBAAsB,IAAI,GAAG;IAOpC;;;;;;OAMG;IAEI,4BAA4B,IAAI,GAAG;IAW1C;;;;;OAKG;IAEI,yBAAyB,IAAI,WAAW,GAAG,SAAS;IAU3D;;;;;;;;OAQG;IAEI,kBAAkB,IAAI,WAAW;IAOxC;;;;;;;;;;;OAWG;IAEI,qBAAqB,IAAI,WAAW,EAAE;IAY7C;;;;;;;;OAQG;IAEI,kBAAkB,IAAI,GAAG;IAMhC;;;OAGG;IAEI,wBAAwB,IAAI,GAAG;IAOtC;;;;;OAKG;IAEI,eAAe,IAAI,WAAW,EAAE;IAWvC;;;;;OAKG;IAEI,eAAe,IAAI,QAAQ,EAAE;IAOpC;;;;;OAKG;IAEI,sBAAsB,IAAI,QAAQ,GAAG,SAAS;IAUrD;;;;;;;;OAQG;IAEI,eAAe,IAAI,QAAQ;IAOlC;;;;;;;OAOG;IAEI,kBAAkB,IAAI,QAAQ,EAAE;IAYvC;;;;;;;OAOG;IAEI,eAAe,IAAI,GAAG;IAM7B;;;OAGG;IAEI,qBAAqB,IAAI,GAAG;IAWnC;;;;;;;OAOG;IAEI,iBAAiB,IAAI,UAAU,EAAE;IAOxC;;;;;;OAMG;IAEI,wBAAwB,IAAI,UAAU,GAAG,SAAS;IAczD;;;;;;;;;OASG;IAEI,iBAAiB,IAAI,UAAU;IAOtC;;;;;;;;OAQG;IAEI,oBAAoB,IAAI,UAAU,EAAE;IAY3C;;;;;;;;;OASG;IAEI,iBAAiB,IAAI,GAAG;IAM/B;;;;OAIG;IAEI,uBAAuB,IAAI,GAAG;CAMtC"}

package/dist/src/classes/features/other/ModdedElementDetection.lua

@@ -0,0 +1,249 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__Decorate = ____lualib.__TS__Decorate
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____cachedClasses = require("src.core.cachedClasses")
+local itemConfig = ____cachedClasses.itemConfig
+local ____constantsFirstLast = require("src.core.constantsFirstLast")
+local FIRST_CARD_TYPE = ____constantsFirstLast.FIRST_CARD_TYPE
+local FIRST_PILL_EFFECT = ____constantsFirstLast.FIRST_PILL_EFFECT
+local FIRST_TRINKET_TYPE = ____constantsFirstLast.FIRST_TRINKET_TYPE
+local LAST_VANILLA_CARD_TYPE = ____constantsFirstLast.LAST_VANILLA_CARD_TYPE
+local LAST_VANILLA_COLLECTIBLE_TYPE = ____constantsFirstLast.LAST_VANILLA_COLLECTIBLE_TYPE
+local LAST_VANILLA_PILL_EFFECT = ____constantsFirstLast.LAST_VANILLA_PILL_EFFECT
+local LAST_VANILLA_TRINKET_TYPE = ____constantsFirstLast.LAST_VANILLA_TRINKET_TYPE
+local NUM_VANILLA_CARD_TYPES = ____constantsFirstLast.NUM_VANILLA_CARD_TYPES
+local NUM_VANILLA_COLLECTIBLE_TYPES = ____constantsFirstLast.NUM_VANILLA_COLLECTIBLE_TYPES
+local NUM_VANILLA_PILL_EFFECTS = ____constantsFirstLast.NUM_VANILLA_PILL_EFFECTS
+local NUM_VANILLA_TRINKET_TYPES = ____constantsFirstLast.NUM_VANILLA_TRINKET_TYPES
+local ____decorators = require("src.decorators")
+local Exported = ____decorators.Exported
+local ____types = require("src.functions.types")
+local asCardType = ____types.asCardType
+local asCollectibleType = ____types.asCollectibleType
+local asNumber = ____types.asNumber
+local asPillEffect = ____types.asPillEffect
+local asTrinketType = ____types.asTrinketType
+local ____utils = require("src.functions.utils")
+local iRange = ____utils.iRange
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+--- Mods can add extra things to the game (e.g. collectibles, trinkets, and so on). Since mods load
+-- in alphabetical order, the total number of things can't be properly be known until at least one
+-- callback fires (which indicates that all mods have been loaded).
+-- 
+-- This feature gates all such functions behind a callback check. Subsequently, these functions will
+-- throw a runtime error if they are called in the menu, before any callbacks have occurred. This
+-- ensures that the proper values are always returned and allows you to get immediate feedback if
+-- you accidentally access them from the menu.
+____exports.ModdedElementDetection = __TS__Class()
+local ModdedElementDetection = ____exports.ModdedElementDetection
+ModdedElementDetection.name = "ModdedElementDetection"
+__TS__ClassExtends(ModdedElementDetection, Feature)
+function ModdedElementDetection.prototype.____constructor(self)
+    Feature.prototype.____constructor(self)
+    self.atLeastOneCallbackFired = false
+    self.postPlayerInit = function(____, _player)
+        self.atLeastOneCallbackFired = true
+    end
+    self.callbacksUsed = {{ModCallback.POST_PLAYER_INIT, {self.postPlayerInit}}}
+end
+function ModdedElementDetection.prototype.errorIfNoCallbacksFired(self, constantType)
+    if not self.atLeastOneCallbackFired then
+        error(("Failed to retrieve a " .. constantType) .. " constant. Since not all mods have been loaded yet, any constants of this type will be inaccurate. Thus, you must wait until at least one callback fires before retrieving these types of constants.")
+    end
+end
+function ModdedElementDetection.prototype.getFirstModdedCollectibleType(self)
+    self:errorIfNoCallbacksFired("collectible")
+    local firstModdedCollectibleType = asCollectibleType(
+        nil,
+        asNumber(nil, LAST_VANILLA_COLLECTIBLE_TYPE) + 1
+    )
+    local itemConfigItem = itemConfig:GetCollectible(firstModdedCollectibleType)
+    local ____temp_0
+    if itemConfigItem == nil then
+        ____temp_0 = nil
+    else
+        ____temp_0 = firstModdedCollectibleType
+    end
+    return ____temp_0
+end
+function ModdedElementDetection.prototype.getLastCollectibleType(self)
+    self:errorIfNoCallbacksFired("collectible")
+    return itemConfig:GetCollectibles().Size - 1
+end
+function ModdedElementDetection.prototype.getModdedCollectibleTypes(self)
+    self:errorIfNoCallbacksFired("collectible")
+    local firstModdedCollectibleType = self:getFirstModdedCollectibleType()
+    if firstModdedCollectibleType == nil then
+        return {}
+    end
+    local lastCollectibleType = self:getLastCollectibleType()
+    return iRange(nil, firstModdedCollectibleType, lastCollectibleType)
+end
+function ModdedElementDetection.prototype.getNumCollectibleTypes(self)
+    self:errorIfNoCallbacksFired("collectible")
+    local numModdedCollectibleTypes = self:getNumModdedCollectibleTypes()
+    return NUM_VANILLA_COLLECTIBLE_TYPES + numModdedCollectibleTypes
+end
+function ModdedElementDetection.prototype.getNumModdedCollectibleTypes(self)
+    self:errorIfNoCallbacksFired("collectible")
+    local lastCollectibleType = self:getLastCollectibleType()
+    return lastCollectibleType - LAST_VANILLA_COLLECTIBLE_TYPE
+end
+function ModdedElementDetection.prototype.getFirstModdedTrinketType(self)
+    self:errorIfNoCallbacksFired("trinket")
+    local firstModdedTrinketType = asTrinketType(
+        nil,
+        asNumber(nil, LAST_VANILLA_TRINKET_TYPE) + 1
+    )
+    local itemConfigItem = itemConfig:GetTrinket(firstModdedTrinketType)
+    local ____temp_1
+    if itemConfigItem == nil then
+        ____temp_1 = nil
+    else
+        ____temp_1 = firstModdedTrinketType
+    end
+    return ____temp_1
+end
+function ModdedElementDetection.prototype.getLastTrinketType(self)
+    self:errorIfNoCallbacksFired("trinket")
+    local numTrinketTypes = self:getNumTrinketTypes()
+    return asTrinketType(nil, numTrinketTypes)
+end
+function ModdedElementDetection.prototype.getModdedTrinketTypes(self)
+    self:errorIfNoCallbacksFired("trinket")
+    local firstModdedTrinketType = self:getFirstModdedTrinketType()
+    if firstModdedTrinketType == nil then
+        return {}
+    end
+    local lastTrinketType = self:getLastTrinketType()
+    return iRange(nil, firstModdedTrinketType, lastTrinketType)
+end
+function ModdedElementDetection.prototype.getNumTrinketTypes(self)
+    self:errorIfNoCallbacksFired("trinket")
+    return itemConfig:GetTrinkets().Size - 1
+end
+function ModdedElementDetection.prototype.getNumModdedTrinketTypes(self)
+    self:errorIfNoCallbacksFired("trinket")
+    local numTrinketTypes = self:getNumTrinketTypes()
+    return numTrinketTypes - NUM_VANILLA_TRINKET_TYPES
+end
+function ModdedElementDetection.prototype.getTrinketTypes(self)
+    self:errorIfNoCallbacksFired("trinket")
+    local lastTrinketType = self:getLastTrinketType()
+    return iRange(nil, FIRST_TRINKET_TYPE, lastTrinketType)
+end
+function ModdedElementDetection.prototype.getAllCardTypes(self)
+    self:errorIfNoCallbacksFired("card")
+    local lastCardType = self:getLastCardType()
+    return iRange(nil, FIRST_CARD_TYPE, lastCardType)
+end
+function ModdedElementDetection.prototype.getFirstModdedCardType(self)
+    self:errorIfNoCallbacksFired("card")
+    local firstModdedCardType = asCardType(
+        nil,
+        asNumber(nil, LAST_VANILLA_CARD_TYPE) + 1
+    )
+    local itemConfigCard = itemConfig:GetCard(firstModdedCardType)
+    local ____temp_2
+    if itemConfigCard == nil then
+        ____temp_2 = nil
+    else
+        ____temp_2 = firstModdedCardType
+    end
+    return ____temp_2
+end
+function ModdedElementDetection.prototype.getLastCardType(self)
+    self:errorIfNoCallbacksFired("card")
+    local numCards = self:getNumCardTypes()
+    return asCardType(nil, numCards)
+end
+function ModdedElementDetection.prototype.getModdedCardTypes(self)
+    self:errorIfNoCallbacksFired("card")
+    local firstModdedCardType = self:getFirstModdedCardType()
+    if firstModdedCardType == nil then
+        return {}
+    end
+    local lastCardType = self:getLastCardType()
+    return iRange(nil, firstModdedCardType, lastCardType)
+end
+function ModdedElementDetection.prototype.getNumCardTypes(self)
+    self:errorIfNoCallbacksFired("card")
+    return itemConfig:GetCards().Size - 1
+end
+function ModdedElementDetection.prototype.getNumModdedCardTypes(self)
+    self:errorIfNoCallbacksFired("card")
+    local numCardTypes = self:getNumCardTypes()
+    return numCardTypes - NUM_VANILLA_CARD_TYPES
+end
+function ModdedElementDetection.prototype.getAllPillEffects(self)
+    self:errorIfNoCallbacksFired("pill")
+    local lastPillEffect = self:getLastPillEffect()
+    return iRange(nil, FIRST_PILL_EFFECT, lastPillEffect)
+end
+function ModdedElementDetection.prototype.getFirstModdedPillEffect(self)
+    self:errorIfNoCallbacksFired("pill")
+    local firstModdedPillEffect = asPillEffect(
+        nil,
+        asNumber(nil, LAST_VANILLA_PILL_EFFECT) + 1
+    )
+    local itemConfigPillEffect = itemConfig:GetPillEffect(firstModdedPillEffect)
+    local ____temp_3
+    if itemConfigPillEffect == nil then
+        ____temp_3 = nil
+    else
+        ____temp_3 = firstModdedPillEffect
+    end
+    return ____temp_3
+end
+function ModdedElementDetection.prototype.getLastPillEffect(self)
+    self:errorIfNoCallbacksFired("pill")
+    local numPillEffects = self:getNumPillEffects()
+    return asPillEffect(nil, numPillEffects)
+end
+function ModdedElementDetection.prototype.getModdedPillEffects(self)
+    self:errorIfNoCallbacksFired("pill")
+    local firstModdedPillEffect = self:getFirstModdedPillEffect()
+    if firstModdedPillEffect == nil then
+        return {}
+    end
+    local lastPillEffect = self:getLastPillEffect()
+    return iRange(nil, firstModdedPillEffect, lastPillEffect)
+end
+function ModdedElementDetection.prototype.getNumPillEffects(self)
+    self:errorIfNoCallbacksFired("pill")
+    return itemConfig:GetPillEffects().Size
+end
+function ModdedElementDetection.prototype.getNumModdedPillEffects(self)
+    self:errorIfNoCallbacksFired("pill")
+    local numPillEffects = self:getNumPillEffects()
+    return numPillEffects - NUM_VANILLA_PILL_EFFECTS
+end
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getFirstModdedCollectibleType", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getLastCollectibleType", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getModdedCollectibleTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getNumCollectibleTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getNumModdedCollectibleTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getFirstModdedTrinketType", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getLastTrinketType", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getModdedTrinketTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getNumTrinketTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getNumModdedTrinketTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getTrinketTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getAllCardTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getFirstModdedCardType", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getLastCardType", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getModdedCardTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getNumCardTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getNumModdedCardTypes", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getAllPillEffects", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getFirstModdedPillEffect", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getLastPillEffect", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getModdedPillEffects", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getNumPillEffects", true)
+__TS__Decorate({Exported}, ModdedElementDetection.prototype, "getNumModdedPillEffects", true)
+return ____exports