Animal

// Animal.absorptionAmount as float
myAnimal.absorptionAmount

// Animal.absorptionAmount() as float;
myAnimal.absorptionAmount();

// Animal.acceptsFailure as bool
myAnimal.acceptsFailure

// Animal.acceptsFailure() as bool;
myAnimal.acceptsFailure();

// Animal.acceptsSuccess as bool
myAnimal.acceptsSuccess

// Animal.acceptsSuccess() as bool;
myAnimal.acceptsSuccess();

// Animal.activeEffects as Collection<MobEffectInstance>
myAnimal.activeEffects

// Animal.activeEffects() as Collection<MobEffectInstance>;
myAnimal.activeEffects();

// Animal.activeEffectsMap as MobEffectInstance[MobEffect]
myAnimal.activeEffectsMap

// Animal.activeEffectsMap() as MobEffectInstance[MobEffect];
myAnimal.activeEffectsMap();

// Animal.addEffect(effectInstance as MobEffectInstance) as bool;
myAnimal.addEffect(myMobEffectInstance);

// Animal.addEffect(effectInstance as MobEffectInstance, entity as Entity) as bool;
myAnimal.addEffect(myMobEffectInstance, myEntity);

// Animal.addTag(tagName as string) as bool;
myAnimal.addTag(myString);

// Animal.aggressive as bool
myAnimal.aggressive

// Animal.aggressive = (value as bool);
myAnimal.aggressive = myBool;

// Animal.airSupply as int
myAnimal.airSupply

// Animal.airSupply() as int;
myAnimal.airSupply();

// Animal.allSlots as Iterable<ItemStack>
myAnimal.allSlots

// Animal.allSlots() as Iterable<ItemStack>;
myAnimal.allSlots();

// Animal.alwaysAccepts as bool
myAnimal.alwaysAccepts

// Animal.alwaysAccepts() as bool;
myAnimal.alwaysAccepts();

// Animal.ambientSoundInterval as int
myAnimal.ambientSoundInterval

// Animal.armorCoverPercentage as float
myAnimal.armorCoverPercentage

// Animal.armorCoverPercentage() as float;
myAnimal.armorCoverPercentage();

// Animal.armorSlots as Iterable<ItemStack>
myAnimal.armorSlots

// Animal.armorSlots() as Iterable<ItemStack>;
myAnimal.armorSlots();

// Animal.armorValue as int
myAnimal.armorValue

// Animal.armorValue() as int;
myAnimal.armorValue();

// Animal.arrowCount as int
myAnimal.arrowCount

// Animal.arrowCount() as int;
myAnimal.arrowCount();

// Animal.ate();
myAnimal.ate();

// Animal.attackable as bool
myAnimal.attackable

// Animal.attackable() as bool;
myAnimal.attackable();

// Animal.baby = (value as bool);
myAnimal.baby = myBool;

// Animal.bbHeight as float
myAnimal.bbHeight

// Animal.bbHeight() as float;
myAnimal.bbHeight();

// Animal.bbWidth as float
myAnimal.bbWidth

// Animal.bbWidth() as float;
myAnimal.bbWidth();

// Animal.bedOrientation as Direction
myAnimal.bedOrientation

// Animal.bedOrientation() as Direction;
myAnimal.bedOrientation();

// Animal.blockPosiion as BlockPos
myAnimal.blockPosiion

// Animal.blockPosiion() as BlockPos;
myAnimal.blockPosiion();

// Animal.blockPosition as BlockPos
myAnimal.blockPosition

// Animal.blockPosition() as BlockPos;
myAnimal.blockPosition();

// Animal.blockX as int
myAnimal.blockX

// Animal.blockX() as int;
myAnimal.blockX();

// Animal.blockY as int
myAnimal.blockY

// Animal.blockY() as int;
myAnimal.blockY();

// Animal.blockZ as int
myAnimal.blockZ

// Animal.blockZ() as int;
myAnimal.blockZ();

// Animal.boundingBox as AABB
myAnimal.boundingBox

// Animal.boundingBox() as AABB;
myAnimal.boundingBox();

// Animal.boundingBoxForCulling as AABB
myAnimal.boundingBoxForCulling

// Animal.boundingBoxForCulling() as AABB;
myAnimal.boundingBoxForCulling();

