declare interface EntityPlayer extends Entity {
  /** 1 unit is half a heart. Remove them with negative numbers. */
  AddBlackHearts(blackHearts: int): void;
  /** This adds Tainted Bethany's blood charges. Only works on Tainted Bethany. */
  AddBloodCharge(num: int): void;
  /**
   * @param amount
   * @param position
   * @param target This argument is not optional. If you want to spawn a fly without a target, then
   * you must explicitly pass undefined.
   */
  AddBlueFlies(
    amount: int,
    position: Vector,
    target: Entity | undefined,
  ): Entity;
  AddBlueSpider(position: Vector): Entity;
  /** Remove them with negative numbers. */
  AddBombs(amount: int): void;
  /** Remove them with negative numbers. */
  AddBoneHearts(hearts: int): void;
  /** Remove them with negative numbers. */
  AddBrokenHearts(hearts: int): void;
  /**
   * Used to specify the kinds of stats that should be evaluated the next time `EvaluateCache()` is
   * run.
   */
  AddCacheFlags(cacheFlags: CacheFlag): void;
  AddCard(card: Card | int): void;
  /** Remove them with negative numbers. */
  AddCoins(amount: int): void;
  /**
   * @param collectibleType
   * @param charge Default is 0.
   * @param firstTimePickingUp Setting this to false will not spawn or add consumables for the item
   * and will not cause it to count towards transformations. Default is true.
   * @param activeSlot Sets the active slot this collectible should be added to.
   * Default is ActiveSlot.SLOT_PRIMARY.
   * @param varData Sets the variable data for this collectible (this is used to store extra data
   * for some active items like the number of uses for Jar of Wisps).
   * Default is 0.
   */
  AddCollectible(
    collectibleType: CollectibleType | int,
    charge?: int,
    firstTimePickingUp?: boolean,
    activeSlot?: ActiveSlot,
    varData?: int,
  ): void;
  AddControlsCooldown(cooldown: int): void;
  AddCostume(itemConfigItem: ItemConfigItem, itemStateOnly: boolean): void;
  /**
   * Disables all item effects similarly to the abandoned mineshaft in Mines II.
   * This also temporarily removes consumables and pocket items.
   */
  AddCurseMistEffect(): void;
  AddDeadEyeCharge(): void;
  AddDollarBillEffect(): void;
  /** Remove them with negative numbers. */
  AddEternalHearts(eternalHearts: int): void;
  /** Spawns a friendly dip from Dirty Mind. */
  AddFriendlyDip(subType: DipFamiliarSubType, position: Vector): EntityFamiliar;
  /**
   * Turns the given number of bombs into giga bombs.
   * This does not actually increase the number of bombs held. To actually add bombs, AddBombs()
   * should be called first.
   *
   * @param num
   */
  AddGigaBombs(num: int): void;
  /** Remove them with negative numbers. */
  AddGoldenBomb(): void;
  AddGoldenHearts(hearts: int): void;
  AddGoldenKey(): void;
  /**
   * Adds red hearts to the player if there are any empty heart containers. 1 unit is half a heart.
   * Remove health with negative numbers.
   */
  AddHearts(hearts: int): void;
  /**
   * Spawns a Lemegeton wisp.
   *
   * @param subType The ID of the passive item to mimic.
   * @param position
   * @param adjustOrbitLayer Default is false.
   */
  AddItemWisp(
    subType: int,
    position: Vector,
    adjustOrbitLayer?: boolean,
  ): EntityFamiliar;
  AddJarFlies(flies: int): void;
  AddJarHearts(hearts: int): void;
  /** Remove them with negative numbers. */
  AddKeys(amount: int): void;
  /**
   * Adds heart containers to the player. 2 units is a full heart container.
   * Remove them with negative numbers.
   */
  AddMaxHearts(maxHearts: int, ignoreKeeper: boolean): void;
  /**
   * Spawns a mini Isaac from Giant Cell.
   *
   * @param position
   * @param playAnim If false, skips the appear animation for the familiars.
   */
  AddMinisaac(position: Vector, playAnim?: boolean): EntityFamiliar;
  AddNullCostume(nullItemID: NullItemID | int): void;
  AddPill(pillColor: PillColor | int): void;
  AddPlayerFormCostume(playerForm: PlayerForm): void;
  AddPrettyFly(): void;
  /**
   * Remove them with negative numbers.
   *
   * @param hearts Rotten hearts must be specified in a multiple of 2.
   * For example, `AddRottenHearts(4)` will add 2 rotten hearts.
   */
  AddRottenHearts(hearts: int): void;
  /** This adds Bethany's soul heart charges. Only works on Bethany. */
  AddSoulCharge(num: int): void;
  /** 1 unit is half a heart. Remove them with negative numbers. */
  AddSoulHearts(soulHearts: int): void;
  /** Spawns a defensive fly from The Swarm. */
  AddSwarmFlyOrbital(position: Vector): EntityFamiliar;
  /**
   * - If the player does not have any open trinket slots, this function will do nothing.
   * - If the player has an open trinket slot but already has a trinket, the new trinket will go to
   * the first slot and the existing trinket will get pushed back to the second slot.
   * - If you provide an argument of 0 or an otherwise invalid trinket ID, the game will crash.
   *
   * @param trinketType
   * @param firstTimePickingUp Setting this to false will not spawn or add pickups for the item
   * and will not cause it to count towards transformations. Default is true.
   */
  AddTrinket(
    trinketType: TrinketType | int,
    firstTimePickingUp?: boolean,
  ): void;
  /**
   * Spawns a Book of Virtues wisp.
   *
   * @param subType The ID of the active item to spawn a wisp from. Wisps with a special ID (for
   * example "s0" in wisps.xml) can be spawned with the subtype 65536 + X where X is the number
   * after the "s".
   * @param position
   * @param adjustOrbitLayer If true, allows wisps to spawn outside of their usual orbit if their
   * assigned orbit is full. Default is false.
   * @param dontUpdate If true, the spawned wisp will not update immediately. This allows certain
   * properties to be set on the first frame before the wisp is fully initialized. Default is false.
   */
  AddWisp(
    subType: int,
    position: Vector,
    adjustOrbitLayer?: boolean,
    dontUpdate?: boolean,
  ): EntityFamiliar;
  /**
   * Play the animation that is normally played at the beginning of a stage.
   * Also plays the associated sound effect.
   */
  AnimateAppear(): void;
  /**
   * @param card
   * @param playerAnimationName Default is "Pickup".
   */
  AnimateCard(
    card: Card | int,
    playerAnimationName?: PlayerItemAnimation,
  ): void;
  /**
   * @param collectibleType
   * @param playerAnimationName Default is "Pickup".
   * @param spriteAnimationName Default is "PlayerPickupSparkle".
   */
  AnimateCollectible(
    collectibleType: CollectibleType | int,
    playerItemAnimation?: PlayerItemAnimation,
    collectibleAnimation?: CollectibleAnimation,
  ): void;
  /** Play the "thumbs up" animation. */
  AnimateHappy(): void;
  /** Play the animation where Isaac steps into a beam of light (e.g. at the end of Womb 2). */
  AnimateLightTravel(): void;
  /**
   * @param pillColor
   * @param playerAnimationName Default is "Pickup".
   */
  AnimatePill(
    pillColor: PillColor | int,
    playerAnimationName?: PlayerItemAnimation,
  ): void;
  AnimatePitfallIn(): void;
  AnimatePitfallOut(): void;
  /**
   * Play the animation where Isaac holds his head in his hands.
   * Also plays the associated sound effect.
   */
  AnimateSad(): void;
  AnimateTeleport(up: boolean): void;
  AnimateTrapdoor(): void;
  /**
   * @param trinketType
   * @param playerAnimationName Default is "Pickup".
   * @param spriteAnimationName Default is "PlayerPickupSparkle".
   */
  AnimateTrinket(
    trinketType: TrinketType | int,
    playerAnimationName?: PlayerItemAnimation,
    spriteAnimationName?: string,
  ): void;
  AreControlsEnabled(): boolean;
  AreOpposingShootDirectionsPressed(): boolean;
  /**
   * @param collectibleType Default is CollectibleType.COLLECTIBLE_NULL.
   */
  CanAddCollectible(collectibleType?: CollectibleType): boolean;
  /** Returns true if the player can pick up black hearts, false otherwise. */
  CanPickBlackHearts(): boolean;
  /** Returns true if the player can pick up bone hearts, false otherwise. */
  CanPickBoneHearts(): boolean;
  /** Returns true if the player can pick up golden hearts, false otherwise. */
  CanPickGoldenHearts(): boolean;
  /** Returns true if the player can pick up red hearts, false otherwise. */
  CanPickRedHearts(): boolean;
  /** Returns true if the player can pick up rotten hearts, false otherwise. */
  CanPickRottenHearts(): boolean;
  /** Returns true if the player can pick up soul hearts, false otherwise. */
  CanPickSoulHearts(): boolean;
  CanPickupItem(): boolean;
  CanShoot(): boolean;
  /**
   * When the player presses the different shoot buttons, Isaac will normally turn his head to face
   * the direction that he is supposed to shoot in. This returns true if head will react to
   * shooting, false otherwise.
   */
  CanTurnHead(): boolean;
  /**
   * This will attempt to merge forms when called on characters like Jacob and Esau.
   * This currently does not work correctly when changing from/to certain characters.
   * (i.e. Tainted Isaac)
   */
  ChangePlayerType(type: PlayerType): void;
  /**
   * @param familiarVariant
   * @param targetCount
   * @param rng
   * @param sourceItem The item this type of familiar was created by. Default is undefined.
   * @param familiarSubType The subtype of the familiar to check (-1 matches any subtype). Default
   * is -1.
   */
  CheckFamiliar(
    familiarVariant: FamiliarVariant | int,
    targetCount: int,
    rng: RNG,
    sourceItem?: ItemConfigItem,
    familiarSubType?: int,
  ): void;
  ClearCostumes(): void;
  ClearDeadEyeCharge(): void;
  /** Called automatically by the game when the player exits a room. */
  ClearTemporaryEffects(): void;
  /**
   * Sets the charge of the active item to 0 without triggering the active item effect.
   *
   * @param activeSlot Default is ActiveSlot.SLOT_PRIMARY.
   */
  DischargeActiveItem(activeSlot?: ActiveSlot): void;
  DoZitEffect(direction: Vector): void;
  DonateLuck(luck: int): void;
  DropPocketItem(pocketItemSlot: PocketItemSlot, position: Vector): void;
  DropTrinket(dropPos: Vector, replaceTick: boolean): void;
  /**
   * Triggers the MC_EVALUATE_CACHE callback. Before calling this function, you need to set the
   * appropriate cache flags by using the `AddCacheFlag()` method.
   */
  EvaluateItems(): void;
  /**
   * @param position
   * @param velocity
   * @param source Default is undefined.
   */
  FireBomb(position: Vector, velocity: Vector, source?: Entity): EntityBomb;
  /**
   * @param direction
   * @param source Default is undefined.
   * @param damageMultiplier Default is 1.
   */
  FireBrimstone(
    direction: Vector,
    source?: Entity,
    damageMultiplier?: float,
  ): EntityLaser;
  FireDelayedBrimstone(angle: float, parent: Entity): EntityLaser;
  /**
   * @param parent
   * @param rotationOffset Default is 0.
   * @param cantOverwrite Default is false.
   * @param subType Default is 0.
   * @param variant Default is 0.
   */
  FireKnife(
    parent: Entity,
    rotationOffset?: float,
    cantOverwrite?: boolean,
    subType?: int,
    variant?: int,
  ): EntityKnife;
  /**
   * @param position
   * @param velocity
   * @param canBeEye Default is true.
   * @param noTractorBeam Default is false.
   * @param canTriggerStreakEnd Default is true.
   * @param source Default is undefined.
   * @param damageMultiplier Default is 1.
   */
  FireTear(
    position: Vector,
    velocity: Vector,
    canBeEye?: boolean,
    noTractorBeam?: boolean,
    canTriggerStreakEnd?: boolean,
    source?: Entity,
    damageMultiplier?: float,
  ): EntityTear;
  /**
   * @param position
   * @param laserOffset
   * @param direction
   * @param leftEye
   * @param oneHit Default is false.
   * @param source Default is undefined.
   * @param damageMultiplier Default is 1.
   */
  FireTechLaser(
    position: Vector,
    laserOffset: LaserOffset,
    direction: Vector,
    leftEye: boolean,
    oneHit?: boolean,
    source?: Entity,
    damageMultiplier?: float,
  ): EntityLaser;
  /**
   * @param position
   * @param direction
   * @param radius
   * @param source Default is undefined.
   * @param damageMultiplier Default is 1.
   */
  FireTechXLaser(
    position: Vector,
    direction: Vector,
    radius: float,
    source?: Entity,
    damageMultiplier?: float,
  ): EntityLaser;
  FlushQueueItem(): boolean;
  /**
   * @param activeSlot Default is ActiveSlot.SLOT_PRIMARY.
   * @param force If set, items will always be charged even if they normally cannot be recharged by
   * batteries.
   */
  FullCharge(activeSlot?: ActiveSlot, force?: boolean): boolean;
  /**
   * @param activeSlot Default is ActiveSlot.SLOT_PRIMARY.
   */
  GetActiveCharge(activeSlot?: ActiveSlot): int;
  /**
   * Returns 0 if no item is held.
   *
   * @param activeSlot Default is ActiveSlot.SLOT_PRIMARY.
   */
  GetActiveItem(activeSlot?: ActiveSlot): CollectibleType | int;
  /**
   * Returns 0 if there is no active item in the specified slot.
   *
   * @param activeSlot Default is ActiveSlot.SLOT_PRIMARY.
   */
  GetActiveSubCharge(activeSlot?: ActiveSlot): int;
  GetActiveWeaponEntity(): Entity;
  GetAimDirection(): Readonly<Vector>;
  GetBabySkin(): BabySubType | int;
  /**
   * @param activeSlot Default is ActiveSlot.SLOT_PRIMARY.
   */
  GetBatteryCharge(activeSlot?: ActiveSlot): int;
  /** This returns the bit mask for which soul hearts are black hearts. */
  GetBlackHearts(): int;
  /** This gets Tainted Bethany's blood charges. */
  GetBloodCharge(): int;
  /**
   * There is no separate BombFlags enum, so bombs use tear flags.
   * Be aware that this really takes a BitSet128 instead of an integer.
   * However, all of the TearFlags enums values use BitSet128 constructors.
   */
  GetBombFlags(): int;
  /**
   * There is no separate BombFlags enum, so bombs use tear flags.
   * Be aware that this really takes a BitSet128 instead of an integer.
   * However, all of the TearFlags enums values use BitSet128 constructors.
   */
  GetBombVariant(
    tearFlags: TearFlags,
    forceSmallBomb: boolean,
  ): BombVariant | int;
  GetBoneHearts(): int;
  GetBrokenHearts(): int;
  /** Returns 0 if there is no card. */
  GetCard(pocketItemSlot: PocketItemSlot): Card | int;
  GetCardRNG(card: Card | int): RNG;
  GetCollectibleCount(): int;
  /**
   * @param collectibleType
   * @param onlyCountTrueItems If set to true, the function only counts collectibles that the player
   * actually owns and ignores things like Lilith's Incubus, items granted by 3 Dollar Bill, and so
   * forth.
   */
  GetCollectibleNum(
    collectibleType: CollectibleType | int,
    ignoreModifiers?: boolean,
  ): int;
  GetCollectibleRNG(collectibleType: CollectibleType | int): RNG;
  GetCostumeNullPos(
    nullFrameName: string,
    headScale: boolean,
    direction: Vector,
  ): Vector;
  GetDamageCooldown(): int;
  /** This returns the number of blood charges when called on Tainted Bethany, 0 otherwise. */
  GetEffectiveBloodCharge(): int;
  GetEffectiveMaxHearts(): int;
  /** This returns the number of soul charges when called on Bethany, 0 otherwise. */
  GetEffectiveSoulCharge(): int;
  GetEffects(): TemporaryEffects;
  GetEternalHearts(): int;
  GetExtraLives(): int;
  GetFireDirection(): Direction;
  GetFlyingOffset(): Vector;
  GetGoldenHearts(): int;
  GetGreedDonationBreakChance(): float;
  GetHeadDirection(): Direction;
  GetHeartLimit(): int;
  /**
   * Returns the amount of red hearts the player has inside their heart containers and bone hearts.
   * 1 unit is half a heart.
   */
  GetHearts(): int;
  GetItemState(): int;
  GetJarFlies(): int;
  GetJarHearts(): int;
  GetLaserOffset(laserOffset: LaserOffset, direction: Vector): Vector;
  GetLastActionTriggers(): int;
  GetLastDamageFlags(): DamageFlag;
  GetLastDamageSource(): Readonly<EntityRef>;
  GetLastDirection(): Readonly<Vector>;
  /**
   * - When called on Jacob or Esau, returns Jacob.
   * - When called on Tainted Forgotten or Tainted Forgotten's Soul, returns Tainted Forgotten.
   * - When called on any other character, returns that character.
   */
  GetMainTwin(): EntityPlayer;
  /**
   * Returns the amount of heart containers that the player has. 1 unit is half a heart container.
   */
  GetMaxHearts(): int;
  /**
   * Returns the maximum number of pocket items + pocket actives that the player can currently hold.
   *
   * - Usually, this will return 1.
   * - If the player has Belly Button, Starter Deck, or Little Baggy, it will increment the number
   * by 1.
   * - If the player has a pocket active item, it will increment the number by 1.
   * - If the player has a dice from the Dice Bag trinket, it will increment the number by 1.
   * - The maximum number this can return is 4.
   */
  GetMaxPocketItems(): int;
  /**
   * Returns the maximum number of trinkets that the player can currently hold. Usually, this will
   * return 1, but the player can hold up to 2 trinkets under certain conditions (e.g. having Mom's
   * Purse).
   */
  GetMaxTrinkets(): int;
  /**
   * Returns the current passive item mimicked by Modeling Clay
   * (or COLLECTIBLE_NULL if no effect is being mimicked).
   */
  GetModelingClayEffect(): CollectibleType;
  GetMovementDirection(): Direction;
  GetMovementInput(): Vector;
  GetMovementJoystick(): Vector;
  GetMovementVector(): Readonly<Vector>;
  /**
   * Note that the only thing that you can do with MultiShotParams is feed it to the
   * `EntityPlayer.GetMultiShotPositionVelocity()` method.
   *
   * @param weaponType Default is WeaponType.WEAPON_TEARS.
   */
  GetMultiShotParams(weaponType?: WeaponType): MultiShotParams;
  GetMultiShotPositionVelocity(
    loopIndex: int,
    weaponType: WeaponType,
    shotDirection: Vector,
    shotSpeed: float,
    multiShotParams: MultiShotParams,
  ): PosVel;
  /**
   * Normally, this function returns the player. However, in some cases, NPCs can be redirected to
   * attack another target, in which case this function will return the alternate target
   * (e.g. after using Best Friend).
   */
  GetNPCTarget(): Entity;
  /** Returns e.g. "Isaac", "Cain", etc. */
  GetName(): string;
  GetNumBlueFlies(): int;
  GetNumBlueSpiders(): int;
  GetNumBombs(): int;
  GetNumCoins(): int;
  /** Returns the number of giga bombs held. */
  GetNumGigaBombs(): int;
  GetNumKeys(): int;
  /**
   * - When called on Jacob, returns Esau.
   * - When called on Esau, returns Jacob.
   * - When called on Tainted Forgotten, returns Tainted Forgotten's Soul.
   * - When called on Tainted Forgotten's Soul, returns Tainted Forgotten.
   * - When called on any other character, returns undefined.
   */
  GetOtherTwin(): EntityPlayer | undefined;
  /** Returns 0 if there is no pill. */
  GetPill(pocketItemSlot: PocketItemSlot): PillColor | int;
  GetPillRNG(pillEffect: PillEffect | int): RNG;
  GetPlayerType(): PlayerType | int;
  // GetPocketItem(slotID: int): Readonly<PlayerPocketItem>; // PlayerPocketItem is not implemented
  /**
   * Returns the joystick direction that drives player movement, taking into account certain
   * modifiers like disabled controls and seed effects.
   */
  GetRecentMovementVector(): Readonly<Vector>;
  /**
   * This returns the actual number of rotten hearts.
   * (For example, this returns 2 if the player has 2 rotten hearts.)
   */
  GetRottenHearts(): int;
  GetShootingInput(): Vector;
  GetShootingJoystick(): Vector;
  GetSmoothBodyRotation(): float;
  /** This gets Bethany's soul heart charges. */
  GetSoulCharge(): int;
  /**
   * 1 unit is half a heart. Black hearts count toward this total.
   * Remove them with negative numbers.
   */
  GetSoulHearts(): int;
  /**
   * - When on The Forgotten, returns the player object for The Soul.
   * - When on The Soul, returns the player object for The Forgotten.
   * - Otherwise, returns undefined.
   */
  GetSubPlayer(): EntityPlayer | undefined;
  /**
   * Used for tear parameters that are calculated on hit (e.g. Tough Love, Common Cold),
   *
   * @param weaponType
   * @param damageScale Default is 1.
   * @param tearDisplacement Default is 1.
   * @param source Default is undefined.
   */
  GetTearHitParams(
    weaponType: WeaponType,
    damageScale?: float,
    tearDisplacement?: int,
    source?: Entity,
  ): TearParams;
  GetTearMovementInheritance(shotDirection: Vector): Vector;
  GetTearPoisonDamage(): float;
  GetTearRangeModifier(): int;
  GetTotalDamageTaken(): int;
  GetTractorBeam(): Entity;
  /** Returns 0 if there is no trinket. */
  GetTrinket(trinketSlot: TrinketSlot): int;
  /**
   * This is the number of times that the trinket effect is applied.
   * Returns 0 if the player does not have the particular trinket.
   */
  GetTrinketMultiplier(trinketType: TrinketType | int): int;
  GetTrinketRNG(trinketType: TrinketType | int): RNG;
  GetVelocityBeforeUpdate(): Readonly<Vector>;
  GetZodiacEffect(): ZodiacCollectibles;
  /**
   * @param collectibleType
   * @param ignoreModifiers If set to true, only counts collectibles the player actually owns and
   * ignores effects granted by items like Zodiac, 3 Dollar Bill and Lemegeton. Default is false.
   */
  HasCollectible(
    collectibleType: CollectibleType | int,
    ignoreModifiers?: boolean,
  ): boolean;
  /** Returns true if the player's item effects are currently being disabled. */
  HasCurseMistEffect(): boolean;
  HasFullHearts(): boolean;
  HasFullHeartsAndSoulHearts(): boolean;
  HasGoldenBomb(): boolean;
  HasGoldenKey(): boolean;
  /**
   * @param damageFlag Default is 0.
   */
  HasInvincibility(damageFlag?: DamageFlag): boolean;
  HasPlayerForm(playerForm: PlayerForm): boolean;
  HasTimedItem(): boolean;
  /**
   * @param trinketType
   * @param ignoreModifiers If set to true, only counts trinkets the player actually holds and
   * ignores effects granted by other items. Default is false.
   */
  HasTrinket(
    trinketType: TrinketType | int,
    ignoreModifiers?: boolean,
  ): boolean;
  HasWeaponType(weaponType: WeaponType): boolean;
  InitBabySkin(): void;
  IsBlackHeart(heart: int): boolean;
  IsBoneHeart(heartSlot: int): boolean;
  /**
   * In a multiplayer game, if a player dies, they will return as a tiny ghost. This method returns
   * true if the player is a co-op ghost.
   */
  IsCoopGhost(): boolean;
  IsExtraAnimationFinished(): boolean;
  IsFullSpriteRendering(): boolean;
  IsHeldItemVisible(): boolean;
  /* Is the player holding up an item (card/collectible/etc)? */
  IsHoldingItem(): boolean;
  IsItemQueueEmpty(): boolean;
  IsP2Appearing(): boolean;
  IsPosInSpotLight(position: Vector): boolean;
  /** Returns true for The Soul. Otherwise, returns false. */
  IsSubPlayer(): boolean;
  /**
   * @param activeSlot Default is ActiveSlot.SLOT_PRIMARY.
   */
  NeedsCharge(activeSlot?: ActiveSlot): boolean;
  PlayExtraAnimation(animation: string): void;
  QueueExtraAnimation(animation: string): void;
  /**
   * When the player touches a collectible item, they are not granted it immediately. Instead, the
   * item is a queue for the duration of the animation where the player holds the item above their
   * head. When the animation is finished, the item(s) in the queue will be granted. This method
   * adds a new item to the item queue. If the player is not currently playing an animation, then
   * the queued item will simply be awarded instantly.
   *
   * @param itemConfigItem
   * @param charge Default is 0.
   * @param touched Default is false.
   * @param golden Default is false.
   * @param varData Default is false.
   */
  QueueItem(
    itemConfigItem: ItemConfigItem,
    charge?: int,
    touched?: boolean,
    golden?: boolean,
    varData?: int,
  ): void;
  RemoveBlackHeart(blackHeart: int): void;
  RemoveBlueFly(): void;
  RemoveBlueSpider(): void;
  /**
   * @param collectibleType
   * @param ignoreModifiers Ignores collectible effects granted by other items (i.e. Void).
   * Default is false.
   * @param activeSlot Sets the active slot this collectible should be removed from.
   * Default is ActiveSlot.SLOT_PRIMARY.
   * @param removeFromPlayerForm If successfully removed and part of a transformation, decrease that
   * transformation's counter by 1. Default is true.
   */
  RemoveCollectible(
    collectibleType: CollectibleType | int,
    ignoreModifiers?: boolean,
    activeSlot?: ActiveSlot,
    removeFromPlayerForm?: boolean,
  ): void;
  RemoveCostume(itemConfigItem: ItemConfigItem): void;
  /**
   * Re-enables item effects removed by AddCurseMistEffect().
   * Also attempts to restore consumables and pocket items removed by AddCurseMistEffect().
   */
  RemoveCurseMistEffect(): void;
  RemoveGoldenBomb(): void;
  RemoveGoldenKey(): void;
  /** Removes player-specific costumes like Magdalene's hair or Cain's eyepatch. */
  RemoveSkinCostume(): void;
  RenderBody(position: Vector): void;
  RenderGlow(position: Vector): void;
  RenderHead(position: Vector): void;
  RenderTop(position: Vector): void;
  ReplaceCostumeSprite(
    itemConfigItem: ItemConfigItem,
    spritePath: string,
    spriteID: int,
  ): void;
  ResetDamageCooldown(): void;
  ResetItemState(): void;
  RespawnFamiliars(): void;
  Revive(): void;
  /**
   * @param charge
   * @param activeSlot Default is ActiveSlot.SLOT_PRIMARY.
   */
  SetActiveCharge(charge: int, activeSlot?: ActiveSlot): void;
  /** This sets Tainted Bethany's blood charges. Only works on Tainted Bethany. */
  SetBloodCharge(num: int): void;
  SetCard(pocketItemSlot: PocketItemSlot, card: Card | int): void;
  SetFullHearts(): void;
  SetMinDamageCooldown(damageCooldown: int): void;
  SetPill(pocketItemSlot: PocketItemSlot, pillColor: PillColor | int): void;
  /**
   * Sets the player's pocket active item to the given active item.
   * Items added to SLOT_POCKET2 will always be removed upon being used.
   *
   * @param collectibleType
   * @param slot Can be either ActiveSlot.SLOT_POCKET or ActiveSlot.SLOT_POCKET2. Default is ActiveSlot.SLOT_POCKET.
   * @param keepInPools If true, the item will not be removed from the item pools. Default is false.
   */
  SetPocketActiveItem(
    collectibleType: CollectibleType,
    slot?: ActiveSlot,
    keepInPools?: boolean,
  ): void;
  SetShootingCooldown(cooldown: int): void;
  /**
   * This sets Bethany's soul heart charges.
   *
   * @param num
   */
  SetSoulCharge(num: int): void;
  SetTargetTrapDoor(trapDoor: GridEntity): void;
  ShootRedCandle(direction: Vector): void;
  SpawnMawOfVoid(timeout: int): EntityLaser;
  StopExtraAnimation(): void;
  SwapActiveItems(): void;
  ThrowBlueSpider(position: Vector, target: Vector): Entity;
  /**
   * Spawns a friendly dip (from Dirty Mind) and throws it towards the specified target.
   *
   * @param subType
   * @param position
   * @param target If Vector.Zero, throws the spawned dip in a random direction. Default is
   * Vector.Zero.
   */
  ThrowFriendlyDip(
    subType: DipFamiliarSubType,
    position: Vector,
    target?: Vector,
  ): EntityFamiliar;
  /**
   * If holding an entity, throws it in the specified direction and returns it. Otherwise, returns
   * undefined.
   *
   * @param velocity
   */
  ThrowHeldEntity(velocity: Vector): Entity;
  /**
   * Triggers the extra effect granted by Book of Virtues for the given active item.
   *
   * @param collectibleType Default is CollectibleType.COLLECTIBLE_NULL.
   */
  TriggerBookOfVirtues(collectibleType?: CollectibleType): void;
  /**
   * Attempts to pick up the given entity, returns true on success.
   * Currently only works with some entity types (mainly bombs and enemies).
   */
  TryHoldEntity(entity: Entity): boolean;
  TryHoldTrinket(trinketType: TrinketType | int): boolean;
  /**
   * @param collectibleType
   * @param keepPersistent If set to false, this method will only remove temporary costumes.
   */
  TryRemoveCollectibleCostume(
    collectibleType: CollectibleType | int,
    keepPersistent: boolean,
  ): void;
  TryRemoveNullCostume(nullItemID: NullItemID | int): void;
  /**
   * Will remove the specified trinket, if it exists. This will also remove The Tick and smelted
   * trinkets.
   *
   * @param trinketType If you provide an argument of 0 or an otherwise invalid trinket ID, the game
   * will crash.
   * @returns Whether or not the specified trinket was removed successfully.
   */
  TryRemoveTrinket(trinketType: TrinketType | int): boolean;
  TryRemoveTrinketCostume(trinketType: TrinketType | int): void;
  TryUseKey(): boolean;
  UpdateCanShoot(): void;
  /**
   * @param collectibleType
   * @param useFlag Default is 0.
   * @param activeSlot The active slot this item was used from.
   * (Set to -1 if this item wasn't triggered by any active slot.)
   * Default is ActiveSlot.SLOT_PRIMARY.
   */
  UseActiveItem(
    collectibleType: CollectibleType | int,
    useFlag?: UseFlag,
    activeSlot?: ActiveSlot,
  ): void;
  /**
   * @param collectibleType
   * @param showAnim
   * @param keepActiveItem
   * @param allowNonMainPlayer
   * @param toAddCostume
   * @param activeSlot The active slot this item was used from.
   * (Set to -1 if this item wasn't triggered by any active slot.)
   * Default is ActiveSlot.SLOT_PRIMARY.
   */
  UseActiveItem(
    collectibleType: CollectibleType | int,
    showAnim: boolean,
    keepActiveItem: boolean,
    allowNonMainPlayer: boolean,
    toAddCostume: boolean,
    activeSlot?: ActiveSlot,
  ): void;
  /**
   * @param card
   * @param useFlag Default is 0.
   */
  UseCard(card: Card | int, useFlag?: UseFlag): void;
  /**
   * @param pillEffect
   * @param pillColor
   * @param useFlag Default is 0.
   */
  UsePill(
    pillEffect: PillEffect | int,
    pillColor: PillColor | int,
    useFlag?: UseFlag,
  ): void;
  WillPlayerRevive(): boolean;

