@airbreather/mod-nodejs-types 0.0.1

package/classes/Roll.d.ts

@@ -0,0 +1,14 @@
+declare global {
+	namespace Acore {
+		class Roll {
+			readonly rollId: number;
+			readonly rollType: RollMask;
+			readonly itemId: number;
+			readonly itemRandomPropId: number;
+			readonly itemSuffix: number;
+			readonly itemCount: number;
+			readonly isRollInProgress: boolean;
+		}
+	}
+}
+export {};

package/classes/Spell.d.ts

@@ -0,0 +1,18 @@
+declare global {
+	namespace Acore {
+		class Spell {
+			readonly spellInfo: SpellInfo;
+			readonly castTime: Temporal.Duration;
+			readonly powerCost: number;
+			readonly caster: Unit;
+			readonly targetDest: Position;
+			readonly target: WorldObject | Item | undefined;
+			isAutoRepeat: boolean;
+
+			cast(skipCheck?: boolean): void;
+			cancel(): void;
+			finish(): void;
+		}
+	}
+}
+export {};

package/classes/SpellChainNode.d.ts

@@ -0,0 +1,7 @@
+declare global {
+	namespace Acore {
+		class SpellChainNode {
+		}
+	}
+}
+export {};

package/classes/SpellEffectInfo.d.ts

@@ -0,0 +1,50 @@
+declare global {
+	namespace Acore {
+		class SpellEffectInfo {
+			readonly effectIndex: SpellEffIndex;
+			readonly effect: SpellEffects;
+			readonly applyAuraName: AuraType;
+			readonly amplitude: number;
+			readonly dieSides: number;
+			readonly realPointsPerLevel: number;
+			readonly basePoints: number;
+			readonly pointsPerComboPoint: number;
+			readonly valueMultiplier: number;
+			readonly damageMultiplier: number;
+			readonly bonusMultiplier: number;
+			readonly miscValue: number;
+			readonly miscValueB: number;
+			readonly mechanic: Mechanics;
+			readonly targetA: SpellImplicitTargetInfo;
+			readonly targetB: SpellImplicitTargetInfo;
+			readonly radiusEntry: SpellRadiusEntry;
+			readonly chainTarget: number;
+			readonly itemType: number; // item id
+			readonly triggerSpell: number; // spell id
+			readonly spellClassMask: bigint; // flag96
+			readonly implicitTargetConditions: Condition[] | undefined;
+			readonly isEffect: boolean;
+			readonly isAura: boolean;
+			readonly isTargetingArea: boolean;
+			readonly isAreaAuraEffect: boolean;
+			readonly isFarUnitTargetEffect: boolean;
+			readonly isFarDestTargetEffect: boolean;
+			readonly isUnitOwnedAuraEffect: boolean;
+			readonly hasRadius: boolean;
+			readonly providedTargetMask: SpellCastTargetFlags;
+			readonly implicitTargetType: SpellEffectImplicitTargetTypes;
+			readonly usedTargetObjectType: SpellTargetObjectTypes;
+			readonly immunityInfo: ImmunityInfo;
+
+			hasEffectOf(effect: SpellEffects): boolean;
+			appliesAura(aura: AuraType): boolean;
+			calcValue(caster?: Unit, basePoints?: number, target?: Unit): number;
+			calcBaseValue(value: number): number;
+			calcValueMultiplier(caster: Unit, spell?: Spell): number;
+			calcDamageMultiplier(caster: Unit, spell?: Spell): number;
+			calcRadius(caster: Unit, spell?: Spell): number;
+			getMissingTargetMask(srcSet?: boolean, destSet?: boolean, mask?: SpellCastTargetFlags): SpellCastTargetFlags;
+		}
+	}
+}
+export {};

package/classes/SpellImplicitTargetInfo.d.ts

@@ -0,0 +1,15 @@
+declare global {
+	namespace Acore {
+		class SpellImplicitTargetInfo {
+			readonly isArea: boolean;
+			readonly selectionCategory: SpellTargetSelectionCategories;
+			readonly referenceType: SpellTargetReferenceTypes;
+			readonly objectType: SpellTargetObjectTypes;
+			readonly checkType: SpellTargetCheckTypes;
+			readonly directionType: SpellTargetDirectionTypes;
+			readonly calcDirectionAngle: number;
+			readonly target: Targets;
+		}
+	}
+}
+export {};