// Animal.canAttack(target as LivingEntity) as bool;
myAnimal.canAttack(myLivingEntity);

// Animal.canBeAffected(effectInstance as MobEffectInstance) as bool;
myAnimal.canBeAffected(myMobEffectInstance);

// Animal.canBeCollidedWith as bool
myAnimal.canBeCollidedWith

// Animal.canBeCollidedWith() as bool;
myAnimal.canBeCollidedWith();

// Animal.canBeLeashed() as bool;
myAnimal.canBeLeashed();

// Animal.canBeSeenAsEnemy as bool
myAnimal.canBeSeenAsEnemy

// Animal.canBeSeenAsEnemy() as bool;
myAnimal.canBeSeenAsEnemy();

// Animal.canBeSeenByAnyone as bool
myAnimal.canBeSeenByAnyone

// Animal.canBeSeenByAnyone() as bool;
myAnimal.canBeSeenByAnyone();

// Animal.canBreatheUnderwater as bool
myAnimal.canBreatheUnderwater

// Animal.canBreatheUnderwater() as bool;
myAnimal.canBreatheUnderwater();

// Animal.canCollideWith(other as Entity) as bool;
myAnimal.canCollideWith(myEntity);

// Animal.canFAllInLove as bool
myAnimal.canFAllInLove

// Animal.canFireProjectileWeapon(weapon as ProjectileWeaponItem) as bool;
myAnimal.canFireProjectileWeapon(myProjectileWeaponItem);

// Animal.canFreeze as bool
myAnimal.canFreeze

// Animal.canFreeze() as bool;
myAnimal.canFreeze();

// Animal.canHoldItem(stack as ItemStack) as bool;
myAnimal.canHoldItem(myItemStack);

// Animal.canMate(other as Animal) as bool;
myAnimal.canMate(myAnimal);

// Animal.canPickUpLoot as bool
myAnimal.canPickUpLoot

// Animal.canPickUpLoot = (value as bool);
myAnimal.canPickUpLoot = myBool;

// Animal.canReplaceEqualItem(toReplace as ItemStack, with as ItemStack) as bool;
myAnimal.canReplaceEqualItem(myItemStack, myItemStack);

// Animal.canStandOnFluid(fluid as Fluid) as bool;
myAnimal.canStandOnFluid(myFluid);

// Animal.canTakeItem(stack as ItemStack) as bool;
myAnimal.canTakeItem(myItemStack);

// Animal.checkSpawnObstruction(level as LevelReader) as bool;
myAnimal.checkSpawnObstruction(myLevelReader);

// Animal.checkSpawnRules(level as LevelAccessor, spawnType as MobSpawnType) as bool;
myAnimal.checkSpawnRules(myLevelAccessor, myMobSpawnType);

// Animal.clearFire();
myAnimal.clearFire();

// Animal.clearRestriction();
myAnimal.clearRestriction();

// Animal.clearSleepingPos();
myAnimal.clearSleepingPos();

// Animal.closerThan(other as Entity, distance as double) as bool;
myAnimal.closerThan(myEntity, myDouble);

// Animal.commandSenderWorld as Level
myAnimal.commandSenderWorld

// Animal.commandSenderWorld() as Level;
myAnimal.commandSenderWorld();

// Animal.controllingPassenger as Entity
myAnimal.controllingPassenger

// Animal.controllingPassenger() as Entity;
myAnimal.controllingPassenger();

// Animal.customData as MapData
myAnimal.customData

// Animal.customData() as MapData;
myAnimal.customData();

// Animal.customName as Component
myAnimal.customName

// Animal.customName as Component
myAnimal.customName

// Animal.customName() as Component;
myAnimal.customName();

// Animal.customName() as Component;
myAnimal.customName();

// Animal.dampensVibrations as bool
myAnimal.dampensVibrations

// Animal.dampensVibrations() as bool;
myAnimal.dampensVibrations();

// Animal.data as MapData
myAnimal.data

// Animal.data() as MapData;
myAnimal.data();

// Animal.deltaMovement as Vec3
myAnimal.deltaMovement

// Animal.deltaMovement = (deltaMovement as Vec3);
myAnimal.deltaMovement = myVec3;

// Animal.deltaMovement() as Vec3;
myAnimal.deltaMovement();

// Animal.deltaMovement(deltaMovement as Vec3);
myAnimal.deltaMovement(myVec3);

