@airbreather/mod-nodejs-types 0.0.1

package/acore.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter } from 'node:events';
+
+type HooksConforming = {
+	[K in keyof Hooks]: [Hooks[K]];
+};
+
+declare global {
+	namespace Acore {
+		const hooks: EventEmitter<HooksConforming>;
+
+		function gc(): void;
+		function guidsEqual(a: ObjectGuid | undefined, b: ObjectGuid | undefined): boolean;
+		function decodeGuid(g: ObjectGuid | undefined): ObjectGuidDecoded;
+		function getCurrTime(): Temporal.Instant;
+		function getTimeDiff(before: Temporal.Instant): Temporal.Duration;
+		function isGameEventActive(id: number): boolean;
+		function dbQuery(db: Db, q: string): QueryResult;
+		function dbQueryAsync(db: Db, q: string): Promise<QueryResult>;
+		function dbNonQuery(db: Db, q: string): void;
+		function inTransaction(db: Db, f: () => void): void;
+		function log(level: LogLevel, filter: string, msg: string): void;
+		function logTrace(filter: string, msg: string): void;
+		function logDebug(filter: string, msg: string): void;
+		function logInfo(filter: string, msg: string): void;
+		function logWarn(filter: string, msg: string): void;
+		function logError(filter: string, msg: string): void;
+		function logFatal(filter: string, msg: string): void;
+		function runCommandAsync(cmd: string, flush?: boolean): Promise<boolean>;
+		function saveAllPlayers(): void;
+		function box<T>(val: T): Box<T>;
+		function registerCommand(command: ChatCommandBuilder): void;
+		function shutdown(time: number, optionsMask: ShutdownMask, exitCode: number, reason?: string): void;
+		function hasPlayerbotsModule(): boolean;
+	}
+}

package/classes/ACMap.d.ts

@@ -0,0 +1,29 @@
+declare global {
+	namespace Acore {
+		class ACMap {
+			static nonInstancedById(id: number): ACMap;
+			static instancedById(id: number, instanceId: number): ACMap;
+			static entrancePosById(id: number): Position;
+
+			readonly mapId: number;
+			readonly instanceId: number;
+			readonly isDungeon: boolean;
+			readonly isRaid: boolean;
+			readonly isBattleground: boolean;
+			readonly isArena: boolean;
+			readonly is25ManRaid: boolean;
+			readonly isEmpty: boolean;
+			readonly isHeroic: boolean;
+			readonly difficulty: Difficulty;
+			readonly playerCount: number;
+			readonly alivePlayerCount: number;
+			readonly name: string;
+			readonly players: Player[];
+
+			getPlayersInTeam(teamId: TeamId): Player[];
+			getHeightAt(x: number, y: number, z: number, phaseMask?: number, vmap?: boolean, maxSearchDist?: number): number;
+			getAreaIdAt(x: number, y: number, z: number, phaseMask?: number): number;
+		}
+	}
+}
+export {};

package/classes/ACObject.d.ts

@@ -0,0 +1,33 @@
+declare global {
+	namespace Acore {
+		class ACObject {
+			readonly typeID: TypeId;
+			readonly entry: number;
+			readonly guid: ObjectGuidNative;
+			readonly isPlayer: boolean;
+			readonly isInWorld: boolean;
+			scale: number;
+
+			hasFlag(field: number, flag: number): boolean;
+			getInt32Value(field: number): number;
+			getUInt32Value(field: number): number;
+			getFloatValue(field: number): number;
+			getByteValue(field: number, offset: 0 | 1 | 2 | 3): number;
+			getUInt16Value(field: number, offset: 0 | 1): number;
+			getInt16Value(field: number, offset: 0 | 1): number;
+			getUInt64Value(field: number): number | bigint;
+
+			setFlag(field: number, flag: number): void;
+			removeFlag(field: number, flag: number): void;
+			setInt32Value(field: number, value: number): void;
+			setUInt32Value(field: number, value: number): void;
+			updateUInt32Value(field: number, value: number): void;
+			setFloatValue(field: number, value: number): void;
+			setByteValue(field: number, offset: 0 | 1 | 2 | 3, value: number): void;
+			setUInt16Value(field: number, offset: 0 | 1, value: number): void;
+			setInt16Value(field: number, offset: 0 | 1, value: number): void;
+			setUInt64Value(field: number, value: number | bigint): void;
+		}
+	}
+}
+export {};

package/classes/Auction.d.ts

