@airbreather/mod-nodejs-types 0.0.1

package/classes/Field.d.ts

@@ -0,0 +1,23 @@
+declare global {
+	namespace Acore {
+		class Field {
+			readonly fieldType: DatabaseFieldTypes;
+			readonly isNull: boolean;
+
+			getBool(): boolean;
+			getU8(): number;
+			getI8(): number;
+			getU16(): number;
+			getI16(): number;
+			getU32(): number;
+			getI32(): number;
+			getU64(): number | bigint;
+			getI64(): number | bigint;
+			getF32(): number;
+			getF64(): number;
+			getString(): string;
+			getBinary(): Uint8Array<ArrayBuffer>;
+		}
+	}
+}
+export {};

package/classes/GameObject.d.ts

@@ -0,0 +1,36 @@
+declare global {
+	namespace Acore {
+		class GameObject extends WorldObject {
+			readonly mapId: number;
+			readonly isSpawned: boolean;
+			readonly isTransport: boolean;
+			readonly isActive: boolean;
+			readonly displayId: number;
+			readonly lootState: LootState;
+			readonly spawnId: number;
+			// readonly lootRecipientGuid: ObjectGuidNative; // not in the core PR yet.
+			readonly lootRecipient: Player | undefined;
+			// readonly lootRecipientGroupId: number; // not in the core PR yet.
+			readonly lootRecipientGroup: Group | undefined;
+			goState: GOState;
+			nextAbsoluteRespawnTime: Temporal.Instant;
+			ownerGuid: ObjectGuid | undefined;
+			spellId: number;
+			isSpawnedByDefault: boolean;
+
+			setLootState(lootState: LootState, unit?: Unit): void;
+			useDoorOrButton(timeToRestore?: Temporal.Duration, alternative?: boolean, user?: Unit): void;
+			despawn(): void;
+			despawnOrUnsummon(timeToDespawn?: Temporal.Duration, forcedRespawnTimer?: Temporal.Duration): void;
+			respawn(): void;
+			refresh(): void;
+			saveToDB(saveAddon?: boolean): void;
+			saveToDBExtra(mapId: number, spawnMask: number, phaseMask: number, saveAddon?: boolean): void;
+			// mod-nodejs inventions: SetRespawnTime and SetRespawnDelay names confuse me greatly. when I
+			// worked out what they were, I thought of better names and a nicer way to handle the former.
+			setTimeUntilNextRespawn(delay: Temporal.Duration): void;
+			setTimeBetweenRespawns(delay: Temporal.Duration): void;
+		}
+	}
+}
+export {};

package/classes/GmTicket.d.ts

@@ -0,0 +1,24 @@
+declare global {
+	namespace Acore {
+		class GmTicket {
+			readonly ticketId: number;
+			readonly lastModifiedTime: Temporal.Instant;
+			readonly escalatedStatus: GMTicketEscalationStatus;
+			readonly playerName: string;
+			readonly assignedGmName: string | undefined;
+			readonly isClosed: boolean;
+			readonly isCompleted: boolean;
+			readonly isAssigned: boolean;
+			readonly response: string;
+			readonly chatLog: string;
+			message: string;
+			assignedToGuid: ObjectGuid | undefined;
+
+			appendResponse(response: string): void;
+			deleteResponse(): void;
+			setViewed(): void;
+			setCompleted(): void;
+		}
+	}
+}
+export {};

package/classes/Group.d.ts

@@ -0,0 +1,28 @@
+declare global {
+	namespace Acore {
+		class Group {
+			readonly isRaid: boolean;
+			readonly isLFG: boolean;
+			readonly isBG: boolean;
+			readonly isFull: boolean;
+			readonly leaderName: string;
+			readonly guid: ObjectGuidNative;
+			readonly memberCount: number;
+			readonly groupType: GroupType;
+			readonly members: GroupMember[];
+			leaderGuid: ObjectGuid;
+
+			hasFreeSlotInSubgroup(subgroup: number): boolean;
+			disband(): void;
+			convertToRaid(): void;
+			changeSubgroup(member: ObjectGuid, subgroup: number): void;
+			setTargetIcon(icon: TargetIcon, setBy: ObjectGuid | undefined, target: ObjectGuid | undefined): void;
+			addMember(player: Player, roles?: LfgRoles): boolean;
+			removeMember(member: ObjectGuid, method?: RemoveMethod, kicker?: ObjectGuid, reason?: string): void;
+			setAssistant(player: ObjectGuid): void;
+			removeAssistant(member: ObjectGuid): void;
+			sendPacket(packet: WorldPacket, ignorePlayersInBG?: boolean, subgroup?: number, ignorePlayer?: ObjectGuid): void;
+		}
+	}
+}
+export {};