// Animal.die(source as DamageSource);
myAnimal.die(myDamageSource);

// Animal.dimensionChangingDelay as int
myAnimal.dimensionChangingDelay

// Animal.dimensionChangingDelay() as int;
myAnimal.dimensionChangingDelay();

// Animal.direction as Direction
myAnimal.direction

// Animal.direction() as Direction;
myAnimal.direction();

// Animal.discard();
myAnimal.discard();

// Animal.dismountsUnderwater as bool
myAnimal.dismountsUnderwater

// Animal.displayName as Component
myAnimal.displayName

// Animal.displayName as Component
myAnimal.displayName

// Animal.displayName() as Component;
myAnimal.displayName();

// Animal.displayName() as Component;
myAnimal.displayName();

// Animal.distanceTo(entity as Entity) as float;
myAnimal.distanceTo(myEntity);

// Animal.distanceToSqr(x as double, y as double, z as double) as double;
myAnimal.distanceToSqr(myDouble, myDouble, myDouble);

// Animal.distanceToSqr(entity as Entity) as double;
myAnimal.distanceToSqr(myEntity);

// Animal.distanceToSqr(vec as Vec3) as double;
myAnimal.distanceToSqr(myVec3);

// Animal.doHurtTarget(entity as Entity) as bool;
myAnimal.doHurtTarget(myEntity);

// Animal.dropLeash(broadcastPacket as bool, dropLeash as bool);
myAnimal.dropLeash(myBool, myBool);

// Animal.eat(level as Level, stack as ItemStack) as ItemStack;
myAnimal.eat(myLevel, myItemStack);

// Animal.ejectPassengers();
myAnimal.ejectPassengers();

// Animal.equipItemIfPossible(stack as ItemStack) as ItemStack;
myAnimal.equipItemIfPossible(myItemStack);

// Animal.eyeHeight as float
myAnimal.eyeHeight

// Animal.eyeHeight() as float;
myAnimal.eyeHeight();

// Animal.eyePosition as Vec3
myAnimal.eyePosition

// Animal.eyePosition() as Vec3;
myAnimal.eyePosition();

// Animal.eyeY as double
myAnimal.eyeY

// Animal.eyeY() as double;
myAnimal.eyeY();

// Animal.fallFlyingTicks as int
myAnimal.fallFlyingTicks

// Animal.fallFlyingTicks() as int;
myAnimal.fallFlyingTicks();

// Animal.finalizeSpawnChildFromBreeding(level as ServerLevel, otherParent as Animal, child as AgeableMob);
myAnimal.finalizeSpawnChildFromBreeding(myServerLevel, myAnimal, myAgeableMob);

// Animal.fireImmune as bool
myAnimal.fireImmune

// Animal.fireImmune() as bool;
myAnimal.fireImmune();

// Animal.fireTicks as int
myAnimal.fireTicks

// Animal.fireTicks = (ticks as int);
myAnimal.fireTicks = myInt;

// Animal.firstPassenger as Entity
myAnimal.firstPassenger

// Animal.firstPassenger() as Entity;
myAnimal.firstPassenger();

// Animal.fluidJumpThreshold as double
myAnimal.fluidJumpThreshold

// Animal.fluidJumpThreshold() as double;
myAnimal.fluidJumpThreshold();

// Animal.forceAddEffect(effectInstance as MobEffectInstance, entity as Entity);
myAnimal.forceAddEffect(myMobEffectInstance, myEntity);

// Animal.forward as Vec3
myAnimal.forward

// Animal.forward() as Vec3;
myAnimal.forward();

// Animal.getAttachmentData<T>(type as AttachmentType<T>) as T;
myAnimal.getAttachmentData<T>(myAttachmentType);

// Animal.getAttachmentData<T>(type as Supplier<AttachmentType<T>>) as T;
myAnimal.getAttachmentData<T>(mySupplier);

// Animal.getAttribute(attribute as Attribute) as AttributeInstance;
myAnimal.getAttribute(myAttribute);

// Animal.getAttributeBaseValue(attribute as Attribute) as double;
myAnimal.getAttributeBaseValue(myAttribute);

// Animal.getAttributeValue(attribute as Attribute) as double;
myAnimal.getAttributeValue(myAttribute);