package/classes/SpellInfo.d.ts

@@ -0,0 +1,200 @@
+// TODO: this should be 2x 32-bit fields because JavaScript is goofy sometimes.
+type MechanicsMask = bigint;
+
+// TODO: this should be 3x 32-bit fields like many other things are.
+// bonus points for making a realistic attempt at making enums for each
+type SpellFamilyFlagsMask = bigint;
+
+declare global {
+	namespace Acore {
+		class SpellInfo {
+			static bySpellId(id: number): SpellInfo;
+
+			readonly spellId: number;
+			readonly categoryEntry: SpellCategoryEntry | undefined;
+			readonly dispel: DispelType;
+			readonly mechanic: Mechanics;
+			readonly attributes: SpellAttr0;
+			readonly attributesEx: SpellAttr1;
+			readonly attributesEx2: SpellAttr2;
+			readonly attributesEx3: SpellAttr3;
+			readonly attributesEx4: SpellAttr4;
+			readonly attributesEx5: SpellAttr5;
+			readonly attributesEx6: SpellAttr6;
+			readonly attributesEx7: SpellAttr7;
+			readonly attributesCu: SpellCustomAttributes;
+			readonly stances: number;
+			readonly stancesNot: number;
+			readonly targets: SpellCastTargetFlags;
+			readonly targetCreatureType: CreatureTypeMask;
+			readonly requiresSpellFocus: number; // SpellFocusObject.dbc id
+			readonly facingCasterFlags: SpellFacingFlags;
+			readonly casterAuraState: AuraStateType;
+			readonly targetAuraState: AuraStateType;
+			readonly casterAuraStateNot: AuraStateType;
+			readonly targetAuraStateNot: AuraStateType;
+			readonly casterAuraSpell: number;
+			readonly targetAuraSpell: number;
+			readonly excludeCasterAuraSpell: number;
+			readonly excludeTargetAuraSpell: number;
+			readonly castTimeEntry: SpellCastTimesEntry | undefined;
+			// favor recoveryTime, which yields categoryRecoveryTime if that's longer
+			readonly recoveryTimeRaw: Temporal.Duration;
+			readonly categoryRecoveryTime: Temporal.Duration;
+			readonly startRecoveryCategory: number;
+			readonly startRecoveryTime: Temporal.Duration;
+			readonly interruptFlags: SpellInterruptFlags;
+			readonly auraInterruptFlags: SpellAuraInterruptFlags;
+			readonly channelInterruptFlags: SpellAuraInterruptFlags;
+			readonly procFlags: ProcFlags;
+			readonly procChance: number;
+			readonly procCharges: number;
+			readonly maxLevel: number;
+			readonly baseLevel: number;
+			readonly spellLevel: number;
+			readonly durationEntry: SpellDurationEntry | undefined;
+			readonly powerType: Powers;
+			readonly manaCost: number;
+			readonly manaCostPerlevel: number;
+			readonly manaPerSecond: number;
+			readonly manaPerSecondPerLevel: number;
+			readonly manaCostPercentage: number;
+			readonly runeCostID: number;
+			readonly rangeEntry: SpellRangeEntry | undefined;
+			readonly speed: number;
+			readonly stackAmount: number;
+			readonly totem: number[];
+			readonly reagent: number[];
+			readonly reagentCount: number[];
+			readonly equippedItemClass: ItemClass;
+			readonly equippedItemSubClassMask: ItemSubclassMask;
+			readonly equippedItemInventoryTypeMask: InventoryTypeMask;
+			readonly totemCategory: number[];
+			readonly spellVisual: number[];
+			readonly spellIconID: number;
+			readonly activeIconID: number;
+			readonly spellPriority: number;
+			readonly spellName: string[];
+			readonly rankName: string[];
+			readonly maxTargetLevel: number;
+			readonly maxAffectedTargets: number;
+			readonly spellFamilyName: SpellFamilyNames;
+			readonly spellFamilyFlags: SpellFamilyFlagsMask;
+			readonly dmgClass: SpellDmgClass;
+			readonly preventionType: SpellPreventionType;
+			readonly areaGroupId: number;
+			readonly schoolMask: SpellSchoolMask;
+			readonly effects: SpellEffectInfo[];
+			readonly explicitTargetMask: SpellCastTargetFlags;
+			readonly chainEntry: SpellChainNode | undefined;
+			readonly category: number; // 0 if categoryEntry is undefined
+			readonly isExplicitDiscovery: boolean;
+			readonly isLootCrafting: boolean;
+			readonly isQuestTame: boolean;
+			readonly isProfessionOrRiding: boolean;
+			readonly isProfession: boolean;
+			readonly isPrimaryProfession: boolean;
+			readonly isPrimaryProfessionFirstRank: boolean;
+			readonly isAbilityLearnedWithProfession: boolean;
+			readonly isAffectingArea: boolean;
+			readonly isTargetingArea: boolean;
+			readonly needsExplicitUnitTarget: boolean;
+			readonly isChannelCategorySpell: boolean;
+			readonly isSelfCast: boolean;
+			readonly isPassive: boolean;
+			readonly isAutocastable: boolean;
+			readonly isCritCapable: boolean;
+			readonly requireCooldownInfo: boolean;
+			readonly isStackableWithRanks: boolean;
+			readonly isPassiveStackableWithRanks: boolean;
+			readonly isMultiSlotAura: boolean;
+			readonly isCooldownStartedOnEvent: boolean;
+			readonly isDeathPersistent: boolean;
+			readonly isRequiringDeadTarget: boolean;
+			readonly isAllowingDeadTarget: boolean;
+			readonly isUsableInCombat: boolean;
+			readonly isPositive: boolean;
+			readonly isChanneled: boolean;
+			readonly isActionAllowedChannel: boolean;
+			readonly needsComboPoints: boolean;
+			readonly isBreakingStealth: boolean;
+			readonly isRangedWeaponSpell: boolean;
+			readonly isAutoRepeatRangedSpell: boolean;
+			readonly hasInitialAggro: boolean;
+			readonly isAffectedBySpellMods: boolean;
+			readonly isSingleTarget: boolean;
+			readonly allEffectsMechanicMask: MechanicsMask;
+			readonly hasAnyEffectMechanic: boolean;
+			readonly dispelMask: DispelTypeMask;
+			readonly auraState: AuraStateType;
+			readonly spellSpecific: SpellSpecificType;
+			readonly duration: Temporal.Duration;
+			readonly maxDuration: Temporal.Duration;
+			readonly maxTicks: number;
+			readonly recoveryTime: Temporal.Duration;
+			readonly isRanked: boolean;
+			readonly rank: number;
+			readonly firsRankSpell: SpellInfo | undefined;
+			readonly lastRankSpell: SpellInfo | undefined;
+			readonly nextRankSpell: SpellInfo | undefined;
+			readonly prevRankSpell: SpellInfo | undefined;
+			readonly hasAreaAuraEffect: boolean;
+
+			hasEffect(effect: SpellEffects): boolean;
+			hasAura(aura: AuraType): boolean;
+			isAbilityOfSkillType(skill: SkillType): boolean;
+			needsToBeTriggeredByCaster(trigger: SpellInfo, effectIndex?: SpellEffIndex): boolean;
+			isPositiveEffect(effectIndex: SpellEffIndex): boolean;
+			isAffected(familyName: SpellFamilyNames, familyFlags: SpellFamilyFlagsMask): boolean;
+			isAffectedBySpellMod(mod: SpellModifier): boolean;
+			canPierceImmuneAura(auraSpell: SpellInfo): boolean;
+			canDispelAura(auraSpell: SpellInfo): boolean;
+			applyAllSpellImmunitiesTo(target: Unit, effect: SpellEffectInfo, apply: boolean): void;
+			canSpellProvideImmunityAgainstAura(aura: SpellInfo): boolean;
+			canSpellCastOverrideAuraEffect(effect: AuraEffect): boolean;
+			isAuraExclusiveBySpecificWith(other: SpellInfo): boolean;
+			isAuraExclusiveBySpecificPerCasterWith(other: SpellInfo): boolean;
+			checkShapeshift(other: ShapeshiftForm): SpellCastResult;
+			checkLocation(mapId: number, zoneId: number, areaId: number, player?: Player, strict?: boolean): SpellCastResult;
+			checkTarget(caster: Unit, target: WorldObject, implicit?: boolean): SpellCastResult;
+			checkExplicitTarget(caster: Unit, target: WorldObject, itemTarget?: Item): SpellCastResult;
+			checkTargetCreatureType(target: Unit): boolean;
+			isAuraEffectEqual(other: SpellInfo): boolean;
+			validateAttribute6SpellDamageMods(caster: Unit, eff: AuraEffect, isDot: boolean): boolean;
+			getEffectMechanicMask(effectIndex: SpellEffIndex): MechanicsMask;
+			getSpellMechanicMaskByEffectMask(effectMask: SpellEffIndexMask): MechanicsMask;
+			getEffectMechanic(effectIndex: SpellEffIndex): Mechanics;
+			getImmunityInfo(effectIndex: SpellEffIndex): ImmunityInfo;
+			getMinRange(positive?: boolean): number;
+			getMaxRange(positive?: boolean, caster?: Unit, spell?: Spell): number;
+			calcCastTime(caster?: Unit, spell?: Spell): Temporal.Duration;
+			calcPowerCost(caster: Unit, schoolMask: SpellSchoolMask, spell?: Spell): number;
+			getAuraRankForLevel(level: number): number;
+			isRankOf(other: SpellInfo): boolean;
+			isDifferentRankOf(other: SpellInfo): boolean;
+			isHighRankOf(other: SpellInfo): boolean;
+			getEffect(i: SpellEffIndex): SpellEffectInfo | undefined;
+		}
+
+		type SpellInfoNarrowable = SpellInfo & (
+			| { equippedItemClass: ItemClass.ITEM_CLASS_ARMOR; equippedItemSubClassMask: ItemSubclassMaskArmor }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_CONSUMABLE; equippedItemSubClassMask: ItemSubclassMaskConsumable }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_CONTAINER; equippedItemSubClassMask: ItemSubclassMaskContainer }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_GEM; equippedItemSubClassMask: ItemSubclassMaskGem }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_GENERIC; equippedItemSubClassMask: ItemSubclassMaskGeneric }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_GLYPH; equippedItemSubClassMask: ItemSubclassMaskGlyph }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_MISC; equippedItemSubClassMask: ItemSubclassMaskJunk }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_KEY; equippedItemSubClassMask: ItemSubclassMaskKey }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_MONEY; equippedItemSubClassMask: ItemSubclassMaskMoney }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_PERMANENT; equippedItemSubClassMask: ItemSubclassMaskPermanent }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_PROJECTILE; equippedItemSubClassMask: ItemSubclassMaskProjectile }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_QUEST; equippedItemSubClassMask: ItemSubclassMaskQuest }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_QUIVER; equippedItemSubClassMask: ItemSubclassMaskQuiver }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_REAGENT; equippedItemSubClassMask: ItemSubclassMaskReagent }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_RECIPE; equippedItemSubClassMask: ItemSubclassMaskRecipe }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_TRADE_GOODS; equippedItemSubClassMask: ItemSubclassMaskTradeGoods }
+			| { equippedItemClass: ItemClass.ITEM_CLASS_WEAPON; equippedItemSubClassMask: ItemSubclassMaskWeapon }
+		)
+	}
+}
+export {};