package/classes/Guardian.d.ts

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

package/classes/Guild.d.ts

@@ -0,0 +1,28 @@
+declare global {
+	namespace Acore {
+		class Guild {
+			static byLeaderGuid(guid: ObjectGuid): Guild | undefined;
+			static byName(name: string): Guild | undefined;
+			static byId(id: number): Guild | undefined;
+
+			readonly id: number;
+			readonly leaderGuid: ObjectGuidNative;
+			readonly memberCount: GuildMember[];
+			readonly members: number;
+			readonly totalBankMoney: number | bigint;
+			readonly createdDate: Temporal.Instant;
+			name: string;
+			motd: string;
+			info: string;
+
+			getMemberByGuid(guid: ObjectGuid): GuildMember | undefined;
+			getMemberByName(name: string): GuildMember | undefined;
+			addMember(guid: ObjectGuid, rank?: GuildDefaultRanks | number): void;
+			removeMember(guid: ObjectGuid, kicked?: boolean): void;
+			disband(): void;
+			modifyBankMoney(money: number | bigint): boolean;
+			// more to come, see the TODOs on the C++ side.
+		}
+	}
+}
+export {};

package/classes/GuildMember.d.ts

@@ -0,0 +1,25 @@
+declare global {
+	namespace Acore {
+		class GuildMember {
+			readonly playerGuid: ObjectGuidNative;
+			readonly playerName: string;
+			readonly clazz: Classes;
+			readonly level: number;
+			readonly gender: Gender;
+			readonly accountId: number;
+			readonly logoutTime: Temporal.Instant;
+			readonly flags: GuildMemberFlags;
+			readonly zoneId: number;
+			readonly isOnline: boolean;
+			readonly remainingWithdrawalAllowedTodayTotal: number;
+			rankId: GuildDefaultRanks | number;
+			publicNote: string;
+			officerNote: string;
+
+			remainingWithdrawalAllowedTodayOnTab(tab: number): number;
+			refresh(): void;
+			updateLogoutTime(): void;
+		}
+	}
+}
+export {};

package/classes/Item.d.ts

@@ -0,0 +1,41 @@
+declare global {
+	namespace Acore {
+		class Item extends ACObject {
+			readonly isBoundAccountWide: boolean;
+			readonly isBoundByEnchant: boolean;
+			readonly isLocked: boolean;
+			readonly isBag: boolean;
+			readonly isCurrencyToken: boolean;
+			readonly isNotEmptyBag: boolean;
+			readonly isBroken: boolean;
+			readonly isInTrade: boolean;
+			readonly isInBag: boolean;
+			readonly isEquipped: boolean;
+			readonly isPotion: boolean;
+			readonly isWeaponVellum: boolean;
+			readonly isArmorVellum: boolean;
+			readonly isConjuredConsumable: boolean;
+			readonly isRefundExpired: boolean;
+			readonly maxStackCount: number;
+			readonly slot: number;
+			readonly bagSlot: number;
+			readonly template: ItemTemplateNarrowable;
+			readonly bagSize: number;
+			ownerGuid: ObjectGuid;
+			count: number;
+			isSoulBound: boolean;
+
+			hasQuest(questId: number): boolean;
+			getEnchantmentId(slot: EnchantmentSlot): number;
+			canBeTraded(mail?: boolean, trade?: boolean): boolean;
+			isBindedNotWith(player: Player): boolean;
+			getItemLinkText(locale?: LocaleConstant): string;
+			setEnchantment(slot: EnchantmentSlot, enchantmentId: number, duration: number, charges: number, caster?: ObjectGuid): boolean;
+			clearEnchantment(slot: EnchantmentSlot): boolean;
+			setRandomProperties(prop: number): void;
+			setRandomSuffix(suffix: number): void;
+			save(): void;
+		}
+	}
+}
+export {};