@@ -0,0 +1,39 @@
+declare global {
+	namespace Acore {
+		class Auction {
+			constructor();
+
+			readonly id: number;
+			readonly factionId: number;
+			readonly depositPercent: number;
+			readonly cutPercent: number;
+			readonly cut: number;
+			readonly outBid: number;
+
+			houseId: AuctionHouseId;
+			itemGuid: ObjectGuidNative;
+			itemTemplate: number;
+			itemCount: number;
+			ownerGuid: ObjectGuidNative;
+			startBid: number;
+			currentBid: number;
+			buyout: number;
+			expireTime: Temporal.Instant;
+			bidder: ObjectGuidNative | undefined;
+			deposit: number;
+
+			static calculateAuctionOutBid(bid: number): number;
+
+			deleteFromDB(): void;
+			saveToDB(): void;
+			saveToDB(): void;
+			sendAuctionWonMail(sendNotification?: boolean, updateAchievementCriteria?: boolean): void;
+			sendAuctionSalePendingMail(): void;
+			sendAuctionSuccessfulMail(sendNotification?: boolean, updateAchievementCriteria?: boolean): void;
+			sendAuctionExpiredMail(sendNotification?: boolean): void;
+			sendAuctionOutbiddedMail(newPrice: number, newBidder: Player, sendNotification?: boolean): void;
+			sendAuctionCancelledToBidderMail(): void;
+		}
+	}
+}
+export {};

package/classes/AuctionHouse.d.ts

@@ -0,0 +1,18 @@
+declare global {
+	namespace Acore {
+		class AuctionHouse {
+			static forId(id: AuctionHouseId): AuctionHouse;
+			static getAuctionDeposit(id: AuctionHouseId, time: Temporal.Duration, item: Item, count: number): number;
+			static getAItem(guid: ObjectGuid): Item | undefined;
+
+			readonly auctionCount: number;
+			readonly allAuctions: Auction[];
+
+			addAuction(auction: Auction, item: Item): void;
+			getAuction(id: number): Auction | undefined;
+			removeAuction(id: number): boolean;
+			update(): void;
+		}
+	}
+}
+export {};

package/classes/Aura.d.ts

@@ -0,0 +1,25 @@
+declare global {
+	namespace Acore {
+		class Aura {
+			readonly caster: Unit;
+			readonly casterGuid: ObjectGuidNative;
+			readonly castItemGuid: ObjectGuidNative | undefined;
+			readonly castItemEntry: number;
+			readonly owner: WorldObject;
+			readonly casterLevel: number;
+			readonly spellId: number;
+			readonly spellInfo: SpellInfo;
+			readonly type: AuraType;
+			readonly charges: number;
+			readonly isExpired: boolean;
+			readonly isPermanent: boolean;
+			duration: Temporal.Duration;
+			maxDuration: Temporal.Duration;
+			stackAmount: number;
+
+			setDurationWithMods(duration: Temporal.Duration): void;
+			remove(): void;
+		}
+	}
+}
+export {};

package/classes/AuraApplication.d.ts

@@ -0,0 +1,21 @@
+declare global {
+	namespace Acore {
+		class AuraApplication {
+			readonly target: Unit;
+			readonly base: Aura;
+			readonly slot: number;
+			readonly flags: AURA_FLAGS;
+			readonly effectMask: AURA_FLAGS_ONLY_EFFECTS;
+			readonly isPositive: boolean;
+			readonly isSelfcasted: boolean;
+			readonly effectsToApply: SpellEffIndexMask;
+			removeMode: AuraRemoveMode;
+
+			hasEffect(effect: SpellEffIndex): boolean;
+			isActive(effectIndex: SpellEffIndex): boolean;
+			setDisableMask(effectIndex: SpellEffIndex): void;
+			removeDisableMask(effectIndex: SpellEffIndex): void;
+		}
+	}
+}
+export {};

package/classes/AuraEffect.d.ts

