warcraft3/common.d.ts

Type definitions for Warcraft3 APIs.

/// <reference path="tstl.d.ts"/>

declare type integer = number
declare type real = number
declare type nothing = void
declare type code = () => void

declare const _handle: unique symbol
declare interface handle {
    [_handle]: never
}

declare const _agent: unique symbol
declare interface agent extends handle {
    [_agent]: never
}

declare const _event: unique symbol
declare interface event extends agent {
    [_event]: never
}

declare const _player: unique symbol
declare interface player extends agent {
    [_player]: never
}

declare const _widget: unique symbol
declare interface widget extends agent {
    [_widget]: never
}

declare const _unit: unique symbol
declare interface unit extends widget {
    [_unit]: never
}

declare const _destructable: unique symbol
declare interface destructable extends widget {
    [_destructable]: never
}

declare const _item: unique symbol
declare interface item extends widget {
    [_item]: never
}

declare const _ability: unique symbol
declare interface ability extends agent {
    [_ability]: never
}

declare const _buff: unique symbol
declare interface buff extends ability {
    [_buff]: never
}

declare const _force: unique symbol
declare interface force extends agent {
    [_force]: never
}

declare const _group: unique symbol
declare interface group extends agent {
    [_group]: never
}

declare const _trigger: unique symbol
declare interface trigger extends agent {
    [_trigger]: never
}

declare const _triggercondition: unique symbol
declare interface triggercondition extends agent {
    [_triggercondition]: never
}

declare const _triggeraction: unique symbol
declare interface triggeraction extends handle {
    [_triggeraction]: never
}

declare const _timer: unique symbol
declare interface timer extends agent {
    [_timer]: never
}

declare const _location: unique symbol
declare interface location extends agent {
    [_location]: never
}

declare const _region: unique symbol
declare interface region extends agent {
    [_region]: never
}

declare const _rect: unique symbol
declare interface rect extends agent {
    [_rect]: never
}

declare const _boolexpr: unique symbol
declare interface boolexpr extends agent {
    [_boolexpr]: never
}

declare const _sound: unique symbol
declare interface sound extends agent {
    [_sound]: never
}

declare const _conditionfunc: unique symbol
declare interface conditionfunc extends boolexpr {
    [_conditionfunc]: never
}

declare const _filterfunc: unique symbol
declare interface filterfunc extends boolexpr {
    [_filterfunc]: never
}

declare const _unitpool: unique symbol
declare interface unitpool extends handle {
    [_unitpool]: never
}

declare const _itempool: unique symbol
declare interface itempool extends handle {
    [_itempool]: never
}

declare const _race: unique symbol
declare interface race extends handle {
    [_race]: never
}

declare const _alliancetype: unique symbol
declare interface alliancetype extends handle {
    [_alliancetype]: never
}

declare const _racepreference: unique symbol
declare interface racepreference extends handle {
    [_racepreference]: never
}

declare const _gamestate: unique symbol
declare interface gamestate extends handle {
    [_gamestate]: never
}

declare const _igamestate: unique symbol
declare interface igamestate extends gamestate {
    [_igamestate]: never
}

declare const _fgamestate: unique symbol
declare interface fgamestate extends gamestate {
    [_fgamestate]: never
}

declare const _playerstate: unique symbol
declare interface playerstate extends handle {
    [_playerstate]: never
}

declare const _playerscore: unique symbol
declare interface playerscore extends handle {
    [_playerscore]: never
}

declare const _playergameresult: unique symbol
declare interface playergameresult extends handle {
    [_playergameresult]: never
}

declare const _unitstate: unique symbol
declare interface unitstate extends handle {
    [_unitstate]: never
}

declare const _aidifficulty: unique symbol
declare interface aidifficulty extends handle {
    [_aidifficulty]: never
}

declare const _eventid: unique symbol
declare interface eventid extends handle {
    [_eventid]: never
}

declare const _gameevent: unique symbol
declare interface gameevent extends eventid {
    [_gameevent]: never
}

declare const _playerevent: unique symbol
declare interface playerevent extends eventid {
    [_playerevent]: never
}

declare const _playerunitevent: unique symbol
declare interface playerunitevent extends eventid {
    [_playerunitevent]: never
}

declare const _unitevent: unique symbol
declare interface unitevent extends eventid {
    [_unitevent]: never
}

declare const _limitop: unique symbol
declare interface limitop extends eventid {
    [_limitop]: never
}

declare const _widgetevent: unique symbol
declare interface widgetevent extends eventid {
    [_widgetevent]: never
}

declare const _dialogevent: unique symbol
declare interface dialogevent extends eventid {
    [_dialogevent]: never
}

declare const _unittype: unique symbol
declare interface unittype extends handle {
    [_unittype]: never
}

declare const _gamespeed: unique symbol
declare interface gamespeed extends handle {
    [_gamespeed]: never
}

declare const _gamedifficulty: unique symbol
declare interface gamedifficulty extends handle {
    [_gamedifficulty]: never
}

declare const _gametype: unique symbol
declare interface gametype extends handle {
    [_gametype]: never
}

declare const _mapflag: unique symbol
declare interface mapflag extends handle {
    [_mapflag]: never
}

declare const _mapvisibility: unique symbol
declare interface mapvisibility extends handle {
    [_mapvisibility]: never
}