package/classes/ItemTemplate.d.ts

@@ -0,0 +1,123 @@
+declare global {
+	namespace Acore {
+		class ItemTemplate {
+			readonly itemId: number;
+			readonly clazz: ItemClass;
+			readonly subClass: ItemSubclass;
+			readonly soundOverrideSubclass: number; // < 0: id from ItemSubClass.dbc, used to override weapon sound from actual SubClass
+			readonly name1: string;
+			readonly displayInfoId: number; // id from ItemDisplayInfo.dbc
+			readonly quality: ItemQualities;
+			readonly flags: ItemFlags;
+			readonly flags2: ItemFlags2;
+			readonly buyCount: number;
+			readonly buyPrice: number;
+			readonly sellPrice: number;
+			readonly inventoryType: InventoryType;
+			readonly allowableClass: number; // bitmask of (1 << Classes) values
+			readonly allowableRace: number; // bitmask of (1 << Races) values
+			readonly itemLevel: number;
+			readonly requiredLevel: number;
+			readonly requiredSkill: number; // id from SkillLine.dbc
+			readonly requiredSkillRank: number;
+			readonly requiredSpell: number; // id from Spell.dbc
+			readonly requiredHonorRank: number;
+			readonly requiredCityRank: number;
+			readonly requiredReputationFaction: number; // id from Faction.dbc
+			readonly requiredReputationRank: ReputationRank;
+			readonly maxCount: number; // <= 0: no limit
+			readonly stackable: number; // 0: not allowed, -1: put in player coin info tab and don't limit stacking (so 1 slot)
+			readonly containerSlots: number;
+			readonly statsCount: number;
+			readonly itemStat: ItemStat[];
+			readonly scalingStatDistribution: number; // id from ScalingStatDistribution.dbc
+			readonly scalingStatValue: number; // mask for selecting column in ScalingStatValues.dbc
+			readonly damage: ItemDamage[];
+			readonly armor: number;
+			readonly holyRes: number;
+			readonly fireRes: number;
+			readonly natureRes: number;
+			readonly frostRes: number;
+			readonly shadowRes: number;
+			readonly arcaneRes: number;
+			readonly delay: Temporal.Duration;
+			readonly ammoType: ItemSubclassProjectile;
+			readonly rangedModRange: number;
+			readonly spells: ItemSpell[];
+			readonly bonding: ItemBondingType;
+			readonly description: string;
+			readonly pageText: number;
+			readonly languageId: number;
+			readonly pageMaterial: number;
+			readonly startQuest: number; // id from QuestCache.wdb
+			readonly lockId: number;
+			readonly material: number; // id from Material.dbc
+			readonly sheath: number; // MIGHT be the enum SheathTypes? unsure
+			readonly randomProperty: number; // id from ItemRandomProperties.dbc
+			readonly randomSuffix: number; // id from ItemRandomSuffix.dbc
+			readonly block: number;
+			readonly itemSet: number; // id from ItemSet.dbc
+			readonly maxDurability: number;
+			readonly area: number; // id from AreaTable.dbc
+			readonly map: number; // id from Map.dbc
+			readonly bagFamily: BAG_FAMILY_MASK; // bit mask (1 << id from ItemBagFamily.dbc)
+			readonly totemCategory: number; // id from TotemCategory.dbc
+			readonly socket: ItemSocket[];
+			readonly socketBonus: number; // id from SpellItemEnchantment.dbc
+			readonly gemProperties: number; // id from GemProperties.dbc
+			readonly requiredDisenchantSkill: number;
+			readonly armorDamageModifier: number;
+			readonly duration: Temporal.Duration;
+			readonly itemLimitCategory: number; // id from ItemLimitCategory.dbc
+			readonly holidayId: HolidayIds;
+			readonly scriptId: number;
+			readonly disenchantID: number;
+			readonly foodType: PetDiet;
+			readonly minMoneyLoot: number;
+			readonly maxMoneyLoot: number;
+			readonly flagsCu: ItemFlagsCustom;
+			readonly hasSignature: boolean;
+			readonly canChangeEquipStateInCombat: boolean;
+			readonly isCurrencyToken: boolean;
+			readonly maxStackSize: number;
+			readonly dps: number;
+			readonly skill: SkillType; // TODO: separate enum for the subset that this can ACTUALLY return
+			readonly isPotion: boolean;
+			readonly isWeaponVellum: boolean;
+			readonly isArmorVellum: boolean;
+			readonly isConjuredConsumable: boolean;
+			readonly hasSpellPowerStat: boolean;
+
+			getFeralBonus(extraDps?: number): number;
+			getItemLevelIncludingQuality(playerLevel: number): number;
+			hasStat(stat: ItemModType): boolean;
+			hasFlag(flag: ItemFlags): boolean;
+			hasFlag2(flag: ItemFlags2): boolean;
+			hasFlagCu(flag: ItemFlagsCustom): boolean;
+		}
+
+		// technically there's only ItemTemplate at runtime, but the subclasses have overlapping values
+		// with different meanings depending on the class value - which is something that TypeScript has
+		// a very specific, very powerful tool to help use it correctly.
+		type ItemTemplateNarrowable = ItemTemplate & (
+			| { clazz: ItemClass.ITEM_CLASS_ARMOR; subclass: ItemSubclassArmor }
+			| { clazz: ItemClass.ITEM_CLASS_CONSUMABLE; subclass: ItemSubclassConsumable }
+			| { clazz: ItemClass.ITEM_CLASS_CONTAINER; subclass: ItemSubclassContainer }
+			| { clazz: ItemClass.ITEM_CLASS_GEM; subclass: ItemSubclassGem }
+			| { clazz: ItemClass.ITEM_CLASS_GENERIC; subclass: ItemSubclassGeneric }
+			| { clazz: ItemClass.ITEM_CLASS_GLYPH; subclass: ItemSubclassGlyph }
+			| { clazz: ItemClass.ITEM_CLASS_MISC; subclass: ItemSubclassJunk }
+			| { clazz: ItemClass.ITEM_CLASS_KEY; subclass: ItemSubclassKey }
+			| { clazz: ItemClass.ITEM_CLASS_MONEY; subclass: ItemSubclassMoney }
+			| { clazz: ItemClass.ITEM_CLASS_PERMANENT; subclass: ItemSubclassPermanent }
+			| { clazz: ItemClass.ITEM_CLASS_PROJECTILE; subclass: ItemSubclassProjectile }
+			| { clazz: ItemClass.ITEM_CLASS_QUEST; subclass: ItemSubclassQuest }
+			| { clazz: ItemClass.ITEM_CLASS_QUIVER; subclass: ItemSubclassQuiver }
+			| { clazz: ItemClass.ITEM_CLASS_REAGENT; subclass: ItemSubclassReagent }
+			| { clazz: ItemClass.ITEM_CLASS_RECIPE; subclass: ItemSubclassRecipe }
+			| { clazz: ItemClass.ITEM_CLASS_TRADE_GOODS; subclass: ItemSubclassTradeGoods }
+			| { clazz: ItemClass.ITEM_CLASS_WEAPON; subclass: ItemSubclassWeapon }
+		);
+	}
+}
+export {};

