export declare enum ModCallback {
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EntityType` provided.
     *
     * ```ts
     * function postNPCUpdate(npc: EntityNPC): void {}
     * ```
     */
    POST_NPC_UPDATE = 0,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function postUpdate(): void {}
     * ```
     */
    POST_UPDATE = 1,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function postRender(): void {}
     * ```
     */
    POST_RENDER = 2,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `CollectibleType` provided.
     *
     * ```ts
     * function useItem(
     *   collectibleType: CollectibleType,
     *   rng: RNG,
     *   player: EntityPlayer,
     *   useFlags: BitFlags<UseFlag>,
     *   activeSlot: int,
     *   customVarData: int,
     * ):
     *   | boolean
     *   | { Discharge: boolean; Remove: boolean; ShowAnim: boolean }
     *   | undefined;
     * ```
     */
    POST_USE_ITEM = 3,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PlayerType` provided.
     *
     * ```ts
     * function postPEffectUpdate(player: EntityPlayer): void {}
     * ```
     *
     * @deprecated Consider using the `ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED` callback from
     *             `isaacscript-common` instead, since it will fire in the correct order and prevent
     *             bugs relating to data structures not being properly initialized.
     */
    POST_PEFFECT_UPDATE = 4,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `CardType` provided.
     *
     * ```ts
     * function postUseCard(
     *   cardType: CardType,
     *   player: EntityPlayer,
     *   useFlags: BitFlags<UseFlag>,
     * ): void {}
     * ```
     */
    POST_USE_CARD = 5,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `FamiliarVariant` provided.
     *
     * ```ts
     * function postFamiliarUpdate(familiar: EntityFamiliar): void {}
     * ```
     */
    POST_FAMILIAR_UPDATE = 6,
    /**
     * Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
     *
     * - `Position`
     * - `SpawnerEntity`
     * - `SpawnerType`
     * - `SpawnerVariant`
     * - `Velocity`
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `FamiliarVariant` provided.
     *
     * ```ts
     * function postFamiliarInit(familiar: EntityFamiliar): void {}
     * ```
     */
    POST_FAMILIAR_INIT = 7,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `CacheFlag` provided.
     *
     * Note that you can only use single `CacheFlag` values as a third argument. (You cannot use a
     * combination of two or more `CacheFlag`.)
     *
     * ```ts
     * function evaluateCache(player: EntityPlayer, cacheFlag: CacheFlag): void {}
     * ```
     */
    EVALUATE_CACHE = 8,
    /**
     * This will fire at the beginning of a run, upon continuing a saved run, and when a player enters
     * a Genesis room.
     *
     * For most cases of general purpose player initialization, you should use the
     * `POST_PLAYER_INIT_FIRST` custom callback instead (in order to exclude the case of a player
     * continuing a saved run).
     *
     * This callback has a special property where most `EntityPlayer` methods (such as e.g.
     * `EntityPlayer.AddCollectible`) will silently fail if the player is continuing a saved run.
     * (This behavior was introduced in Repentance.) See the docs for more details about which
     * specific methods are affected.
     *
     * The `isChildPlayer` helper function does not work in this callback (because
     * `EntityPlayer.Parent` is not initialized yet at this point). If you want to exclude non-real
     * players, use the `POST_PLAYER_INIT_FIRST` or the `POST_PLAYER_INIT_LATE` custom callbacks
     * instead.
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PlayerVariant` provided.
     *
     * ```ts
     * function postPlayerInit(player: EntityPlayer): void {}
     * ```
     */
    POST_PLAYER_INIT = 9,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PillEffect` provided.
     *
     * ```ts
     * function postUsePill(
     *   pillEffect: PillEffect,
     *   player: EntityPlayer,
     *   useFlags: BitFlags<UseFlag>,
     * ): void {}
     * ```
     */
    POST_USE_PILL = 10,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EntityType` provided.
     *
     * ```ts
     * function entityTakeDmg(
     *   entity: Entity,
     *   amount: float,
     *   damageFlags: BitFlags<DamageFlag>,
     *   source: EntityRef,
     *   countdownFrames: int,
     * ): boolean | undefined {}
     * ```
     */
    ENTITY_TAKE_DMG = 11,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function postCurseEval(curses: BitFlags<LevelCurse>): BitFlags<LevelCurse> | undefined {}
     * ```
     */
    POST_CURSE_EVAL = 12,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `InputHook` provided.
     *
     * ```ts
     * function inputAction(
     *   entity: Entity | undefined,
     *   inputHook: InputHook,
     *   buttonAction: ButtonAction,
     * ): boolean | float | undefined {}
     * ```
     */
    INPUT_ACTION = 13,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function postGameStarted(isContinued: boolean): void {}
     * ```
     *
     * @deprecated Consider using the `ModCallbackCustom.POST_GAME_STARTED_REORDERED` callback from
     *             `isaacscript-common` instead, since it will fire in the correct order and prevent
     *             bugs relating to data structures not being properly initialized.
     */
    POST_GAME_STARTED = 15,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function postGameEnd(isGameOver: boolean): void {}
     * ```
     */
    POST_GAME_END = 16,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function preGameExit(shouldSave: boolean): void {}
     * ```
     */
    PRE_GAME_EXIT = 17,
    /**
     * Unlike the `POST_GAME_STARTED` callback, this callback does not fire when resuming a saved run.
     *
     * You cannot filter this callback.
     *
     * ```ts
     * function postNewLevel(): void {}
     * ```
     *
     * @deprecated Consider using the `ModCallbackCustom.POST_NEW_LEVEL_REORDERED` callback from
     *             `isaacscript-common` instead, since it will fire in the correct order and prevent
     *             bugs relating to data structures not being properly initialized.
     */
    POST_NEW_LEVEL = 18,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function postNewRoom(): void {}
     * ```
     *
     * @deprecated Consider using the `ModCallbackCustom.POST_NEW_ROOM_REORDERED` callback from
     *             `isaacscript-common` instead, since it will fire in the correct order and prevent
     *             bugs relating to data structures not being properly initialized.
     */
    POST_NEW_ROOM = 19,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function getCard(
     *   rng: RNG,
     *   cardType: CardType,
     *   includePlayingCards: boolean,
     *   includeRunes: boolean,
     *   onlyRunes: boolean,
     * ): CardType | undefined {}
     * ```
     */
    GET_CARD = 20,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function getShaderParams(shaderName: string): Record<string, unknown> {}
     * ```
     */
    GET_SHADER_PARAMS = 21,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function executeCmd(
     *   command: string,
     *   parameters: string,
     *   player: EntityPlayer,
     * ): void {}
     * ```
     */
    EXECUTE_CMD = 22,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `CollectibleType` provided.
     *
     * ```ts
     * function preUseItem(
     *   collectibleType: CollectibleType,
     *   rng: RNG,
     *   player: EntityPlayer,
     *   useFlags: BitFlags<UseFlag>,
     *   activeSlot: ActiveSlot,
     *   customVarData: int,
     * ): boolean | undefined {}
     * ```
     */
    PRE_USE_ITEM = 23,
    /**
     * If you want to prevent an entity from spawning, you cannot return an `EntityType` of 0, since
     * that will cause the game to crash.
     *
     * Sometimes, if you return a type other than the original type (e.g. replacing a pickup with an
     * effect), the game will crash. Thus, you should replace a pickup with a new pickup, and so on.
     *
     * You cannot filter this callback.
     *
     * ```ts
     * function preEntitySpawn(
     *   entityType: EntityType,
     *   variant: int,
     *   subType: int,
     *   position: Vector,
     *   velocity: Vector,
     *   spawner: Entity | undefined,
     *   initSeed: Seed,
     * ): [entityType: EntityType, variant: int, subType: int, initSeed: Seed] | undefined {}
     * ```
     */
    PRE_ENTITY_SPAWN = 24,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `FamiliarVariant` provided.
     *
     * ```ts
     * function postFamiliarRender(
     *   entityFamiliar: EntityFamiliar,
     *   renderOffset: Vector,
     * ): void {}
     * ```
     */
    POST_FAMILIAR_RENDER = 25,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `FamiliarVariant` provided.
     *
     * ```ts
     * function preFamiliarCollision(
     *   familiar: EntityFamiliar,
     *   collider: Entity,
     *   low: boolean,
     * ): boolean | undefined {}
     * ```
     */
    PRE_FAMILIAR_COLLISION = 26,
    /**
     * Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
     *
     * - `Position`
     * - `SpawnerEntity`
     * - `SpawnerType`
     * - `SpawnerVariant`
     * - `Velocity`
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EntityType` provided.
     *
     * ```ts
     * function postNPCInit(npc: EntityNPC): void {}
     * ```
     */
    POST_NPC_INIT = 27,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EntityType` provided.
     *
     * ```ts
     * function postNPCRender(npc: EntityNPC, renderOffset: Vector): void {}
     * ```
     */
    POST_NPC_RENDER = 28,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EntityType` provided.
     *
     * ```ts
     * function postNPCDeath(npc: EntityNPC): void {}
     * ```
     */
    POST_NPC_DEATH = 29,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EntityType` provided.
     *
     * ```ts
     * function preNPCCollision(
     *   npc: EntityNPC,
     *   collider: Entity,
     *   low: boolean,
     * ): boolean | undefined {}
     * ```
     */
    PRE_NPC_COLLISION = 30,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PlayerVariant` provided.
     *
     * ```ts
     * function postPlayerUpdate(player: EntityPlayer): void {}
     * ```
     *
     * @deprecated Consider using the `ModCallbackCustom.POST_PLAYER_UPDATE_REORDERED` callback from
     *             `isaacscript-common` instead, since it will fire in the correct order and prevent
     *             bugs relating to data structures not being properly initialized.
     */
    POST_PLAYER_UPDATE = 31,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PlayerVariant` provided.
     *
     * ```ts
     * function postPlayerRender(player: EntityPlayer, renderOffset: Vector): void {}
     * ```
     *
     * @deprecated Consider using the `ModCallbackCustom.POST_PLAYER_RENDER_REORDERED` callback from
     *             `isaacscript-common` instead, since it will fire in the correct order and prevent
     *             bugs relating to data structures not being properly initialized.
     */
    POST_PLAYER_RENDER = 32,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PlayerVariant` provided.
     *
     * ```ts
     * function prePlayerCollision(
     *   player: EntityPlayer,
     *   collider: Entity,
     *   low: boolean,
     * ): boolean | undefined {}
     * ```
     */
    PRE_PLAYER_COLLISION = 33,
    /**
     * Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
     *
     * - `Position`
     * - `SpawnerEntity`
     * - `SpawnerType`
     * - `SpawnerVariant`
     * - `Velocity`
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PickupVariant` provided.
     *
     * ```ts
     * function postPickupInit(pickup: EntityPickup): void {}
     * ```
     */
    POST_PICKUP_INIT = 34,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PickupVariant` provided.
     *
     * ```ts
     * function postPickupUpdate(pickup: EntityPickup): void {}
     * ```
     */
    POST_PICKUP_UPDATE = 35,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PickupVariant` provided.
     *
     * ```ts
     * function postPickupRender(pickup: EntityPickup, renderOffset: Vector): void {}
     * ```
     */
    POST_PICKUP_RENDER = 36,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function postPickupSelection(
     *   pickup: EntityPickup,
     *   variant: PickupVariant,
     *   subType: int,
     * ): [pickupVariant: PickupVariant, subType: int] | undefined {}
     * ```
     */
    POST_PICKUP_SELECTION = 37,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `PickupVariant` provided.
     *
     * ```ts
     * function prePickupCollision(
     *   pickup: EntityPickup,
     *   collider: Entity,
     *   low: boolean,
     * ): boolean | undefined {}
     * ```
     */
    PRE_PICKUP_COLLISION = 38,
    /**
     * Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
     *
     * - `Position`
     * - `SpawnerEntity`
     * - `SpawnerType`
     * - `SpawnerVariant`
     * - `Velocity`
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `TearVariant` provided.
     *
     * ```ts
     * function postTearInit(tear: EntityTear): void {}
     * ```
     */
    POST_TEAR_INIT = 39,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `TearVariant` provided.
     *
     * ```ts
     * function postTearUpdate(tear: EntityTear): void {}
     * ```
     */
    POST_TEAR_UPDATE = 40,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `TearVariant` provided.
     *
     * ```ts
     * function postTearRender(tear: EntityTear, renderOffset: Vector): void {}
     * ```
     */
    POST_TEAR_RENDER = 41,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `TearVariant` provided.
     *
     * ```ts
     * function preTearCollision(
     *   tear: EntityTear,
     *   collider: Entity,
     *   low: boolean,
     * ): boolean | undefined {}
     * ```
     */
    PRE_TEAR_COLLISION = 42,
    /**
     * Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
     *
     * - `Position`
     * - `SpawnerEntity`
     * - `SpawnerType`
     * - `SpawnerVariant`
     * - `Velocity`
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `ProjectileVariant` provided.
     *
     * ```ts
     * function postProjectileInit(projectile: EntityProjectile): void {}
     * ```
     */
    POST_PROJECTILE_INIT = 43,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `ProjectileVariant` provided.
     *
     * ```ts
     * function postProjectileUpdate(projectile: EntityProjectile): void {}
     * ```
     */
    POST_PROJECTILE_UPDATE = 44,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `ProjectileVariant` provided.
     *
     * ```ts
     * function postProjectileRender(
     *   projectile: EntityProjectile,
     *   renderOffset: Vector,
     * ): void {}
     * ```
     */
    POST_PROJECTILE_RENDER = 45,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `ProjectileVariant` provided.
     *
     * ```ts
     * function preProjectileCollision(
     *   projectile: EntityProjectile,
     *   collider: Entity,
     *   low: boolean,
     * ): boolean | undefined {}
     * ```
     */
    PRE_PROJECTILE_COLLISION = 46,
    /**
     * Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
     *
     * - `Position`
     * - `SpawnerEntity`
     * - `SpawnerType`
     * - `SpawnerVariant`
     * - `Velocity`
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `LaserVariant` provided.
     *
     * ```ts
     * function postLaserInit(laser: EntityLaser): void {}
     * ```
     */
    POST_LASER_INIT = 47,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `LaserVariant` provided.
     *
     * ```ts
     * function postLaserUpdate(laser: EntityLaser): void {}
     * ```
     */
    POST_LASER_UPDATE = 48,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `LaserVariant` provided.
     *
     * ```ts
     * function postLaserRender(laser: EntityLaser, renderOffset: Vector): void {}
     * ```
     */
    POST_LASER_RENDER = 49,
    /**
     * Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
     *
     * - `Position`
     * - `SpawnerEntity`
     * - `SpawnerType`
     * - `SpawnerVariant`
     * - `Velocity`
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the sub-type provided. (This is bugged and is NOT the `KnifeVariant` like you would
     *   expect!)
     *
     * ```ts
     * function postKnifeInit(knife: EntityKnife): void {}
     * ```
     */
    POST_KNIFE_INIT = 50,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the sub-type provided. (This is bugged and is NOT the `KnifeVariant` like you would
     *   expect!)
     *
     * ```ts
     * function postKnifeUpdate(knife: EntityKnife): void {}
     * ```
     */
    POST_KNIFE_UPDATE = 51,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the sub-type provided. (This is bugged and is NOT the `KnifeVariant` like you would
     *   expect!)
     *
     * ```ts
     * function postKnifeRender(knife: EntityKnife, renderOffset: Vector): void {}
     * ```
     */
    POST_KNIFE_RENDER = 52,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the sub-type provided. (This is bugged and is NOT the `KnifeVariant` like you would
     *   expect!)
     *
     * ```ts
     * function preKnifeCollision(
     *   knife: EntityKnife,
     *   collider: Entity,
     *   low: boolean,
     * ): boolean | undefined {}
     * ```
     */
    PRE_KNIFE_COLLISION = 53,
    /**
     * Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
     *
     * - `Position`
     * - `SpawnerEntity`
     * - `SpawnerType`
     * - `SpawnerVariant`
     * - `Velocity`
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EffectVariant` provided.
     *
     * ```ts
     * function postEffectInit(effect: EntityEffect): void {}
     * ```
     */
    POST_EFFECT_INIT = 54,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EffectVariant` provided.
     *
     * ```ts
     * function postEffectUpdate(effect: EntityEffect): void {}
     * ```
     */
    POST_EFFECT_UPDATE = 55,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EffectVariant` provided.
     *
     * ```ts
     * function postEffectRender(effect: EntityEffect, renderOffset: Vector): void {}
     * ```
     */
    POST_EFFECT_RENDER = 56,
    /**
     * Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
     *
     * - `Position`
     * - `SpawnerEntity`
     * - `SpawnerType`
     * - `SpawnerVariant`
     * - `Velocity`
     *
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `BombVariant` provided.
     *
     * ```ts
     * function postBombInit(bomb: EntityBomb): void {}
     * ```
     */
    POST_BOMB_INIT = 57,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `BombVariant` provided.
     *
     * ```ts
     * function postBombUpdate(bomb: EntityBomb): void {}
     * ```
     */
    POST_BOMB_UPDATE = 58,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `BombVariant` provided.
     *
     * ```ts
     * function postBombRender(bomb: EntityBomb, renderOffset: Vector): void {}
     * ```
     */
    POST_BOMB_RENDER = 59,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `BombVariant` provided.
     *
     * ```ts
     * function preBombCollision(
     *   bomb: EntityBomb,
     *   collider: Entity,
     *   low: boolean,
     * ): boolean | undefined {}
     * ```
     */
    PRE_BOMB_COLLISION = 60,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function postFireTear(tear: EntityTear): void {}
     * ```
     */
    POST_FIRE_TEAR = 61,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function preGetCollectible(
     *   itemPoolType: ItemPoolType,
     *   decrease: boolean,
     *   seed: Seed,
     * ): CollectibleType | undefined {}
     * ```
     */
    PRE_GET_COLLECTIBLE = 62,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function postGetCollectible(
     *   collectibleType: CollectibleType,
     *   itemPoolType: ItemPoolType,
     *   decrease: boolean,
     *   seed: Seed,
     * ): CollectibleType | undefined {}
     * ```
     */
    POST_GET_COLLECTIBLE = 63,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function getPillColor(seed: Seed): PillColor | undefined {}
     * ```
     */
    GET_PILL_COLOR = 64,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function getPillEffect(
     *   pillEffect: PillEffect,
     *   pillColor: PillColor,
     * ): PillEffect | undefined {}
     * ```
     */
    GET_PILL_EFFECT = 65,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function getTrinket(
     *   trinketType: TrinketType,
     *   rng: RNG,
     * ): TrinketType | undefined {}
     * ```
     */
    GET_TRINKET = 66,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EntityType` provided.
     *
     * ```ts
     * function postEntityRemove(entity: Entity): void {}
     * ```
     */
    POST_ENTITY_REMOVE = 67,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EntityType` provided.
     *
     * ```ts
     * function postEntityKill(entity: Entity): void {}
     * ```
     */
    POST_ENTITY_KILL = 68,
    /**
     * When registering this callback with the `Mod.AddCallback` method:
     * - You can provide an optional third argument that will make the callback only fire if it
     *   matches the `EntityType` provided.
     *
     * ```ts
     * function preNPCUpdate(entity: Entity): boolean | undefined {}
     * ```
     */
    PRE_NPC_UPDATE = 69,
    /**
     * In vanilla, this is `PRE_SPAWN_CLEAN_AWARD`, which is a typo.
     *
     * You cannot filter this callback.
     *
     * ```ts
     * function preSpawnClearAward(
     *   rng: RNG,
     *   spawnPosition: Vector,
     * ): boolean | undefined {}
     * ```
     */
    PRE_SPAWN_CLEAR_AWARD = 70,
    /**
     * You can use the `isGridEntityXMLType` helper function to convert the
     * `entityTypeOrGridEntityXMLType` argument to an `EntityType` or `GridEntityXMLType`, if needed.
     *
     * You cannot filter this callback.
     *
     * ```ts
     * function preRoomEntitySpawn(
     *   entityTypeOrGridEntityXMLType: EntityType | GridEntityXMLType,
     *   variant: int,
     *   subType: int,
     *   gridIndex: int,
     *   initSeed: Seed,
     * ): [type: EntityType | GridEntityXMLType, variant: int, subType: int] | undefined {}
     * ```
     */
    PRE_ROOM_ENTITY_SPAWN = 71,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function preEntityDevolve(entity: Entity): boolean | undefined {}
     * ```
     */
    PRE_ENTITY_DEVOLVE = 72,
    /**
     * You cannot filter this callback.
     *
     * ```ts
     * function preModUnload(mod: Mod): void {}
     * ```
     */
    PRE_MOD_UNLOAD = 73
}
//# sourceMappingURL=ModCallback.d.ts.map