// Animal.getEffect(effect as MobEffect) as MobEffectInstance;
myAnimal.getEffect(myMobEffect);

// Animal.getEyePosition(partialTicks as float) as Vec3;
myAnimal.getEyePosition(myFloat);

// Animal.getItemBySlot(slot as EquipmentSlot) as ItemStack;
myAnimal.getItemBySlot(myEquipmentSlot);

// Animal.getItemInHand(hand as InteractionHand) as ItemStack;
myAnimal.getItemInHand(myInteractionHand);

// Animal.getPosition(partialTicks as float) as Vec3;
myAnimal.getPosition(myFloat);

// Animal.getRestrictCenter as BlockPos
myAnimal.getRestrictCenter

// Animal.getRestrictCenter as Entity
myAnimal.getRestrictCenter

// Animal.getRestrictRadius as float
myAnimal.getRestrictRadius

// Animal.getSwimAmount(partialTicks as float) as float;
myAnimal.getSwimAmount(myFloat);

// Animal.getUpVector(partialTicks as float) as Vec3;
myAnimal.getUpVector(myFloat);

// Animal.getViewVector(partialTicks as float) as Vec3;
myAnimal.getViewVector(myFloat);

// Animal.getVisibilityPercent(lookingEntity as Entity) as double;
myAnimal.getVisibilityPercent(myEntity);

// Animal.getX(scale as double) as double;
myAnimal.getX(myDouble);

// Animal.getY(scale as double) as double;
myAnimal.getY(myDouble);

// Animal.getZ(scale as double) as double;
myAnimal.getZ(myDouble);

// Animal.handSlots as Iterable<ItemStack>
myAnimal.handSlots

// Animal.handSlots() as Iterable<ItemStack>;
myAnimal.handSlots();

// Animal.hasAttachmentData<T>(type as AttachmentType<T>) as bool;
myAnimal.hasAttachmentData<T>(myAttachmentType);

// Animal.hasAttachmentData<T>(type as Supplier<AttachmentType<T>>) as bool;
myAnimal.hasAttachmentData<T>(mySupplier);

// Animal.hasCustomName as bool
myAnimal.hasCustomName

// Animal.hasCustomName as bool
myAnimal.hasCustomName

// Animal.hasCustomName() as bool;
myAnimal.hasCustomName();

// Animal.hasCustomName() as bool;
myAnimal.hasCustomName();

// Animal.hasEffect(effect as MobEffect) as bool;
myAnimal.hasEffect(myMobEffect);

// Animal.hasExactlyOnePlayerPassenger as bool
myAnimal.hasExactlyOnePlayerPassenger

// Animal.hasExactlyOnePlayerPassenger() as bool;
myAnimal.hasExactlyOnePlayerPassenger();

// Animal.hasGlowingTag as bool
myAnimal.hasGlowingTag

// Animal.hasGlowingTag() as bool;
myAnimal.hasGlowingTag();

// Animal.hasIndirectPassenger(entity as Entity) as bool;
myAnimal.hasIndirectPassenger(myEntity);

// Animal.hasItemInSlot(slot as EquipmentSlot) as bool;
myAnimal.hasItemInSlot(myEquipmentSlot);

// Animal.hasLineOfSight(entity as Entity) as bool;
myAnimal.hasLineOfSight(myEntity);

// Animal.hasPassenger(entity as Entity) as bool;
myAnimal.hasPassenger(myEntity);

// Animal.hasPassenger(predicate as function(t as Entity) as bool) as bool;
myAnimal.hasPassenger(myPredicate);

// Animal.hasRestriction as bool
myAnimal.hasRestriction

// Animal.heal(amount as float);
myAnimal.heal(myFloat);

// Animal.health as float
myAnimal.health

// Animal.health() as float;
myAnimal.health();

// Animal.hurt(source as DamageSource, amount as float) as bool;
myAnimal.hurt(myDamageSource, myFloat);

// Animal.id as int
myAnimal.id

// Animal.id() as int;
myAnimal.id();

// Animal.inBlockState as BlockState
myAnimal.inBlockState

// Animal.inLoveTime as int
myAnimal.inLoveTime

// Animal.inLoveTime = (inLove as int);
myAnimal.inLoveTime = myInt;

// Animal.isAffectedByPotions as bool
myAnimal.isAffectedByPotions