package/classes/TempSummon.d.ts

@@ -0,0 +1,15 @@
+declare global {
+	namespace Acore {
+		class TempSummon extends Creature {
+			readonly summoner: WorldObject | undefined;
+			readonly properties: SummonPropertiesEntry | undefined;
+
+			isVisibleBySummonerOnly: boolean;
+			timer: Temporal.Duration;
+			summonType: TempSummonType;
+
+			unsummon(delay?: Temporal.Duration): void;
+		}
+	}
+}
+export {};

package/classes/ThreatReference.d.ts

@@ -0,0 +1,24 @@
+declare global {
+	namespace Acore {
+		class ThreatReference {
+			readonly owner: Creature;
+			readonly victim: Unit;
+			readonly threat: number;
+			readonly onlineState: OnlineState;
+			readonly isOnline: boolean;
+			readonly isAvailable: boolean;
+			readonly isSuppressed: boolean;
+			readonly isOffline: boolean;
+			readonly tauntState: TauntState;
+			readonly isTaunting: boolean;
+			readonly isDetaunted: boolean;
+
+			addThreat(amount: number): void;
+			scaleThreat(factor: number): void;
+			modifyThreatByPercent(percent: number): void;
+			updateOffline(): void;
+			clearThreatAndDestroyThisObject(): void;
+		}
+	}
+}
+export {};