  BabySkin: BabySubType | int;
  /** Only change this in the EvaluateCache callback. */
  CanFly: boolean;
  readonly ControllerIndex: ControllerIndex;
  ControlsCooldown: int;
  ControlsEnabled: boolean;
  /** Only change this in the EvaluateCache callback. */
  Damage: float;
  FireDelay: int;
  // readonly FriendBallEnemy: Readonly<EntityDesc>; // EntityDesc is not implemented
  HeadFrameDelay: int;
  ItemHoldCooldown: int;
  LaserColor: Color;
  /** Only change this in the EvaluateCache callback. */
  Luck: float;
  /** Only change this in the EvaluateCache callback. */
  MaxFireDelay: int;
  /** Only change this in the EvaluateCache callback. */
  MoveSpeed: float;
  QueuedItem: QueueItemData;
  /** Only change this in the EvaluateCache callback. */
  ShotSpeed: float;
  SpriteScale: Vector;
  TearColor: Color;
  TearFallingAcceleration: float;
  /** Only change this in the EvaluateCache callback. */
  TearFallingSpeed: float;
  /**
   * Only change this in the EvaluateCache callback.
   * Be aware that this is really a BitSet128 instead of an integer.
   * However, all of the TearFlags enums values use BitSet128 constructors.
   */
  TearFlags: int;
  /**
   * This is equal to the range stat multiplied by -1.
   * Only change this in the EvaluateCache callback.
   */
  TearHeight: float;
  readonly TearsOffset: Readonly<Vector>;
}