@@ -0,0 +1,45 @@
+declare global {
+	namespace Acore {
+		class AuraEffect {
+			readonly caster: Unit | undefined;
+			readonly casterGuid: ObjectGuidNative;
+			readonly base: Aura;
+			readonly targetList: Unit[];
+			readonly applicationList: AuraApplication[];
+			readonly spellModifier: SpellModifier;
+			readonly spellInfo: SpellInfo;
+			readonly id: number;
+			readonly effIndex: SpellEffIndex;
+			readonly baseAmount: number;
+			readonly dieSides: number;
+			readonly amplitude: number;
+			readonly miscValue: number;
+			readonly miscValueB: number;
+			readonly auraType: AuraType;
+			readonly forcedAmount: number;
+			readonly tickNumber: number;
+			readonly totalTicks: number;
+			readonly hasSpellClassMask: boolean;
+			readonly casterLevel: number;
+			readonly canApplyResilience: boolean;
+
+			amount: number;
+			periodicTimer: number;
+			canBeRecalculated: boolean;
+			isPeriodic: boolean;
+			critChance: number;
+			pctMods: number;
+			oldAmount: number;
+			isEnabled: boolean;
+
+			calculatePeriodic(caster: Unit, create?: boolean, load?: boolean): void;
+			calculatePeriodicData(): void;
+			calculateSpellMod(): void;
+			changeAmount(newAmount: number, mark?: boolean, onStackOrReapply?: boolean): void;
+			recalculateAmount(caster?: Unit): void;
+			handleEffect(target: Unit, mode: number, apply: boolean): void;
+			handleEffect(auraApplication: AuraApplication, mode: number, apply: boolean): void;
+		}
+	}
+}
+export {};

package/classes/Battleground.d.ts

@@ -0,0 +1,16 @@
+declare global {
+	namespace Acore {
+		class Battleground {
+			readonly name: string;
+			readonly instanceId: number;
+			readonly mapId: number;
+			readonly battlegroundTypeId: BattlegroundTypeId;
+			readonly playerScores: Map<number, BattlegroundScore>;
+			isRandom: boolean;
+
+			getPlayersCountByTeam(teamId: TeamId): number;
+			getAlivePlayersCountByTeam(teamId: TeamId): number;
+		}
+	}
+}
+export {};

package/classes/BattlegroundQueue.d.ts

@@ -0,0 +1,12 @@
+declare global {
+	namespace Acore {
+		class BattlegroundQueue {
+			readonly queuedPlayers: Map<number, GroupQueueInfo>;
+
+			getAverageQueueWaitTime(teamId: TeamId, bracketId: number): Temporal.Duration;
+			getAverageArenaQueueWaitTime(arenaType: number, isRated: boolean, bracketId: number): Temporal.Duration;
+			checkPremadeMatch(bracketId: number, minPlayersPerTeam: number, maxPlayersPerTeam: number): boolean;
+		}
+	}
+}
+export {};

package/classes/ByteBuffer.d.ts

@@ -0,0 +1,34 @@
+declare global {
+	namespace Acore {
+		class ByteBuffer {
+			readonly size: number;
+
+			readByte(): number;
+			readUByte(): number;
+			readShort(): number;
+			readUShort(): number;
+			readLong(): number;
+			readULong(): number;
+			readFloat(): number;
+			readDouble(): number;
+			readString(): string;
+			readGuid(): ObjectGuidNative | undefined;
+			readPackedGuid(): ObjectGuidNative | undefined;
+
+			writeByte(v: number): this;
+			writeUByte(v: number): this;
+			writeShort(v: number): this;
+			writeUShort(v: number): this;
+			writeLong(v: number): this;
+			writeULong(v: number): this;
+			writeFloat(v: number): this;
+			writeDouble(v: number): this;
+			writeString(v: string): this;
+			writeGuidFrom(obj: ACObject): this;
+			writeGuid(v: ObjectGuid | undefined): this;
+			writePackedGuidFrom(obj: ACObject): this;
+			writePackedGuid(v: ObjectGuid | undefined): this;
+		}
+	}
+}
+export {};

package/classes/CastSpellBuilder.d.ts