declare const _mapsetting: unique symbol
declare interface mapsetting extends handle {
    [_mapsetting]: never
}

declare const _mapdensity: unique symbol
declare interface mapdensity extends handle {
    [_mapdensity]: never
}

declare const _mapcontrol: unique symbol
declare interface mapcontrol extends handle {
    [_mapcontrol]: never
}

declare const _playerslotstate: unique symbol
declare interface playerslotstate extends handle {
    [_playerslotstate]: never
}

declare const _volumegroup: unique symbol
declare interface volumegroup extends handle {
    [_volumegroup]: never
}

declare const _camerafield: unique symbol
declare interface camerafield extends handle {
    [_camerafield]: never
}

declare const _camerasetup: unique symbol
declare interface camerasetup extends handle {
    [_camerasetup]: never
}

declare const _playercolor: unique symbol
declare interface playercolor extends handle {
    [_playercolor]: never
}

declare const _placement: unique symbol
declare interface placement extends handle {
    [_placement]: never
}

declare const _startlocprio: unique symbol
declare interface startlocprio extends handle {
    [_startlocprio]: never
}

declare const _raritycontrol: unique symbol
declare interface raritycontrol extends handle {
    [_raritycontrol]: never
}

declare const _blendmode: unique symbol
declare interface blendmode extends handle {
    [_blendmode]: never
}

declare const _texmapflags: unique symbol
declare interface texmapflags extends handle {
    [_texmapflags]: never
}

declare const _effect: unique symbol
declare interface effect extends agent {
    [_effect]: never
}

declare const _effecttype: unique symbol
declare interface effecttype extends handle {
    [_effecttype]: never
}

declare const _weathereffect: unique symbol
declare interface weathereffect extends handle {
    [_weathereffect]: never
}

declare const _terraindeformation: unique symbol
declare interface terraindeformation extends handle {
    [_terraindeformation]: never
}

declare const _fogstate: unique symbol
declare interface fogstate extends handle {
    [_fogstate]: never
}

declare const _fogmodifier: unique symbol
declare interface fogmodifier extends agent {
    [_fogmodifier]: never
}

declare const _dialog: unique symbol
declare interface dialog extends agent {
    [_dialog]: never
}

declare const _button: unique symbol
declare interface button extends agent {
    [_button]: never
}

declare const _quest: unique symbol
declare interface quest extends agent {
    [_quest]: never
}

declare const _questitem: unique symbol
declare interface questitem extends agent {
    [_questitem]: never
}

declare const _defeatcondition: unique symbol
declare interface defeatcondition extends agent {
    [_defeatcondition]: never
}

declare const _timerdialog: unique symbol
declare interface timerdialog extends agent {
    [_timerdialog]: never
}

declare const _leaderboard: unique symbol
declare interface leaderboard extends agent {
    [_leaderboard]: never
}

declare const _multiboard: unique symbol
declare interface multiboard extends agent {
    [_multiboard]: never
}

declare const _multiboarditem: unique symbol
declare interface multiboarditem extends agent {
    [_multiboarditem]: never
}

declare const _trackable: unique symbol
declare interface trackable extends agent {
    [_trackable]: never
}

declare const _gamecache: unique symbol
declare interface gamecache extends agent {
    [_gamecache]: never
}

declare const _version: unique symbol
declare interface version extends handle {
    [_version]: never
}

declare const _itemtype: unique symbol
declare interface itemtype extends handle {
    [_itemtype]: never
}

declare const _texttag: unique symbol
declare interface texttag extends handle {
    [_texttag]: never
}

declare const _attacktype: unique symbol
declare interface attacktype extends handle {
    [_attacktype]: never
}

declare const _damagetype: unique symbol
declare interface damagetype extends handle {
    [_damagetype]: never
}

declare const _weapontype: unique symbol
declare interface weapontype extends handle {
    [_weapontype]: never
}

declare const _soundtype: unique symbol
declare interface soundtype extends handle {
    [_soundtype]: never
}

declare const _lightning: unique symbol
declare interface lightning extends handle {
    [_lightning]: never
}

declare const _pathingtype: unique symbol
declare interface pathingtype extends handle {
    [_pathingtype]: never
}

declare const _mousebuttontype: unique symbol
declare interface mousebuttontype extends handle {
    [_mousebuttontype]: never
}

declare const _animtype: unique symbol
declare interface animtype extends handle {
    [_animtype]: never
}

declare const _subanimtype: unique symbol
declare interface subanimtype extends handle {
    [_subanimtype]: never
}

declare const _image: unique symbol
declare interface image extends handle {
    [_image]: never
}

declare const _ubersplat: unique symbol
declare interface ubersplat extends handle {
    [_ubersplat]: never
}

declare const _hashtable: unique symbol
declare interface hashtable extends agent {
    [_hashtable]: never
}

declare const _framehandle: unique symbol
declare interface framehandle extends handle {
    [_framehandle]: never
}

declare const _originframetype: unique symbol
declare interface originframetype extends handle {
    [_originframetype]: never
}

declare const _framepointtype: unique symbol
declare interface framepointtype extends handle {
    [_framepointtype]: never
}

declare const _textaligntype: unique symbol
declare interface textaligntype extends handle {
    [_textaligntype]: never
}