package/classes/Loot.d.ts

@@ -0,0 +1,29 @@
+declare global {
+	namespace Acore {
+		class Loot {
+			readonly itemCount: number;
+			readonly isLooted: boolean;
+			readonly isEmpty: boolean;
+			readonly hasQuestItems: boolean;
+			readonly hasItemForAll: boolean;
+			readonly hasOverThresholdItem: boolean;
+			readonly items: LootItem[];
+			readonly questItems: LootItem[];
+			lootType: LootType;
+			unlootedCount: number;
+			gold: number;
+			// SOME of these `| undefined` MAY be incorrect. SOME of them are DEFINITELY correct.
+			roundRobinPlayer: ObjectGuidNative | undefined;
+			lootOwnerGuid: ObjectGuidNative | undefined;
+			containerGuid: ObjectGuidNative | undefined;
+			sourceWorldObjectGuid: ObjectGuidNative | undefined;
+
+			addItem(itemId: number, minCount: number, maxCount: number, chance: number, lootMode: LootModes, needsQuest?: boolean, allowStacking?: boolean, maxStackSize?: number): void;
+			clear(): void;
+			generateMoney(min: number, max: number): void;
+			addLooter(looter: ObjectGuid): void;
+			removeLooter(looter: ObjectGuid): void;
+		}
+	}
+}
+export {};