@@ -0,0 +1,41 @@
+declare global {
+	namespace Acore {
+		class CastSpellBuilder {
+			cast(): SpellCastResult;
+
+			resetCaster(caster: Unit): this;
+			resetSpell(spell: SpellInfo): this;
+			targetUnit(target: Unit): this;
+			targetGameObject(target: GameObject): this;
+			targetCorpse(target: Corpse): this;
+			targetItem(target: Item): this;
+			targetItemInTradeWith(player: Player): this;
+			updateTradeSlotItem(): this;
+			resetObjectTarget(): this;
+			setSrcWorldObject(src: WorldObject): this;
+			setSrcPos(x: number, y: number, z: number, o?: number): this;
+			moveSrcPos(x: number, y: number, z: number, o?: number): this;
+			resetSrc(): this;
+			setDstWorldObject(dst: WorldObject): this;
+			setDstPos(x: number, y: number, z: number, o?: number, mapId?: number): this;
+			moveDstPos(x: number, y: number, z: number, o?: number): this;
+			resetDst(): this;
+			setElevation(elevation: number): this;
+			setSpeed(speed: number): this;
+			setObjectTargetChannel(guid: ObjectGuid | undefined): this;
+			setDstChannelWorldObject(dstChannel: WorldObject): this;
+			setDstChannelPos(x: number, y: number, z: number, o?: number, mapId?: number): this;
+			resetDstChannel(): this;
+			setCustomSpellValue(mod: SpellValueMod, val: number): this;
+			appendTriggerFlags(flags: TriggerCastFlags): this;
+			resetTriggerFlags(newFlags?: TriggerCastFlags): this;
+			setCastItem(item: Item): this;
+			resetCastItem(): this;
+			setTriggeredByAura(aura: AuraEffect): this;
+			resetTriggeredByAura(): this;
+			setOriginalCaster(originalCaster: ObjectGuid | undefined): this;
+			setTargetFlagsAdvanced(newFlags: SpellCastTargetFlags): this;
+		}
+	}
+}
+export {};

package/classes/ChatCommandBuilder.d.ts

@@ -0,0 +1,13 @@
+declare global {
+	namespace Acore {
+		class ChatCommandBuilder {
+			constructor(name: string);
+			withSubcommand(cmd: ChatCommandBuilder): ChatCommandBuilder;
+			withHandler(handler: (h: ChatHandler, args: string) => boolean): ChatCommandBuilder;
+			withSecurityLevel(sec: AccountTypes): ChatCommandBuilder;
+			withAllowConsole(allow: boolean): ChatCommandBuilder;
+			withHelp(help: AcoreStrings): ChatCommandBuilder;
+		}
+	}
+}
+export {};

package/classes/ChatHandler.d.ts

@@ -0,0 +1,23 @@
+declare global {
+	namespace Acore {
+		class ChatHandler {
+			readonly player: Player | undefined;
+			readonly selectedPlayer: Player | undefined;
+			readonly selectedPlayerOrSelf: Player | undefined;
+			readonly selectedCreature: Creature | undefined;
+			readonly selectedUnit: Unit | undefined
+			readonly selectedObject: WorldObject | undefined;
+			readonly isConsole: boolean;
+			readonly hasSentErrorMessage: boolean;
+
+			isAvailable(sec: AccountTypes): boolean;
+			sendSysMessageStored(msg: number): void;
+			sendSysMessageInline(msg: string): void;
+			sendGlobalSysMessage(msg: string): void;
+			sendGlobalGMSysMessage(msg: string): void;
+			hasLowerSecurity(player: Player, guid?: ObjectGuid, strong?: boolean): boolean;
+			hasLowerSecurityAccount(accountId: number, strong?: boolean): boolean;
+		}
+	}
+}
+export {};

package/classes/Condition.d.ts

@@ -0,0 +1,29 @@
+declare global {
+	namespace Acore {
+		class Condition {
+			constructor();
+
+			readonly isLoaded: boolean;
+			readonly searcherTypeMaskForCondition: number;
+			readonly maxAvailableConditionTargets: number;
+			sourceType: ConditionSourceType;
+			sourceGroup: number;
+			sourceEntry: number;
+			sourceId: number;
+			elseGroup: number;
+			conditionType: ConditionTypes;
+			conditionValue1: number;
+			conditionValue2: number;
+			conditionValue3: number;
+			errorType: number;
+			errorTextId: number;
+			referenceId: number;
+			scriptId: number;
+			conditionTarget: number;
+			negativeCondition: boolean;
+
+			meets(source: ConditionSourceInfo): boolean;
+		}
+	}
+}
+export {};

package/classes/ConditionSourceInfo.d.ts

@@ -0,0 +1,15 @@
+declare global {
+	namespace Acore {
+		class ConditionSourceInfo {
+			constructor(target0: WorldObject);
+			constructor(target0: WorldObject, target1: WorldObject);
+			constructor(target0: WorldObject, target1: WorldObject, target2: WorldObject);
+
+			target0: WorldObject;
+			target1: WorldObject | undefined;
+			target2: WorldObject | undefined;
+			lastFailedCondition: Condition | undefined;
+		}
+	}
+}
+export {};