package/classes/Transport.d.ts

@@ -0,0 +1,13 @@
+declare global {
+	namespace Acore {
+		class Transport extends GameObject {
+			readonly isMotionTransport: boolean;
+			readonly passengers: WorldObject[];
+
+			addPassenger(passenger: WorldObject, withAll?: boolean): void;
+			removePassenger(passenger: WorldObject, withAll?: boolean): void;
+			enableMovement(enabled: boolean): void;
+		}
+	}
+}
+export {};

package/classes/Unit.d.ts

@@ -0,0 +1,173 @@
+declare global {
+	namespace Acore {
+		class Unit extends WorldObject {
+			readonly gender: Gender;
+			readonly creatureType: CreatureType;
+			readonly healthPct: number;
+			readonly movementType: MovementGeneratorType;
+			readonly mountId: number;
+			readonly vehicle: Vehicle | undefined;
+			readonly isDying: boolean;
+			readonly victim: Unit | undefined;
+			readonly isAttackingPlayer: boolean;
+			readonly isStandState: boolean;
+			readonly charmGuid: ObjectGuid | undefined;
+			readonly charmerGuid: ObjectGuid | undefined;
+			readonly charmerOrOwnerGuid: ObjectGuid | undefined;
+			readonly charmerOrOwnerOrOwnGuid: ObjectGuid | undefined;
+			readonly owner: Unit | undefined;
+			readonly followAngle: number;
+			readonly isAlive: boolean;
+			readonly isDead: boolean;
+			readonly isInCombat: boolean;
+			readonly isMounted: boolean;
+			readonly isInWater: boolean;
+			readonly isUnderWater: boolean;
+			readonly isFlying: boolean;
+			readonly isFalling: boolean;
+			readonly isStopped: boolean;
+			readonly isCharmed: boolean;
+			readonly isFullHealth: boolean;
+			readonly isPvP: boolean;
+			readonly isOnVehicle: boolean;
+			readonly isArmorer: boolean;
+			readonly isAuctioneer: boolean;
+			readonly isBanker: boolean;
+			readonly isBattleMaster: boolean;
+			readonly isGossip: boolean;
+			readonly isGuildMaster: boolean;
+			readonly isInnkeeper: boolean;
+			readonly isQuestGiver: boolean;
+			readonly isServiceProvider: boolean;
+			readonly isSpiritGuide: boolean;
+			readonly isSpiritHealer: boolean;
+			readonly isSpiritService: boolean;
+			readonly isTabardDesigner: boolean;
+			readonly isTaxi: boolean;
+			readonly isTrainer: boolean;
+			readonly isVendor: boolean;
+			readonly comboTarget: Unit | undefined;
+			readonly isMoving: boolean;
+			readonly comboPoints: number;
+			readonly attackers: Unit[];
+			readonly unorderedThreatList: ThreatReference[];
+			// FactionTemplates in the C++ template has a bunch, but there's also things like
+			// KarazhanChessGameFactions, which are different numbers from what you'd expect, and
+			// magic number 2082 which seems to show up only in a Zul'Drak encounter with Drakuru.
+			faction: number;
+			health: number;
+			maxHealth: number;
+			displayId: number;
+			nativeDisplayId: number;
+			sheath: SheathState;
+			speedWalk: number;
+			speedRun: number;
+			speedSwim: number;
+			speedTurn: number;
+			level: number;
+			powerType: Powers;
+			isPvPFlagged: boolean;
+			standState: UnitStandStateType;
+			creatorGuid: ObjectGuid | undefined;
+			critterGuid: ObjectGuid | undefined;
+			ownerGuid: ObjectGuid | undefined;
+			petGuid: ObjectGuid | undefined;
+			isFFA: boolean;
+			isInSanctuary: boolean;
+			isRooted: boolean;
+			isConfused: boolean;
+			// sometimes aka feared
+			isFleeing: boolean;
+			emoteState: Emote;
+
+			getCurrentSpell(spellType?: CurrentSpellTypes): Spell | undefined;
+			isNonMeleeSpellCast(withDelayed: boolean, skipChanneled?: boolean, skipAutorepeat?: boolean, isAutoshoot?: boolean, skipInstant?: boolean): boolean;
+			getComboPointsOn(who: Unit): number;
+			getAura(spellId: number, caster?: ObjectGuid, itemCaster?: ObjectGuid, requiredEffectMask?: SpellEffIndexMask): Aura | undefined;
+			getStat(stat: Stats): number;
+			getPower(power: Powers): number;
+			getMaxPower(power: Powers): number;
+			getPowerPct(power: Powers): number;
+			getSpeed(type: UnitMoveType): number;
+			getSpeedRate(type: UnitMoveType): number;
+			getThreat(target: Unit, includeOffline?: boolean): number;
+			isInAccessiblePlaceFor(creature: Creature): boolean;
+			getFriendlyUnitsInRange(range: number): Unit[];
+			getUnfriendlyUnitsInRange(range: number): Unit[];
+			hasAura(spellId: number, caster?: ObjectGuid, itemCaster?: ObjectGuid, requiredEffectMask?: SpellEffIndexMask): boolean;
+			healthAbovePct(pct: number): boolean;
+			healthBelowPct(pct: number): boolean;
+			countPctFromCurHealth(amount: number): boolean;
+			countPctFromMaxHealth(amount: number): boolean;
+			getBaseSpellPower(spellSchool: SpellSchools): number;
+			hasUnitState(state: UnitState): boolean;
+			sendChatMessageToPlayer(type: ChatMsg, lang: Language, msg: string, target: Player): void;
+			demorph(): void;
+			dismount(): void;
+			performEmote(emote: Emote): void;
+			mount(mountDisplayId: number, vehicleId?: number, creatureEntry?: number): void;
+			stopSpellCast(spellId?: number): void;
+			// set withDelayed to true to interrupt delayed spells too<br>
+			// delayed+channeled spells are always interrupted
+			interruptNonMeleeSpells(withDelayed: boolean, spellId?: number, withInstant?: boolean, bySelf?: boolean): void;
+			removeAllAuras(): void;
+			removeArenaAuras(): void;
+			setFacingToObject(target: WorldObject, timed?: number): void;
+			setInCombatWith(target: Unit, addSecondUnitSuppressed?: boolean): void;
+			clearThreatList(): void;
+			addUnitState(state: UnitState): void;
+			clearUnitState(state: UnitState): void;
+			nearTeleportTo(x: number, y: number, z: number, o?: number, casting?: boolean, vehicleTeleport?: boolean, withPet?: boolean, removeTransport?: boolean): void;
+			addThreat(target: Unit, amount: number, spell?: SpellInfo, ignoreModifiers?: boolean, ignoreRedirects?: boolean): void;
+			modifyThreatByPercent(target: Unit, pct: number): void;
+			resetThreat(target: Unit): void;
+			resetAllThreat(): void;
+			modifyPower(powerType: Powers, amount: number, withPowerUpdate?: boolean): void;
+			moveStop(): void;
+			moveExpire(reset?: boolean): void;
+			moveClear(reset?: boolean): void;
+			moveFollow(target: Unit, distance?: number, angle?: number, slot?: MovementSlot, inheritWalkState?: boolean, inheritSpeed?: boolean): void;
+			moveChase(target: Unit, distance?: ChaseRange, angle?: ChaseAngle): void;
+			moveFleeing(enemy: Unit, time?: number): void;
+			moveJump(x: number, y: number, z: number, velXY: number, velZ: number, id?: number, target?: Unit): void;
+			moveConfused(): void;
+			clearComboPoints(): void;
+			addComboPoints(count: number): void;
+			addAura(spellId: number, target: Unit): void;
+			removeAura(spellId: number, caster?: ObjectGuid, requiredEffectMask?: SpellEffIndexMask, removeMode?: AuraRemoveMode): void;
+			kill(target: Unit, durabilityLoss?: boolean, attackType?: WeaponAttackType, spellProto?: SpellInfo, spell?: Spell): void;
+			clearInCombat(): void;
+			// TODO: use enums / alternate names / (overloads?) so the type checker can help a bit more.
+			// not doing that right now because it mirrors the C++ side anyway.
+			applySpellImmune(spellId: number, op: SpellImmunity, type: number, apply: boolean, blockType?: SpellImmuneBlockType): void;
+			setMaxPower(amt: number, type?: Powers): void;
+			setPower(amt: number, type?: Powers): void;
+			setSpeed(type: UnitMoveType, speed: number, forced?: boolean): void;
+			setSpeedRate(type: UnitMoveType, speed: number): void;
+			attack(target: Unit, meleeAttack: boolean): boolean;
+			attackStop(): boolean;
+			getFlatModifierValue(stat: UnitMods, type: UnitModifierFlatType): void;
+			getPctModifierValue(stat: UnitMods, type: UnitModifierPctType): void;
+			setStatFlatModifier(stat: UnitMods, type: UnitModifierFlatType, value: number): void;
+			setStatPctModifier(stat: UnitMods, type: UnitModifierPctType, value: number): void;
+			handleStatFlatModifier(stat: UnitMods, type: UnitModifierFlatType, value: number, apply: boolean): boolean;
+			// Usage outside of AuraEffect Handlers is discouraged as the value will be lost when auras change. Use an Aura instead.
+			applyStatPctModifier(stat: UnitMods, type: UnitModifierPctType, value: number): void;
+			sendUnitEmote(msg: string, receiver?: Unit, bossEmote?: boolean): void;
+			say(msg: string, language: Language): void;
+			yell(msg: string, language: Language): void;
+			whisper(msg: string, language: Language, target: Player): void;
+			bossWhisper(msg: string, language: Language, target: Player): void;
+			setDeathState(deathState: DeathState, despawn?: boolean): void;
+			setWalk(enable: boolean): void;
+			setDisableGravity(disable: boolean): void;
+			setSwim(enable: boolean): void;
+			setCanFly(enable: boolean): void;
+			setWaterWalking(enable: boolean): void;
+			setFeatherFall(enable: boolean): void;
+			setHover(enable: boolean): void;
+			buildCastSpell(spell: SpellInfo): CastSpellBuilder;
+		}
+	}
+}
+export {};