package/classes/LootStore.d.ts

@@ -0,0 +1,16 @@
+declare global {
+	namespace Acore {
+		class LootStore {
+			readonly name: string;
+			readonly entryName: string;
+			readonly ratesAllowed: boolean;
+
+			haveLootFor(lootId: number): boolean;
+			haveQuestLootFor(lootId: number, player?: Player): boolean;
+			getLootFor(lootId: number): LootTemplate;
+		}
+
+		type LootStoreArg = LootStore | LootStoreType;
+	}
+}
+export {};

package/classes/LootTemplate.d.ts

@@ -0,0 +1,8 @@
+declare global {
+	namespace Acore {
+		class LootTemplate {
+			process(loot: Loot, lootStore: LootStore, lootMode: LootModes, player: Player, groupId?: number, isTopLevel?: boolean): void;
+		}
+	}
+}
+export {};

package/classes/MailDraft.d.ts

@@ -0,0 +1,15 @@
+declare global {
+	namespace Acore {
+		class MailDraft {
+			constructor(subject: string, text: string);
+
+			addMoney(money: number): MailDraft;
+			addCOD(money: number): MailDraft;
+			addItem(item: Item): MailDraft;
+			createAndAddItem(entry: number, amount?: number): ObjectGuid;
+			send(receiver: ObjectGuid, sender: MailSender, checked?: MailCheckedMask, deliverDelay?: number, customExpiration?: number): void;
+			sendReturnToSender(senderAccount: number, sender: ObjectGuid, receiver: ObjectGuid): void;
+		}
+	}
+}
+export {};

package/classes/MailSender.d.ts

@@ -0,0 +1,24 @@
+declare global {
+	namespace Acore {
+		class MailSender {
+			constructor(messageType: MailMessageType, sender: number, stationery?: MailStationery);
+
+			readonly messageType: MailMessageType;
+			// creature's entry,
+			// game object's entry,
+			// player's ObjectGuid's counter,
+			// {@link AuctionHouseId}, or
+			// calendar entry's id (truncated to 32 bits for some reason)
+			readonly senderId: number;
+			readonly stationery: MailStationery;
+
+			static thePostmaster(stationery?: MailStationery): MailSender;
+			static forCreature(entry: number, stationery?: MailStationery): MailSender;
+			static forPlayer(guid: ObjectGuid, stationery?: MailStationery): MailSender;
+			static forGameObject(entry: number, stationery?: MailStationery): MailSender;
+			static forAuctionHouse(id: AuctionHouseId, stationery?: MailStationery): MailSender;
+			static forCalendarEvent(entry: number, stationery?: MailStationery): MailSender;
+		}
+	}
+}
+export {};

package/classes/Minion.d.ts

@@ -0,0 +1,12 @@
+declare global {
+	namespace Acore {
+		class Minion extends TempSummon {
+			readonly owner: Unit;
+			readonly isPetGhoul: boolean;
+			readonly isGuardianPet: boolean;
+
+			followAngle: number;
+		}
+	}
+}
+export {};

package/classes/Pet.d.ts

@@ -0,0 +1,18 @@
+declare global {
+	namespace Acore {
+		class Pet extends Guardian {
+			readonly isHappy: boolean;
+			readonly owner: Player;
+			readonly isControlled: boolean;
+			readonly isTemporary: boolean;
+			readonly hasTempSpell: boolean;
+			readonly autoSpellSize: number;
+			readonly petInfo: PetInfo;
+			readonly spells: Map<number, PetSpellState>;
+			readonly autospells: number[];
+			readonly usedTalentCount: number;
+			readonly declinedNames: string[];
+		}
+	}
+}
+export {};

package/classes/Player.d.ts