declare const _frameeventtype: unique symbol
declare interface frameeventtype extends handle {
    [_frameeventtype]: never
}

declare const _oskeytype: unique symbol
declare interface oskeytype extends handle {
    [_oskeytype]: never
}

declare const _abilityintegerfield: unique symbol
declare interface abilityintegerfield extends handle {
    [_abilityintegerfield]: never
}

declare const _abilityrealfield: unique symbol
declare interface abilityrealfield extends handle {
    [_abilityrealfield]: never
}

declare const _abilitybooleanfield: unique symbol
declare interface abilitybooleanfield extends handle {
    [_abilitybooleanfield]: never
}

declare const _abilitystringfield: unique symbol
declare interface abilitystringfield extends handle {
    [_abilitystringfield]: never
}

declare const _abilityintegerlevelfield: unique symbol
declare interface abilityintegerlevelfield extends handle {
    [_abilityintegerlevelfield]: never
}

declare const _abilityreallevelfield: unique symbol
declare interface abilityreallevelfield extends handle {
    [_abilityreallevelfield]: never
}

declare const _abilitybooleanlevelfield: unique symbol
declare interface abilitybooleanlevelfield extends handle {
    [_abilitybooleanlevelfield]: never
}

declare const _abilitystringlevelfield: unique symbol
declare interface abilitystringlevelfield extends handle {
    [_abilitystringlevelfield]: never
}

declare const _abilityintegerlevelarrayfield: unique symbol
declare interface abilityintegerlevelarrayfield extends handle {
    [_abilityintegerlevelarrayfield]: never
}

declare const _abilityreallevelarrayfield: unique symbol
declare interface abilityreallevelarrayfield extends handle {
    [_abilityreallevelarrayfield]: never
}

declare const _abilitybooleanlevelarrayfield: unique symbol
declare interface abilitybooleanlevelarrayfield extends handle {
    [_abilitybooleanlevelarrayfield]: never
}

declare const _abilitystringlevelarrayfield: unique symbol
declare interface abilitystringlevelarrayfield extends handle {
    [_abilitystringlevelarrayfield]: never
}

declare const _unitintegerfield: unique symbol
declare interface unitintegerfield extends handle {
    [_unitintegerfield]: never
}

declare const _unitrealfield: unique symbol
declare interface unitrealfield extends handle {
    [_unitrealfield]: never
}

declare const _unitbooleanfield: unique symbol
declare interface unitbooleanfield extends handle {
    [_unitbooleanfield]: never
}

declare const _unitstringfield: unique symbol
declare interface unitstringfield extends handle {
    [_unitstringfield]: never
}

declare const _unitweaponintegerfield: unique symbol
declare interface unitweaponintegerfield extends handle {
    [_unitweaponintegerfield]: never
}

declare const _unitweaponrealfield: unique symbol
declare interface unitweaponrealfield extends handle {
    [_unitweaponrealfield]: never
}

declare const _unitweaponbooleanfield: unique symbol
declare interface unitweaponbooleanfield extends handle {
    [_unitweaponbooleanfield]: never
}

declare const _unitweaponstringfield: unique symbol
declare interface unitweaponstringfield extends handle {
    [_unitweaponstringfield]: never
}

declare const _itemintegerfield: unique symbol
declare interface itemintegerfield extends handle {
    [_itemintegerfield]: never
}

declare const _itemrealfield: unique symbol
declare interface itemrealfield extends handle {
    [_itemrealfield]: never
}

declare const _itembooleanfield: unique symbol
declare interface itembooleanfield extends handle {
    [_itembooleanfield]: never
}

declare const _itemstringfield: unique symbol
declare interface itemstringfield extends handle {
    [_itemstringfield]: never
}

declare const _movetype: unique symbol
declare interface movetype extends handle {
    [_movetype]: never
}

declare const _targetflag: unique symbol
declare interface targetflag extends handle {
    [_targetflag]: never
}

declare const _armortype: unique symbol
declare interface armortype extends handle {
    [_armortype]: never
}

declare const _heroattribute: unique symbol
declare interface heroattribute extends handle {
    [_heroattribute]: never
}

declare const _defensetype: unique symbol
declare interface defensetype extends handle {
    [_defensetype]: never
}

declare const _regentype: unique symbol
declare interface regentype extends handle {
    [_regentype]: never
}

declare const _unitcategory: unique symbol
declare interface unitcategory extends handle {
    [_unitcategory]: never
}

declare const _pathingflag: unique symbol
declare interface pathingflag extends handle {
    [_pathingflag]: never
}