package/classes/Vehicle.d.ts

@@ -0,0 +1,15 @@
+declare global {
+	namespace Acore {
+		class Vehicle {
+			readonly entry: number;
+			readonly availableSeatCount: number;
+			readonly owner: Unit;
+
+			getPassenger(seat: number): WorldObject | undefined;
+			isOnBoard(passenger: Unit): boolean;
+			addPassenger(passenger: Unit, seatId?: number): void;
+			removePassenger(passenger: Unit): void;
+		}
+	}
+}
+export {};

package/classes/WorldObject.d.ts

@@ -0,0 +1,51 @@
+declare global {
+	namespace Acore {
+		class WorldObject extends ACObject {
+			readonly mapId: number;
+			readonly map: ACMap | undefined;
+			readonly zoneId: number;
+			readonly areaId: number;
+			readonly phaseMask: number;
+			readonly instanceId: number;
+			readonly location: Position;
+			readonly transport: Transport | undefined;
+			readonly sightRange: number;
+			name: string;
+
+			getNearestPlayer(range: number): Player | undefined;
+			getNearestCreature(range: number, entry?: number): Creature | undefined;
+			getNearestGameObject(range: number, entry?: number): GameObject | undefined;
+			getDistanceTo(target: WorldObject, only2d?: boolean, mustBeExact?: boolean): number;
+			getSightRangeTo(target: WorldObject): number;
+			getAngleTo(target: WorldObject): number;
+			isWithinLoSTo(target: WorldObject): boolean;
+			isWithinDistTo(target: WorldObject, dist: number, mustBeInSameMap?: boolean): boolean;
+			isInSameMapAs(target: WorldObject): boolean;
+			isWithinDist3d(x: number, y: number, z: number, dist: number): boolean;
+			isWithinDist2d(x: number, y: number, dist: number): boolean;
+			isInRangeTo(target: WorldObject, max: number, min?: number, only2d?: boolean): boolean;
+			isInFrontOf(target: WorldObject): boolean;
+			isInBackOf(target: WorldObject): boolean;
+			getRelativePoint(range: number, deg: number): number;
+			getNearObject(range: number): WorldObject | undefined;
+			getPlayersInRange(range: number): Player[];
+			getCreaturesInRange(range: number, entry?: number): Creature[];
+			getGameObjectsInRange(range: number, entry?: number): GameObject[];
+			getUnitsInRange(range: number): Unit[];
+			getNearObjects(range: number, mask?: NearObjectsMask): WorldObject[];
+			getNearObjects(range: number, mask?: NearObjectsMask): WorldObject[];
+			sendMessageToSet(packet: WorldPacket, self: boolean): void;
+			sendMessageToSetInRange(packet: WorldPacket, range: number): void;
+			sendMessageToSetExceptPlayer(packet: WorldPacket, skippedReceiver: Player): void;
+			playMusic(soundKitId: number, zoneWide?: boolean): void;
+			playDirectSound(soundId: number): void;
+			playDistanceSound(soundId: number): void;
+			// TODO: this is how they're defined today, but I think I want to make a breaking change before documenting them
+			// in a declaration file like this. if you're reading this and you are OK with having to update in a future
+			// version, feel free to uncomment and use them as written...
+			// summonGameObject(entry: number, x?: number, y?: number, z?: number, o?: number): GameObject | undefined;
+			// spawnCreature(entry: number, x?: number, y?: number, z?: number, o?: number): Creature | undefined;
+		}
+	}
+}
+export {};