package/classes/Config.d.ts

@@ -0,0 +1,22 @@
+declare global {
+	namespace Acore {
+		class Config {
+			static getArguments(): string[];
+			static getConfigPath(): string;
+			static getFilename(): string;
+			static getKeysStartingWith(): string[];
+			static getBool(): boolean;
+			static getString(): string;
+			static getFloat(): number;
+			static getU8(): number;
+			static getI8(): number;
+			static getU16(): number;
+			static getI16(): number;
+			static getU32(): number;
+			static getI32(): number;
+			static getU64(): number | bigint;
+			static getI64(): number | bigint;
+		}
+	}
+}
+export {};

package/classes/Corpse.d.ts

@@ -0,0 +1,14 @@
+declare global {
+	namespace Acore {
+		class Corpse extends WorldObject {
+			ghostTime: Temporal.Instant;
+			corpseType: CorpseType;
+			ownerGuid: ObjectGuidNative;
+			owner: Player | undefined;
+
+			resetGhostTime(): void;
+			saveToDB(): void;
+		}
+	}
+}
+export {};

package/classes/Creature.d.ts

@@ -0,0 +1,82 @@
+declare global {
+	namespace Acore {
+		class Creature extends Unit {
+			// 0 for new or temporary, Acore.decodeGuid(guid)[2] otherwise.
+			readonly spawnId: number;
+			readonly template: CreatureTemplate;
+			readonly shieldBlockValue: number;
+			readonly isInEvadeMode: boolean;
+			readonly isElite: boolean;
+			readonly isGuard: boolean;
+			readonly isCivilian: boolean;
+			readonly isRacialLeader: boolean;
+			readonly isDungeonBoss: boolean;
+			readonly isWorldBoss: boolean;
+			readonly isTrigger: boolean;
+			readonly isDamageEnoughForLootingAndReward: boolean;
+			readonly canSwim: boolean;
+			readonly canWalk: boolean;
+			readonly canFly: boolean;
+			readonly hasSearchedAssistance: boolean;
+			readonly hasLootRecipient: boolean;
+			readonly canAggro: boolean;
+			readonly waypointPath: number;
+			readonly currentWaypointId: number;
+			readonly scriptName: string;
+			readonly aiName: string;
+			readonly scriptId: number;
+			readonly lootRecipientGuid: ObjectGuidNative | undefined;
+			readonly lootRecipient: Player | undefined;
+			readonly lootRecipientGroupId: number;
+			readonly lootRecipientGroup: Group | undefined;
+			readonly homePosition: Position;
+			regeneratingHealth: boolean;
+			reputationGainDisabled: boolean;
+			respawnDelay: Temporal.Duration;
+			wanderRadius: number;
+			corpseDelay: Temporal.Duration;
+			defaultMovementType: MovementGeneratorType;
+			npcFlags: NPCFlags;
+			unitFlags: UnitFlags;
+			unitFlags2: UnitFlags2;
+			reactState: ReactStates;
+			lootMode: LootModes;
+
+			canCompleteQuest(questId: number): boolean;
+			canAssistTo(friend: Unit, enemy: Unit, checkFaction?: boolean): boolean;
+			isTappedBy(player: Player): boolean;
+			isTargetableForAttack(mustBeDead?: boolean, byWhom?: Unit): boolean;
+			canStartAttack(target: Unit, force?: boolean): boolean;
+			getAggroRange(target: Unit): number;
+			hasSpell(spellId: number): boolean;
+			hasSpellCooldown(spellId: number): boolean;
+			getSpellCooldown(spellId: number): number;
+			hasQuest(questId: number): boolean;
+			hasLootMode(lootMode: LootModes): boolean;
+			getAITargets(): ThreatReference[];
+			getAITargetsCount(): number;
+			setInCombatWithZone(): void;
+			attackStart(target: Unit): void;
+			setHomePosition(x: number, y: number, z: number, o: number): void;
+			setAggroEnabled(allow?: boolean): void;
+			setEquipmentSlots(mainHand: number, offHand: number, ranged: number): void;
+			setNoSearchAssistance(v?: boolean): void;
+			setNoCallAssistance(v?: boolean): void;
+			despawnOrUnsummon(timeToDespawn?: Temporal.Duration, forcedRespawnTimer?: Temporal.Duration): void;
+			respawn(force?: boolean): void;
+			removeCorpse(setSpawnTime?: boolean, skipVisibility?: boolean): void;
+			allLootRemovedFromCorpse(): void;
+			saveToDB(): void;
+			moveWaypoint(): void;
+			callAssistance(target?: Unit): void;
+			callForHelp(radius: number, target?: Unit): void;
+			fleeToGetAssistance(): void;
+			selectVictim(): Unit | undefined;
+			updateEntry(entry: number, spawnIdForCreatureData?: number, changeLevel?: boolean, updateAi?: boolean): void;
+			resetLootMode(): void;
+			removeLootMode(lootMode: LootModes): void;
+			addLootMode(lootMode: LootModes): void;
+		}
+	}
+}
+export {};