declare function ConvertRace(i: integer): race
declare function ConvertAllianceType(i: integer): alliancetype
declare function ConvertRacePref(i: integer): racepreference
declare function ConvertIGameState(i: integer): igamestate
declare function ConvertFGameState(i: integer): fgamestate
declare function ConvertPlayerState(i: integer): playerstate
declare function ConvertPlayerScore(i: integer): playerscore
declare function ConvertPlayerGameResult(i: integer): playergameresult
declare function ConvertUnitState(i: integer): unitstate
declare function ConvertAIDifficulty(i: integer): aidifficulty
declare function ConvertGameEvent(i: integer): gameevent
declare function ConvertPlayerEvent(i: integer): playerevent
declare function ConvertPlayerUnitEvent(i: integer): playerunitevent
declare function ConvertWidgetEvent(i: integer): widgetevent
declare function ConvertDialogEvent(i: integer): dialogevent
declare function ConvertUnitEvent(i: integer): unitevent
declare function ConvertLimitOp(i: integer): limitop
declare function ConvertUnitType(i: integer): unittype
declare function ConvertGameSpeed(i: integer): gamespeed
declare function ConvertPlacement(i: integer): placement
declare function ConvertStartLocPrio(i: integer): startlocprio
declare function ConvertGameDifficulty(i: integer): gamedifficulty
declare function ConvertGameType(i: integer): gametype
declare function ConvertMapFlag(i: integer): mapflag
declare function ConvertMapVisibility(i: integer): mapvisibility
declare function ConvertMapSetting(i: integer): mapsetting
declare function ConvertMapDensity(i: integer): mapdensity
declare function ConvertMapControl(i: integer): mapcontrol
declare function ConvertPlayerColor(i: integer): playercolor
declare function ConvertPlayerSlotState(i: integer): playerslotstate
declare function ConvertVolumeGroup(i: integer): volumegroup
declare function ConvertCameraField(i: integer): camerafield
declare function ConvertBlendMode(i: integer): blendmode
declare function ConvertRarityControl(i: integer): raritycontrol
declare function ConvertTexMapFlags(i: integer): texmapflags
declare function ConvertFogState(i: integer): fogstate
declare function ConvertEffectType(i: integer): effecttype
declare function ConvertVersion(i: integer): version
declare function ConvertItemType(i: integer): itemtype
declare function ConvertAttackType(i: integer): attacktype
declare function ConvertDamageType(i: integer): damagetype
declare function ConvertWeaponType(i: integer): weapontype
declare function ConvertSoundType(i: integer): soundtype
declare function ConvertPathingType(i: integer): pathingtype
declare function ConvertMouseButtonType(i: integer): mousebuttontype
declare function ConvertAnimType(i: integer): animtype
declare function ConvertSubAnimType(i: integer): subanimtype
declare function ConvertOriginFrameType(i: integer): originframetype
declare function ConvertFramePointType(i: integer): framepointtype
declare function ConvertTextAlignType(i: integer): textaligntype
declare function ConvertFrameEventType(i: integer): frameeventtype
declare function ConvertOsKeyType(i: integer): oskeytype
declare function ConvertAbilityIntegerField(i: integer): abilityintegerfield
declare function ConvertAbilityRealField(i: integer): abilityrealfield
declare function ConvertAbilityBooleanField(i: integer): abilitybooleanfield
declare function ConvertAbilityStringField(i: integer): abilitystringfield
declare function ConvertAbilityIntegerLevelField(i: integer): abilityintegerlevelfield
declare function ConvertAbilityRealLevelField(i: integer): abilityreallevelfield
declare function ConvertAbilityBooleanLevelField(i: integer): abilitybooleanlevelfield
declare function ConvertAbilityStringLevelField(i: integer): abilitystringlevelfield
declare function ConvertAbilityIntegerLevelArrayField(i: integer): abilityintegerlevelarrayfield
declare function ConvertAbilityRealLevelArrayField(i: integer): abilityreallevelarrayfield
declare function ConvertAbilityBooleanLevelArrayField(i: integer): abilitybooleanlevelarrayfield
declare function ConvertAbilityStringLevelArrayField(i: integer): abilitystringlevelarrayfield
declare function ConvertUnitIntegerField(i: integer): unitintegerfield
declare function ConvertUnitRealField(i: integer): unitrealfield
declare function ConvertUnitBooleanField(i: integer): unitbooleanfield
declare function ConvertUnitStringField(i: integer): unitstringfield
declare function ConvertUnitWeaponIntegerField(i: integer): unitweaponintegerfield
declare function ConvertUnitWeaponRealField(i: integer): unitweaponrealfield
declare function ConvertUnitWeaponBooleanField(i: integer): unitweaponbooleanfield
declare function ConvertUnitWeaponStringField(i: integer): unitweaponstringfield
declare function ConvertItemIntegerField(i: integer): itemintegerfield
declare function ConvertItemRealField(i: integer): itemrealfield
declare function ConvertItemBooleanField(i: integer): itembooleanfield
declare function ConvertItemStringField(i: integer): itemstringfield
declare function ConvertMoveType(i: integer): movetype
declare function ConvertTargetFlag(i: integer): targetflag
declare function ConvertArmorType(i: integer): armortype
declare function ConvertHeroAttribute(i: integer): heroattribute
declare function ConvertDefenseType(i: integer): defensetype
declare function ConvertRegenType(i: integer): regentype
declare function ConvertUnitCategory(i: integer): unitcategory
declare function ConvertPathingFlag(i: integer): pathingflag
declare function OrderId(orderIdString: string): integer
declare function OrderId2String(orderId: integer): string
declare function UnitId(unitIdString: string): integer
declare function UnitId2String(unitId: integer): string
declare function GetBJMaxPlayers(): integer
declare function GetBJPlayerNeutralVictim(): integer
declare function GetBJPlayerNeutralExtra(): integer
declare function GetBJMaxPlayerSlots(): integer
declare function GetPlayerNeutralPassive(): integer
declare function GetPlayerNeutralAggressive(): integer
declare function AbilityId(abilityIdString: string): integer
declare function AbilityId2String(abilityId: integer): string
declare function GetObjectName(objectId: integer): string