package/classes/WorldPacket.d.ts

@@ -0,0 +1,8 @@
+declare global {
+	namespace Acore {
+		class WorldPacket extends ByteBuffer {
+			constructor(opcode?: number, sizeToReserve?: number);
+		}
+	}
+}
+export {};

package/classes/index.d.ts

@@ -0,0 +1,52 @@
+export * from './ACMap';
+export * from './ACObject';
+export * from './Auction';
+export * from './AuctionHouse';
+export * from './Aura';
+export * from './AuraApplication';
+export * from './AuraEffect';
+export * from './BattlegroundQueue';
+export * from './Battleground';
+export * from './ByteBuffer';
+export * from './CastSpellBuilder';
+export * from './ChatCommandBuilder';
+export * from './ChatHandler';
+export * from './Condition';
+export * from './ConditionSourceInfo';
+export * from './Config';
+export * from './Corpse';
+export * from './Creature';
+export * from './CreatureTemplate';
+export * from './DynamicObject';
+export * from './Field';
+export * from './GameObject';
+export * from './GmTicket';
+export * from './Group';
+export * from './Guardian';
+export * from './Guild';
+export * from './GuildMember';
+export * from './Item';
+export * from './ItemTemplate';
+export * from './Loot';
+export * from './LootStore';
+export * from './LootTemplate';
+export * from './MailDraft';
+export * from './MailSender';
+export * from './Minion';
+export * from './Pet';
+export * from './Player';
+export * from './QueryResult';
+export * from './Quest';
+export * from './Roll';
+export * from './Spell';
+export * from './SpellChainNode';
+export * from './SpellEffectInfo';
+export * from './SpellImplicitTargetInfo';
+export * from './SpellInfo';
+export * from './TempSummon';
+export * from './ThreatReference';
+export * from './Transport';
+export * from './Unit';
+export * from './Vehicle';
+export * from './WorldObject';
+export * from './WorldPacket';