// Animal.isAffectedByPotions() as bool;
myAnimal.isAffectedByPotions();

// Animal.isAlive as bool
myAnimal.isAlive

// Animal.isAlive() as bool;
myAnimal.isAlive();

// Animal.isAlwaysTicking as bool
myAnimal.isAlwaysTicking

// Animal.isAlwaysTicking() as bool;
myAnimal.isAlwaysTicking();

// Animal.isAttackable as bool
myAnimal.isAttackable

// Animal.isAttackable() as bool;
myAnimal.isAttackable();

// Animal.isAutoSpinAttack as bool
myAnimal.isAutoSpinAttack

// Animal.isAutoSpinAttack() as bool;
myAnimal.isAutoSpinAttack();

// Animal.isBaby as bool
myAnimal.isBaby

// Animal.isBaby() as bool;
myAnimal.isBaby();

// Animal.isBlocking as bool
myAnimal.isBlocking

// Animal.isBlocking() as bool;
myAnimal.isBlocking();

// Animal.isColliding(pos as BlockPos, state as BlockState) as bool;
myAnimal.isColliding(myBlockPos, myBlockState);

// Animal.isCrouching as bool
myAnimal.isCrouching

// Animal.isCrouching() as bool;
myAnimal.isCrouching();

// Animal.isCurrentlyGlowing as bool
myAnimal.isCurrentlyGlowing

// Animal.isCurrentlyGlowing as bool
myAnimal.isCurrentlyGlowing

// Animal.isCurrentlyGlowing() as bool;
myAnimal.isCurrentlyGlowing();

// Animal.isCurrentlyGlowing() as bool;
myAnimal.isCurrentlyGlowing();

// Animal.isCustomNameVisible as bool
myAnimal.isCustomNameVisible

// Animal.isCustomNameVisible() as bool;
myAnimal.isCustomNameVisible();

// Animal.isDamageSourceBlocked(source as DamageSource) as bool;
myAnimal.isDamageSourceBlocked(myDamageSource);

// Animal.isDeadOrDying as bool
myAnimal.isDeadOrDying

// Animal.isDeadOrDying() as bool;
myAnimal.isDeadOrDying();

// Animal.isDescending as bool
myAnimal.isDescending

// Animal.isDescending() as bool;
myAnimal.isDescending();

// Animal.isDiscrete as bool
myAnimal.isDiscrete

// Animal.isDiscrete() as bool;
myAnimal.isDiscrete();

// Animal.isFallFlying as bool
myAnimal.isFallFlying

// Animal.isFallFlying() as bool;
myAnimal.isFallFlying();

// Animal.isFood(stack as ItemStack) as bool;
myAnimal.isFood(myItemStack);

// Animal.isFree(x as double, y as double, z as double) as bool;
myAnimal.isFree(myDouble, myDouble, myDouble);

// Animal.isFullyFrozen as bool
myAnimal.isFullyFrozen

// Animal.isFullyFrozen() as bool;
myAnimal.isFullyFrozen();

// Animal.isHolding(item as ItemDefinition) as bool;
myAnimal.isHolding(myItem);

// Animal.isHolding(predicate as function(t as ItemStack) as bool) as bool;
myAnimal.isHolding(myPredicate);

// Animal.isInLava as bool
myAnimal.isInLava

// Animal.isInLava() as bool;
myAnimal.isInLava();

// Animal.isInLove as bool
myAnimal.isInLove

// Animal.isInvertedHealAndHarm as bool
myAnimal.isInvertedHealAndHarm

// Animal.isInvertedHealAndHarm() as bool;
myAnimal.isInvertedHealAndHarm();

// Animal.isInvisible as bool
myAnimal.isInvisible

// Animal.isInvisible() as bool;
myAnimal.isInvisible();

// Animal.isInvisibleTo(player as Player) as bool;
myAnimal.isInvisibleTo(myPlayer);

// Animal.isInvulnerable as bool
myAnimal.isInvulnerable

// Animal.isInvulnerable() as bool;
myAnimal.isInvulnerable();

// Animal.isInvulnerableTo(source as DamageSource) as bool;
myAnimal.isInvulnerableTo(myDamageSource);

// Animal.isInWall as bool
myAnimal.isInWall

// Animal.isInWall() as bool;
myAnimal.isInWall();