declare const FALSE: false
declare const TRUE: true
declare const JASS_MAX_ARRAY_SIZE: 32768
declare const PLAYER_NEUTRAL_PASSIVE: 15
declare const PLAYER_NEUTRAL_AGGRESSIVE: 12
declare const PLAYER_COLOR_RED: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_BLUE: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_CYAN: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_PURPLE: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_YELLOW: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_ORANGE: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_GREEN: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_PINK: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_LIGHT_GRAY: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_LIGHT_BLUE: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_AQUA: ReturnType<typeof ConvertPlayerColor>
declare const PLAYER_COLOR_BROWN: ReturnType<typeof ConvertPlayerColor>
declare const RACE_HUMAN: ReturnType<typeof ConvertRace>
declare const RACE_ORC: ReturnType<typeof ConvertRace>
declare const RACE_UNDEAD: ReturnType<typeof ConvertRace>
declare const RACE_NIGHTELF: ReturnType<typeof ConvertRace>
declare const RACE_DEMON: ReturnType<typeof ConvertRace>
declare const RACE_OTHER: ReturnType<typeof ConvertRace>
declare const PLAYER_GAME_RESULT_VICTORY: ReturnType<typeof ConvertPlayerGameResult>
declare const PLAYER_GAME_RESULT_DEFEAT: ReturnType<typeof ConvertPlayerGameResult>
declare const PLAYER_GAME_RESULT_TIE: ReturnType<typeof ConvertPlayerGameResult>
declare const PLAYER_GAME_RESULT_NEUTRAL: ReturnType<typeof ConvertPlayerGameResult>
declare const ALLIANCE_PASSIVE: ReturnType<typeof ConvertAllianceType>
declare const ALLIANCE_HELP_REQUEST: ReturnType<typeof ConvertAllianceType>
declare const ALLIANCE_HELP_RESPONSE: ReturnType<typeof ConvertAllianceType>
declare const ALLIANCE_SHARED_XP: ReturnType<typeof ConvertAllianceType>
declare const ALLIANCE_SHARED_SPELLS: ReturnType<typeof ConvertAllianceType>
declare const ALLIANCE_SHARED_VISION: ReturnType<typeof ConvertAllianceType>
declare const ALLIANCE_SHARED_CONTROL: ReturnType<typeof ConvertAllianceType>
declare const ALLIANCE_RESCUABLE: ReturnType<typeof ConvertAllianceType>
declare const ALLIANCE_SHARED_VISION_FORCED: ReturnType<typeof ConvertAllianceType>
declare const VERSION_REIGN_OF_CHAOS: ReturnType<typeof ConvertVersion>
declare const VERSION_FROZEN_THRONE: ReturnType<typeof ConvertVersion>
declare const ATTACK_TYPE_NORMAL: ReturnType<typeof ConvertAttackType>
declare const ATTACK_TYPE_MELEE: ReturnType<typeof ConvertAttackType>
declare const ATTACK_TYPE_PIERCE: ReturnType<typeof ConvertAttackType>
declare const ATTACK_TYPE_SIEGE: ReturnType<typeof ConvertAttackType>
declare const ATTACK_TYPE_MAGIC: ReturnType<typeof ConvertAttackType>
declare const ATTACK_TYPE_CHAOS: ReturnType<typeof ConvertAttackType>
declare const ATTACK_TYPE_HERO: ReturnType<typeof ConvertAttackType>
declare const DAMAGE_TYPE_UNKNOWN: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_NORMAL: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_ENHANCED: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_FIRE: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_COLD: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_LIGHTNING: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_POISON: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_DISEASE: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_DIVINE: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_MAGIC: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_SONIC: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_ACID: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_FORCE: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_DEATH: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_MIND: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_PLANT: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_DEFENSIVE: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_DEMOLITION: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_SLOW_POISON: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_SPIRIT_LINK: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_SHADOW_STRIKE: ReturnType<typeof ConvertDamageType>
declare const DAMAGE_TYPE_UNIVERSAL: ReturnType<typeof ConvertDamageType>
declare const WEAPON_TYPE_WHOKNOWS: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_LIGHT_CHOP: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_MEDIUM_CHOP: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_HEAVY_CHOP: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_LIGHT_SLICE: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_MEDIUM_SLICE: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_HEAVY_SLICE: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_MEDIUM_BASH: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_HEAVY_BASH: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_MEDIUM_STAB: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_METAL_HEAVY_STAB: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_WOOD_LIGHT_SLICE: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_WOOD_MEDIUM_SLICE: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_WOOD_HEAVY_SLICE: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_WOOD_LIGHT_BASH: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_WOOD_MEDIUM_BASH: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_WOOD_HEAVY_BASH: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_WOOD_LIGHT_STAB: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_WOOD_MEDIUM_STAB: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_CLAW_LIGHT_SLICE: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_CLAW_MEDIUM_SLICE: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_CLAW_HEAVY_SLICE: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_AXE_MEDIUM_CHOP: ReturnType<typeof ConvertWeaponType>
declare const WEAPON_TYPE_ROCK_HEAVY_BASH: ReturnType<typeof ConvertWeaponType>
declare const PATHING_TYPE_ANY: ReturnType<typeof ConvertPathingType>
declare const PATHING_TYPE_WALKABILITY: ReturnType<typeof ConvertPathingType>
declare const PATHING_TYPE_FLYABILITY: ReturnType<typeof ConvertPathingType>
declare const PATHING_TYPE_BUILDABILITY: ReturnType<typeof ConvertPathingType>
declare const PATHING_TYPE_PEONHARVESTPATHING: ReturnType<typeof ConvertPathingType>
declare const PATHING_TYPE_BLIGHTPATHING: ReturnType<typeof ConvertPathingType>
declare const PATHING_TYPE_FLOATABILITY: ReturnType<typeof ConvertPathingType>
declare const PATHING_TYPE_AMPHIBIOUSPATHING: ReturnType<typeof ConvertPathingType>
declare const MOUSE_BUTTON_TYPE_LEFT: ReturnType<typeof ConvertMouseButtonType>
declare const MOUSE_BUTTON_TYPE_MIDDLE: ReturnType<typeof ConvertMouseButtonType>
declare const MOUSE_BUTTON_TYPE_RIGHT: ReturnType<typeof ConvertMouseButtonType>
declare const ANIM_TYPE_BIRTH: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_DEATH: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_DECAY: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_DISSIPATE: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_STAND: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_WALK: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_ATTACK: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_MORPH: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_SLEEP: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_SPELL: ReturnType<typeof ConvertAnimType>
declare const ANIM_TYPE_PORTRAIT: ReturnType<typeof ConvertAnimType>
declare const SUBANIM_TYPE_ROOTED: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_ALTERNATE_EX: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_LOOPING: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_SLAM: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_THROW: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_SPIKED: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FAST: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_SPIN: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_READY: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_CHANNEL: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_DEFEND: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_VICTORY: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_TURN: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_LEFT: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_RIGHT: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FIRE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FLESH: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_HIT: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_WOUNDED: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_LIGHT: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_MODERATE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_SEVERE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_CRITICAL: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_COMPLETE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_GOLD: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_LUMBER: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_WORK: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_TALK: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FIRST: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_SECOND: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_THIRD: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FOURTH: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FIFTH: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_ONE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_TWO: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_THREE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FOUR: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FIVE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_SMALL: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_MEDIUM: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_LARGE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_UPGRADE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_DRAIN: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FILL: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_CHAINLIGHTNING: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_EATTREE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_PUKE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_FLAIL: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_OFF: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_SWIM: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_ENTANGLE: ReturnType<typeof ConvertSubAnimType>
declare const SUBANIM_TYPE_BERSERK: ReturnType<typeof ConvertSubAnimType>
declare const RACE_PREF_HUMAN: ReturnType<typeof ConvertRacePref>
declare const RACE_PREF_ORC: ReturnType<typeof ConvertRacePref>
declare const RACE_PREF_NIGHTELF: ReturnType<typeof ConvertRacePref>
declare const RACE_PREF_UNDEAD: ReturnType<typeof ConvertRacePref>
declare const RACE_PREF_DEMON: ReturnType<typeof ConvertRacePref>
declare const RACE_PREF_RANDOM: ReturnType<typeof ConvertRacePref>
declare const RACE_PREF_USER_SELECTABLE: ReturnType<typeof ConvertRacePref>
declare const MAP_CONTROL_USER: ReturnType<typeof ConvertMapControl>
declare const MAP_CONTROL_COMPUTER: ReturnType<typeof ConvertMapControl>
declare const MAP_CONTROL_RESCUABLE: ReturnType<typeof ConvertMapControl>
declare const MAP_CONTROL_NEUTRAL: ReturnType<typeof ConvertMapControl>
declare const MAP_CONTROL_CREEP: ReturnType<typeof ConvertMapControl>
declare const MAP_CONTROL_NONE: ReturnType<typeof ConvertMapControl>
declare const GAME_TYPE_MELEE: ReturnType<typeof ConvertGameType>
declare const GAME_TYPE_FFA: ReturnType<typeof ConvertGameType>
declare const GAME_TYPE_USE_MAP_SETTINGS: ReturnType<typeof ConvertGameType>
declare const GAME_TYPE_BLIZ: ReturnType<typeof ConvertGameType>
declare const GAME_TYPE_ONE_ON_ONE: ReturnType<typeof ConvertGameType>
declare const GAME_TYPE_TWO_TEAM_PLAY: ReturnType<typeof ConvertGameType>
declare const GAME_TYPE_THREE_TEAM_PLAY: ReturnType<typeof ConvertGameType>
declare const GAME_TYPE_FOUR_TEAM_PLAY: ReturnType<typeof ConvertGameType>
declare const MAP_FOG_HIDE_TERRAIN: ReturnType<typeof ConvertMapFlag>
declare const MAP_FOG_MAP_EXPLORED: ReturnType<typeof ConvertMapFlag>
declare const MAP_FOG_ALWAYS_VISIBLE: ReturnType<typeof ConvertMapFlag>
declare const MAP_USE_HANDICAPS: ReturnType<typeof ConvertMapFlag>
declare const MAP_OBSERVERS: ReturnType<typeof ConvertMapFlag>
declare const MAP_OBSERVERS_ON_DEATH: ReturnType<typeof ConvertMapFlag>
declare const MAP_FIXED_COLORS: ReturnType<typeof ConvertMapFlag>
declare const MAP_LOCK_RESOURCE_TRADING: ReturnType<typeof ConvertMapFlag>
declare const MAP_RESOURCE_TRADING_ALLIES_ONLY: ReturnType<typeof ConvertMapFlag>
declare const MAP_LOCK_ALLIANCE_CHANGES: ReturnType<typeof ConvertMapFlag>
declare const MAP_ALLIANCE_CHANGES_HIDDEN: ReturnType<typeof ConvertMapFlag>
declare const MAP_CHEATS: ReturnType<typeof ConvertMapFlag>
declare const MAP_CHEATS_HIDDEN: ReturnType<typeof ConvertMapFlag>
declare const MAP_LOCK_SPEED: ReturnType<typeof ConvertMapFlag>
declare const MAP_LOCK_RANDOM_SEED: ReturnType<typeof ConvertMapFlag>
declare const MAP_SHARED_ADVANCED_CONTROL: ReturnType<typeof ConvertMapFlag>
declare const MAP_RANDOM_HERO: ReturnType<typeof ConvertMapFlag>
declare const MAP_RANDOM_RACES: ReturnType<typeof ConvertMapFlag>
declare const MAP_RELOADED: ReturnType<typeof ConvertMapFlag>
declare const MAP_PLACEMENT_RANDOM: ReturnType<typeof ConvertPlacement>
declare const MAP_PLACEMENT_FIXED: ReturnType<typeof ConvertPlacement>
declare const MAP_PLACEMENT_USE_MAP_SETTINGS: ReturnType<typeof ConvertPlacement>
declare const MAP_PLACEMENT_TEAMS_TOGETHER: ReturnType<typeof ConvertPlacement>
declare const MAP_LOC_PRIO_LOW: ReturnType<typeof ConvertStartLocPrio>
declare const MAP_LOC_PRIO_HIGH: ReturnType<typeof ConvertStartLocPrio>
declare const MAP_LOC_PRIO_NOT: ReturnType<typeof ConvertStartLocPrio>
declare const MAP_DENSITY_NONE: ReturnType<typeof ConvertMapDensity>
declare const MAP_DENSITY_LIGHT: ReturnType<typeof ConvertMapDensity>
declare const MAP_DENSITY_MEDIUM: ReturnType<typeof ConvertMapDensity>
declare const MAP_DENSITY_HEAVY: ReturnType<typeof ConvertMapDensity>
declare const MAP_DIFFICULTY_EASY: ReturnType<typeof ConvertGameDifficulty>
declare const MAP_DIFFICULTY_NORMAL: ReturnType<typeof ConvertGameDifficulty>
declare const MAP_DIFFICULTY_HARD: ReturnType<typeof ConvertGameDifficulty>
declare const MAP_DIFFICULTY_INSANE: ReturnType<typeof ConvertGameDifficulty>
declare const MAP_SPEED_SLOWEST: ReturnType<typeof ConvertGameSpeed>
declare const MAP_SPEED_SLOW: ReturnType<typeof ConvertGameSpeed>
declare const MAP_SPEED_NORMAL: ReturnType<typeof ConvertGameSpeed>
declare const MAP_SPEED_FAST: ReturnType<typeof ConvertGameSpeed>
declare const MAP_SPEED_FASTEST: ReturnType<typeof ConvertGameSpeed>
declare const PLAYER_SLOT_STATE_EMPTY: ReturnType<typeof ConvertPlayerSlotState>
declare const PLAYER_SLOT_STATE_PLAYING: ReturnType<typeof ConvertPlayerSlotState>
declare const PLAYER_SLOT_STATE_LEFT: ReturnType<typeof ConvertPlayerSlotState>
declare const SOUND_VOLUMEGROUP_UNITMOVEMENT: ReturnType<typeof ConvertVolumeGroup>
declare const SOUND_VOLUMEGROUP_UNITSOUNDS: ReturnType<typeof ConvertVolumeGroup>
declare const SOUND_VOLUMEGROUP_COMBAT: ReturnType<typeof ConvertVolumeGroup>
declare const SOUND_VOLUMEGROUP_SPELLS: ReturnType<typeof ConvertVolumeGroup>
declare const SOUND_VOLUMEGROUP_UI: ReturnType<typeof ConvertVolumeGroup>
declare const SOUND_VOLUMEGROUP_MUSIC: ReturnType<typeof ConvertVolumeGroup>
declare const SOUND_VOLUMEGROUP_AMBIENTSOUNDS: ReturnType<typeof ConvertVolumeGroup>
declare const SOUND_VOLUMEGROUP_FIRE: ReturnType<typeof ConvertVolumeGroup>
declare const GAME_STATE_DIVINE_INTERVENTION: ReturnType<typeof ConvertIGameState>
declare const GAME_STATE_DISCONNECTED: ReturnType<typeof ConvertIGameState>
declare const GAME_STATE_TIME_OF_DAY: ReturnType<typeof ConvertFGameState>
declare const PLAYER_STATE_GAME_RESULT: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_RESOURCE_GOLD: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_RESOURCE_LUMBER: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_RESOURCE_HERO_TOKENS: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_RESOURCE_FOOD_CAP: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_RESOURCE_FOOD_USED: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_FOOD_CAP_CEILING: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_GIVES_BOUNTY: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_ALLIED_VICTORY: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_PLACED: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_OBSERVER_ON_DEATH: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_OBSERVER: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_UNFOLLOWABLE: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_GOLD_UPKEEP_RATE: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_LUMBER_UPKEEP_RATE: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_GOLD_GATHERED: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_LUMBER_GATHERED: ReturnType<typeof ConvertPlayerState>
declare const PLAYER_STATE_NO_CREEP_SLEEP: ReturnType<typeof ConvertPlayerState>
declare const UNIT_STATE_LIFE: ReturnType<typeof ConvertUnitState>
declare const UNIT_STATE_MAX_LIFE: ReturnType<typeof ConvertUnitState>
declare const UNIT_STATE_MANA: ReturnType<typeof ConvertUnitState>
declare const UNIT_STATE_MAX_MANA: ReturnType<typeof ConvertUnitState>
declare const AI_DIFFICULTY_NEWBIE: ReturnType<typeof ConvertAIDifficulty>
declare const AI_DIFFICULTY_NORMAL: ReturnType<typeof ConvertAIDifficulty>
declare const AI_DIFFICULTY_INSANE: ReturnType<typeof ConvertAIDifficulty>
declare const PLAYER_SCORE_UNITS_TRAINED: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_UNITS_KILLED: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_STRUCT_BUILT: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_STRUCT_RAZED: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_TECH_PERCENT: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_FOOD_MAXPROD: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_FOOD_MAXUSED: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_HEROES_KILLED: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_ITEMS_GAINED: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_MERCS_HIRED: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_GOLD_MINED_TOTAL: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_GOLD_MINED_UPKEEP: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_GOLD_LOST_UPKEEP: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_GOLD_LOST_TAX: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_GOLD_GIVEN: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_GOLD_RECEIVED: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_LUMBER_TOTAL: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_LUMBER_LOST_UPKEEP: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_LUMBER_LOST_TAX: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_LUMBER_GIVEN: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_LUMBER_RECEIVED: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_UNIT_TOTAL: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_HERO_TOTAL: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_RESOURCE_TOTAL: ReturnType<typeof ConvertPlayerScore>
declare const PLAYER_SCORE_TOTAL: ReturnType<typeof ConvertPlayerScore>
declare const EVENT_GAME_VICTORY: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_END_LEVEL: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_VARIABLE_LIMIT: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_STATE_LIMIT: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_TIMER_EXPIRED: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_ENTER_REGION: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_LEAVE_REGION: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_TRACKABLE_HIT: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_TRACKABLE_TRACK: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_SHOW_SKILL: ReturnType<typeof ConvertGameEvent>
declare const EVENT_GAME_BUILD_SUBMENU: ReturnType<typeof ConvertGameEvent>
declare const EVENT_PLAYER_STATE_LIMIT: ReturnType<typeof ConvertPlayerEvent>
declare const EVENT_PLAYER_ALLIANCE_CHANGED: ReturnType<typeof ConvertPlayerEvent>
declare const EVENT_PLAYER_DEFEAT: ReturnType<typeof ConvertPlayerEvent>
declare const EVENT_PLAYER_VICTORY: ReturnType<typeof ConvertPlayerEvent>
declare const EVENT_PLAYER_LEAVE: ReturnType<typeof ConvertPlayerEvent>
declare const EVENT_PLAYER_CHAT: ReturnType<typeof ConvertPlayerEvent>
declare const EVENT_PLAYER_END_CINEMATIC: ReturnType<typeof ConvertPlayerEvent>
declare const EVENT_PLAYER_UNIT_ATTACKED: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_RESCUED: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_DEATH: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_DECAY: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_DETECTED: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_HIDDEN: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_SELECTED: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_DESELECTED: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_CONSTRUCT_START: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_CONSTRUCT_CANCEL: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_CONSTRUCT_FINISH: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_UPGRADE_START: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_UPGRADE_CANCEL: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_UPGRADE_FINISH: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_TRAIN_START: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_TRAIN_CANCEL: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_TRAIN_FINISH: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_RESEARCH_START: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_RESEARCH_CANCEL: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_RESEARCH_FINISH: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_ISSUED_ORDER: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_ISSUED_POINT_ORDER: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_ISSUED_TARGET_ORDER: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_ISSUED_UNIT_ORDER: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_HERO_LEVEL: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_HERO_SKILL: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_HERO_REVIVABLE: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_HERO_REVIVE_START: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_HERO_REVIVE_CANCEL: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_HERO_REVIVE_FINISH: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_SUMMON: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_DROP_ITEM: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_PICKUP_ITEM: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_USE_ITEM: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_PLAYER_UNIT_LOADED: ReturnType<typeof ConvertPlayerUnitEvent>
declare const EVENT_UNIT_DAMAGED: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_DEATH: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_DECAY: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_DETECTED: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_HIDDEN: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_SELECTED: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_DESELECTED: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_STATE_LIMIT: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_ACQUIRED_TARGET: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_TARGET_IN_RANGE: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_ATTACKED: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_RESCUED: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_CONSTRUCT_CANCEL: ReturnType<typeof ConvertUnitEvent>
declare const EVENT_UNIT_CONSTRUCT_FINISH: Return