package/classes/CreatureTemplate.d.ts

@@ -0,0 +1,73 @@
+declare global {
+	namespace Acore {
+		class CreatureTemplate {
+			readonly entry: number;
+			readonly difficultyEntry: number[];
+			readonly killCredit: number[];
+			readonly models: CreatureModel[];
+			readonly name: string;
+			readonly subName: string;
+			readonly iconName: string;
+			readonly gossipMenuId: number;
+			readonly minLevel: number;
+			readonly maxLevel: number;
+			readonly expansion: Expansions;
+			readonly faction: number;
+			readonly npcFlag: NPCFlags;
+			readonly speedWalk: number;
+			readonly speedRun: number;
+			readonly speedSwim: number;
+			readonly speedFlight: number;
+			readonly detectionRange: number;
+			readonly rank: CreatureEliteType;
+			readonly dmgSchool: SpellSchools;
+			readonly damageModifier: number;
+			readonly baseAttackTime: Temporal.Duration;
+			readonly rangeAttackTime: Temporal.Duration;
+			readonly baseVariance: number;
+			readonly rangeVariance: number;
+			readonly unitClass: CreatureClasses;
+			readonly unitFlags: UnitFlags;
+			readonly unitFlags2: UnitFlags2;
+			readonly dynamicflags: UnitDynFlags;
+			readonly family: CreatureFamily;
+			readonly creatureType: CreatureType;
+			readonly creatureTypeFlags: CreatureTypeFlags;
+			readonly lootId: number;
+			readonly pickpocketLootId: number;
+			readonly skinLootId: number;
+			readonly resistance: number[];
+			readonly spells: number[];
+			readonly petSpellDataId: number;
+			readonly vehicleId: number;
+			readonly minGold: number;
+			readonly maxGold: number;
+			readonly movementType: MovementGeneratorType;
+			readonly movement: CreatureMovementData;
+			readonly hoverHeight: number;
+			readonly modHealth: number;
+			readonly modMana: number;
+			readonly modArmor: number;
+			readonly modExperience: number;
+			readonly racialLeader: boolean;
+			// CreatureMovementInfo.dbc
+			readonly movementId: number;
+			readonly regenHealth: boolean;
+			readonly creatureImmunitiesId: number;
+			readonly flagsExtra: CreatureFlagsExtra;
+			readonly scriptId: number;
+			readonly requiredLootSkill: SkillType;
+			readonly isExotic: boolean;
+
+			getModelByIdx(idx: number): CreatureModel;
+			getRandomValidModel(): CreatureModel;
+			getFirstValidModel(): CreatureModel;
+			getModelWithDisplayId(displayId: number): CreatureModel;
+			getFirstInvisibleModel(): CreatureModel;
+			getFirstVisibleModel(): CreatureModel;
+			isTameable(exotic: boolean): boolean;
+			hasFlagsExtra(flag: CreatureFlagsExtra): boolean;
+		}
+	}
+}
+export {};

package/classes/DynamicObject.d.ts

@@ -0,0 +1,23 @@
+declare global {
+	namespace Acore {
+		class DynamicObject extends WorldObject {
+			readonly casterGuid: ObjectGuidNative;
+			readonly caster: Unit | undefined;
+			readonly spellId: number;
+			readonly radius: number;
+			readonly isViewpoint: boolean;
+			readonly oldFarsightGuid: ObjectGuidNative | undefined;
+			duration: Temporal.Duration;
+
+			remove(): void;
+			delay(delayTime: Temporal.Duration): void;
+			setAura(aura: Aura): void;
+			removeAura(): void;
+			setCasterViewpoint(updateViewerVisibility: boolean): void;
+			removeCasterViewpoint(): void;
+			bindToCaster(): void;
+			unbindFromCaster(): void;
+		}
+	}
+}
+export {};