@@ -0,0 +1,156 @@
+declare global {
+	namespace Acore {
+		class Player extends Unit {
+			readonly race: Races;
+			readonly raceMask: number;
+			readonly clazz: Classes;
+			readonly classMask: number;
+			readonly teamId: TeamId;
+			readonly guildId: number;
+			readonly isInGroup: boolean;
+			readonly isInGuild: boolean;
+			readonly isRested: boolean;
+			readonly hasCorpse: boolean;
+			readonly isMaxLevel: boolean;
+			readonly activeSpec: number;
+			readonly specsCount: number;
+			readonly restBonus: number;
+			readonly xp: number;
+			readonly battlegroundTypeId: BattlegroundTypeId;
+			readonly gmRank: AccountTypes;
+			readonly accountId: number;
+			readonly accountFlags: AccountFlag;
+			readonly accountName: string;
+			readonly completedQuestsCount: number;
+			readonly corpse: Corpse | undefined;
+			readonly playerIP: string;
+			readonly mailCount: number;
+			readonly mostPointsTalentTree: number;
+			readonly group: Group | undefined;
+			readonly difficulty: Difficulty;
+			readonly inventoryFreeSlots: number;
+			readonly canSpeak: boolean;
+			readonly canUninviteFromGroup: boolean;
+			readonly inBattlegroundQueue: boolean;
+			readonly inArena: boolean;
+			readonly inBattleground: boolean;
+			readonly hasTankSpec: boolean;
+			readonly hasMeleeSpec: boolean;
+			readonly hasCasterSpec: boolean;
+			readonly hasHealSpec: boolean;
+			readonly hasPet: boolean;
+			readonly canTameExoticPets: boolean;
+			readonly canPetResurrect: boolean;
+			readonly canResummonPet: boolean;
+			readonly inRandomLfgDungeon: boolean;
+			readonly isUsingLfg: boolean;
+			readonly achievementPoints: number;
+			readonly dodgeFromAgility: number;
+			readonly meleeCritFromAgility: number;
+			readonly spellCritFromIntellect: number;
+			readonly ammoDPS: number;
+			readonly canSeeDKPet: boolean;
+			readonly isImmuneToDamage: boolean;
+			readonly battlegroundId: number;
+			readonly championingFactionId: number;
+			readonly chatTag: PlayerChatTag;
+			readonly dbLocaleIndex: LocaleConstant;
+			readonly dbcLocale: LocaleConstant;
+			readonly latency: Temporal.Duration;
+			readonly groupInvite: Group | undefined;
+			/**
+			 * Keeping this for parity with C++, but it has a weak name and an awkward type.
+			 *
+			 * Some may prefer the mod-nodejs invention {@link loginTimestamp} instead.
+			 */
+			readonly inGameTime: number;
+			readonly loginTimestamp: Temporal.Instant;
+			readonly healthBonusFromStamina: number;
+			readonly manaBonusFromIntellect: number;
+			readonly originalGroup: number
+			readonly originalSubGroup: number;
+			// used for proper set phase for DB at GM-mode creature/GO spawn
+			readonly phaseMaskForSpawn: number;
+			readonly selectedPlayer: Player | undefined;
+			readonly selectedUnit: Unit | undefined;
+			readonly shield: Item | undefined;
+			readonly shieldBlockValue: number;
+			readonly subGroup: number;
+			readonly todayHonorPoints: number;
+			readonly todayKills: number;
+			readonly trader: Player | undefined;
+			readonly yesterdayHonorPoints: number;
+			readonly yesterdayKills: number;
+			readonly recruiterId: number;
+			readonly bankFreeSlots: number;
+			readonly levelPlayedTime: Temporal.Duration;
+			readonly averageItemLevel: number;
+			readonly totalPlayedTime: Temporal.Duration;
+			readonly guildName: string;
+			readonly runesState: number;
+			// false if mod_playerbots is not installed
+			readonly isBot: boolean;
+			readonly isHorde: boolean;
+			readonly isAlliance: boolean;
+			readonly isInArena: boolean;
+			readonly isInBattleground: boolean;
+			readonly isInBattlegroundQueue: boolean;
+			readonly canTitanGrip: boolean;
+			readonly pet: Pet | undefined;
+			readonly homebind: Homebind;
+			readonly talentTreePoints: number[];
+			readonly completedAchievementsCount: number;
+			readonly completedAchievementsCountExcludingFeatsOfStrength: number;
+
+			static byGuid(guid: ObjectGuid): Player | undefined;
+			static byName(name: string): Player | undefined;
+			static allInWorld(): Player[];
+
+			hasAccountFlag(flag: AccountFlag): boolean;
+			setAccountFlag(flag: AccountFlag): boolean;
+			clearAccountFlag(flag: AccountFlag): boolean;
+			resetTalentsCost(): void;
+			getRaceAsString(locale?: LocaleConstant): string;
+			getClassAsString(locale?: LocaleConstant): string;
+			hasSpell(spellId: number): boolean;
+			hasQuest(questId: number): boolean;
+			hasItemCount(itemId: number, count?: number, checkBank?: false): boolean;
+			getItemCount(itemId: number, checkBank?: false, skipItem?: Item): number;
+			getReputationWith(factionId: number): number;
+			getReputationRankWith(factionId: number): ReputationRank;
+			getQuestStatus(questId: number): QuestStatus;
+			// TODO: verify correctness
+			getEquippedItemBySlot(slot: number): Item | undefined;
+			// TODO: verify correctness
+			getInventoryItem(slot: number): Item | undefined;
+			// TODO: verify correctness
+			getBankItem(slot: number): Item | undefined;
+			getBarberShopCost(hairstyle: number, haircolor: number, facialhair: number, skincolor?: number): number;
+			getSkillValue(skill: SkillType): number;
+			getMaxSkillValue(skill: SkillType): number;
+			hasTalent(talentId: number, spec?: number): boolean;
+			hasAchieved(achievementId: number): boolean;
+			hasQuestForItem(itemId: number, excludeQuestId?: number, turnIn?: boolean, showInLoot?: Box<boolean>): boolean;
+			canUseItem(itemId: number): boolean;
+			hasSpellCooldown(spellId: number): boolean;
+			canShareQuest(questId: number): boolean;
+			isGroupVisibleFor(player: Player): boolean;
+			isInSameRaidWith(player: Player): boolean;
+			isInSameGroupWith(player: Player): boolean;
+			isHonorOrXPTarget(target: Unit): boolean;
+			isVisibleFor(player: Player): boolean;
+			hasKnownTaxiNode(nodeId: number): boolean;
+			isAtGroupRewardDistanceFor(target: Unit): boolean;
+			isAtLootRewardDistanceFor(target: Unit): boolean;
+			canEquipNewItem(itemId: number, slot: number, swap: boolean): boolean;
+			isDailyQuestDone(quest: Quest): boolean;
+			canSeeStartQuest(quest: Quest): boolean;
+			canInteractWithQuestGiver(target: WorldObject): boolean;
+			hasArmorProficiency(armor: ItemSubclassArmor): boolean;
+			hasWeaponProficiency(weapon: ItemSubclassWeapon): boolean;
+			getGlyph(slot: number): GlyphPropertiesEntry | undefined;
+			sendSystemMessage(msg: string): void;
+		}
+	}
+}
+export {};

package/classes/QueryResult.d.ts

@@ -0,0 +1,14 @@
+declare global {
+	namespace Acore {
+		class QueryResult {
+			readonly rowCount: number;
+			readonly fieldCount: number;
+			readonly allFields: Field[];
+
+			getFieldName(i: number): string;
+			getField(i: number): Field;
+			nextRow(): boolean;
+		}
+	}
+}
+export {};

package/classes/Quest.d.ts

@@ -0,0 +1,21 @@
+declare global {
+	namespace Acore {
+		class Quest {
+			static byId(id: number): Quest | undefined;
+
+			readonly questId: number;
+			readonly questType: QuestTypes;
+			readonly level: number;
+			readonly logTitle: string;
+			readonly objectiveText: string;
+			readonly objectiveDescription: string;
+			readonly areaDescription: string;
+			readonly startAreaId: number;
+			readonly rewardSpell: number;
+			readonly isRepeatable: boolean;
+			readonly isDaily: boolean;
+			readonly isWeekly: boolean;
+		}
+	}
+}
+export {};