ggejs/typings/index.d.ts

A powerful JavaScript library for interacting with the server of Goodgame Empire: Four Kingdoms

import {EventEmitter} from "node:events";
import {Socket as netSocket} from 'node:net';
import {
    ConstructionItem,
    Dungeon as RawDungeon,
    Effect as RawEffect,
    Gem as RawGem,
    General as RawGeneral,
    Lord as RawLord,
    NetworkInstance,
    Title,
    Unit as RawUnit,
    Quest as RawQuest
} from 'e4k-data'

export {Client, Horse, InventoryItem, MovementManager};
export const Constants: IConstants;

/** Base class for a player account */
declare class Client extends EventEmitter {
    public alliances: AllianceManager;
    public clientUserData: ClientUserDataManager;
    public equipments: EquipmentManager;
    public movements: MovementManager;
    public players: PlayerManager;
    public worldMaps: WorldMapManager;
    public externalClient: Client | null;

    private _serverInstance: NetworkInstance;
    private _socket: Socket;
    private _language: string;

    /**
     * @param name Your player account name
     * @param password Your player account password
     * @param serverInstance Your player account serverInstance
     * @param debug
     * @example ```js
     * const e4kNetworkInstances = require('e4k-data').network.instances.instance;
     * const worldNetworkInstance = e4kNetworkInstances.find(i => i.instanceLocaId === "generic_country_world");
     * const client = new Client(playername, password, worldNetworkInstance)
     */
    public constructor(name: string, password: string, serverInstance: NetworkInstance, debug: boolean = false);

    public set language(val: string);

    public get mailMessages(): MailMessage[];

    public set reconnectTimeout(val: number);

    /** Login with your credentials */
    public connect(): Promise<Client>;

    private _verifyLoginData(): void;

    public sendChatMessage(message: string): void;

    public sendMailMessage(playerName: string, subject: string, message: string): void;

    public getCastleInfo(Mapobject: InteractiveMapobject): Promise<Castle>;

    public on<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): this;

    public addListener<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): this;

    public emit<K extends keyof ClientEvents>(eventName: K, ...args: ClientEvents[K]): boolean;

    private __x__x__relogin(): Promise<void>;
}

declare class Socket extends netSocket {
    public client: Client;
    public debug: boolean;
    public ultraDebug: boolean;
    public _host: string;
}

//#region Managers
declare class BaseManager extends EventEmitter {
    protected _client: Client;
    protected _socket: Socket;

    protected constructor(client: Client);
}

declare class AllianceManager extends BaseManager {
    private constructor(client: Client);

    public async getById(id: number): Promise<Alliance>;

    public async find(name: string): Promise<Alliance>;

    public async getMyAlliance(): Promise<MyAlliance>;

    public async getRankings(nameOrRanking: string | number, rankingType: AllianceHighScoreRankingTypes = "might", leagueId: number = 1): Promise<HighScore<AllianceHighScoreItem>>
}

declare class ClientUserDataManager {
    private constructor(client: Client);

    public boostData: PremiumBoostData;
    public questData: QuestData;

    public get isXPDataInitialized(): boolean;
    private set isXPDataInitialized(val: number);

    public get userXp(): number;
    private set userXp(val: number);

    public get userXpCurrentLevel(): number;
    private set userXpCurrentLevel(val: number);

    public get userXPtoNextLevel(): number;
    private set userXPtoNextLevel(val: number);

    public get displayXP(): number;
    private set displayXP(val: number);

    public get hasPremiumFlag(): boolean;
    private set hasPremiumFlag(val: boolean);

    public get userRanking(): number;
    private set userRanking(val: number);

    public get mightpoints(): number;
    private set mightpoints(val: number);

    public get highestAchievedMight(): number;
    private set highestAchievedMight(val: number);

    public get paymentDoublerCount(): number;
    private set paymentDoublerCount(val: number);

    public get isPayUser(): boolean;
    private set isPayUser(val: boolean);

    public get userId(): number;
    private set userId(val: number);

    public get playerId(): number;
    private set playerId(val: number);

    public get userName(): string;
    private set userName(val: string);

    public get email(): string;
    private set email(val: string);

    public get pendingEmailChange(): string | null;
    private set pendingEmailChange(val: string | null);

    public get isCheater(): boolean;
    private set isCheater(val: boolean);

    public get hasEverChangedName(): boolean;
    private set hasEverChangedName(val: boolean);

    public get hasConfirmedTOC(): boolean;
    private set hasConfirmedTOC(val: boolean);

    public get isAccountSaved(): boolean;
    private set isAccountSaved(val: boolean);

    public get hasFreeCastleRename(): boolean;
    private set hasFreeCastleRename(val: boolean);

    public get lifeTimeSpent(): number
    private set lifeTimeSpent(val: number)

    public get facebookId(): string | null;
    private set facebookId(val: string | null);

    public get minUserNameLength(): number;
    private set minUserNameLength(): number;

    public get allianceId(): number;
    private set allianceId(val: number);

    public get allianceRank(): number;
    private set allianceRank(val: number);

    public get allianceCurrentFame(): number;
    private set allianceCurrentFame(val: number);

    public get isSearchingAlliance(): boolean;
    private set isSearchingAlliance(val: boolean);

    public get wasResetted(): boolean;
    private set wasResetted(val: boolean);

    public get selectedHeroId(): number;
    private set selectedHeroId(val: number);

    public get lastUserActivity(): Date;
    private set lastUserActivity(val: number);

    public get maxSpies(): number;
    private set maxSpies(val: number);

    public get availablePlagueMonks(): number;
    private set availablePlagueMonks(val: number);

    public get noobProtectionEndTime(): Date;
    private set noobProtectionEndTime(val: Date);

    public get noobProtected(): boolean;
    private set noobProtected(val: boolean);

    public get peaceProtectionStatusEndTime(): Date;
    private set peaceProtectionStatusEndTime(val: Date);

    public get peaceModeStatus(): number;
    private set peaceModeStatus(val: number);

    public get activeMovementFilters(): number[];
    private set activeMovementFilters(val: number[]);

    public get relocationCount(): number;
    private set relocationCount(val: number);

    public get relocationDurationEndTime(): Date;
    private set relocationDurationEndTime(val: Date);

    public get relocationCooldownEndTime(): Date;
    private set relocationCooldownEndTime(val: Date);

    public get relocationDestination(): Coordinate;
    private set relocationDestination(val: Coordinate);

    public get mayChangeCrest(): boolean;
    private set mayChangeCrest(val: boolean);

    public get playerCrest(): Crest;
    private set playerCrest(val: Crest);

    public get globalCurrencies(): Good[]

    private setGlobalCurrency(val: Good);

    public get titlePrefix(): Title
    private set titlePrefix(val: number);

    public get titleSuffix(): Title
    private set titleSuffix(val: number);

    public get level(): number;

    public get legendaryLevel(): number;

    public get honor(): number;

    public get registrationDate(): Date;

    private set userLevel(val: number);

    private set userParagonLevel(val: number);

    private set userHonor(val: number);

    private set registrationTimestamp(val: number);

    public isLegendLevel(): boolean;

    public titlePoints(titleType: number): number

    public currentTitle(titleType: number): Title

    public highestTitlePoints(titleType: number): number

    private setKingdomNoobProtection(kingdomID: number, remainingNoobTimeInSeconds: number): void;

    private setTitlePoints(points: number, titleType: number): void

    private setCurrentTitle(titleType: number, title: Title): void

    private clearCurrentTitle(titleType: number): void

    private setHighestTitlePoints(points: number, titleType: number): void

    /* todo: TitleRatingStatus
    setTitleRatingStatus(titleRatingStatus: TitleRatingStatus, titleType: number): void;
    titleRatingStatus(titleType: number): TitleRatingStatus
     */

    public get showVIPFlagOption(): boolean
    private set showVIPFlagOption(val: boolean)

    public get vipPoints(): number
    private set vipPoints(points: number)

    public get maxVIPLevelReached(): number
    private set maxVIPLevelReached(level: number)

    public get usedPremiumGenerals(): number
    private set usedPremiumGenerals(val: number)

    public get vipTimeExpireDate(): Date

    private set vipTimeExpireTimestamp(val: number)

    public get myAlliance(): MyAlliance
    private set myAlliance(val: MyAlliance)
}

declare class EquipmentManager extends BaseManager {
    private constructor(client: Client);

    public set autoDeleteAtOrBelowRarity(rarity: number);

    public set autoDeleteAtOrBelowGemLevel(rarity: number);

    public get equipmentSpaceLeft(val: number);
    private set equipmentSpaceLeft(val: number);

    public get equipmentTotalInventorySpace(val: number);
    private set equipmentTotalInventorySpace(val: number);

    public get gemSpaceLeft(val: number);
    private set gemSpaceLeft(val: number);

    public get gemTotalInventorySpace(val: number);
    private set gemTotalInventorySpace(val: number);

    public getCommandants(): Lord[];

    /** Returns Array with all idle commandants.*/
    public getAvailableCommandants(): Lord[];

    public getBarons(): Lord[];

    public getGenerals(): General[];

    public getEquipmentInventory(): (Equipment | RelicEquipment)[];

    public sellEquipment(equipment: Equipment | RelicEquipment): Promise<void>;

    public sellAllEquipmentsAtOrBelowRarity(rarity: number): Promise<void>;

    public getRegularGemInventory(): { gem: Gem, amount: number }[];

    public getRelicGemInventory(): RelicGem[];

    public sellGem(gem: Gem | RelicGem): Promise<void>;

    public sellAllGemsAtOrBelowLevel(level: number): Promise<void>;

    private _setCommandantsAndBarons(barons: Lord[], commandants: Lord[]): void;

    private _setGenerals(generals: General[]): void;

    private _setEquipmentInventory(equipments: (Equipment | RelicEquipment)[]): void;

    private _autoSellEquipment(e: Equipment | RelicEquipment): Promise<void>;

    private _setRegularGemInventory(gems: { gem: Gem, amount: number }[]): void;

    private _setRelicGemInventory(gems: RelicGem[]): void;

    private _autoSellGem(gem: Gem): Promise<void>;
}

declare class MovementManager extends BaseManager {
    private constructor(client: Client);

    public getDistance(castle1: Mapobject | CastlePosition, castle2: Mapobject | CastlePosition): number;

    public static getDistance(castle1: Mapobject | CastlePosition, castle2: Mapobject | CastlePosition): number;

    public on<K extends keyof MovementEvents>(event: K, listener: (...args: MovementEvents[K]) => void): this;

    public addListener<K extends keyof MovementEvents>(event: K, listener: (...args: MovementEvents[K]) => void): this;

    emit<K extends keyof MovementEvents>(eventName: K, ...args: MovementEvents[K]): boolean;

    /** Returns all movements */
    public get(): Movement[];

    public startAttackMovement(castleFrom: InteractiveMapobject, castleTo: Mapobject | CastlePosition, army: ArmyWave[], lord: Lord, horse?: Horse): void;

    public startSpyMovement(castleFrom: InteractiveMapobject, castleTo: Mapobject | CastlePosition, spyCount: number, spyType: number, spyEffect: number, horse?: Horse): void;

    public startMarketMovement(castleFrom: InteractiveMapobject, castleTo: Mapobject | CastlePosition, goods: Good[], horse?: Horse): void;

    private _add_or_update(_movements: Movement[]): void;

    private _remove(_movementId: number): void;
}

declare class PlayerManager extends BaseManager {
    private constructor(client: Client);

    public async getById(id: number): Promise<Player>;

    public async find(name: string): Promise<Player>;

    public async getThisPlayer(): Promise<Player>;

    public async getRankings(nameOrRanking: string | number, rankingType: PlayerHighScoreRankingTypes = "might", leagueId: number = 1): Promise<LeaderboardList>
}

declare class WorldMapManager extends BaseManager {
    private _ownerInfoData

    /**
     * Returns the complete worldMap, use {@link getSector} if only part of it is needed
     * @param kingdomId Only kingdoms you have a castle in are valid
     */
    public async get(kingdomId: number): Promise<WorldMap>;

    /**
     * Returns a 100x100 area of a certain worldMap with center {@link centerX}/{@link centerY}
     * @param kingdomId Only kingdoms you have a castle in are valid
     * @param centerX X coordinate that will be the center of sector
     * @param centerY Y coordinate that will be the center of sector
     * @returns 100x100 WorldMapSector
     */
    public async getSector(kingdomId: number, centerX: number, centerY: number): Promise<WorldMapSector>;
}

//#endregion

//#region Movement
/** */
type Movement =
    BasicMovement
    | ArmyAttackMovement
    | ArmyTravelMovement
    | SiegeMovement
    | MarketMovement
    | SpyMovement;

declare class BasicMovement {
    public movementId: number;
    public movementType: number;
    public arrivalTime: Date;
    public departureTime: Date;
    public direction: number;
    public sourceArea: Mapobject;
    public targetArea: Mapobject;
    public ownerArea: Mapobject;
    public distance: number;
    public kingdomId: number;
    public horseBoosterWodId: number;
    public endWaitTime?: Date;
    public lord?: Lord;
    public general?: General;

    protected constructor(client: Client, data: object);
}

declare class ArmyAttackMovement extends BasicMovement {
    public army?: CompactArmy;
    public armyState: number;
    public attackType: AttackType;
    public guessedSize?: number;
    public isForceCancelable: boolean;
    public isShadowMovement: boolean;

    protected constructor(client: Client, data);
}

declare class ArmyTravelMovement extends BasicMovement {
    public army: InventoryItem<Unit>[];
    public goods?: Good[];

    protected constructor(client: Client, data);
}

declare class SiegeMovement extends BasicMovement {
    public army: InventoryItem<Unit>[];

    protected constructor(client: Client, data);
}

declare class MarketMovement extends BasicMovement {
    public goods: Good[];
    public carriages: number;

    protected constructor(client: Client, data);
}

declare class SpyMovement extends BasicMovement {
    public spyType: number;
    public spyCount: number;
    public spyRisk: number;
    public spyAccuracy?: number;
    public sabotageDamage?: number;

    protected constructor(client: Client, data);
}

declare class SupportDefenceMovement extends ArmytravelMovement {
}

declare class InventoryItem<T> {
    item: T;
    count: number;

    constructor(item: T, count: number);
}

declare class ArmyWave {
    left: {
        units: InventoryItem<Unit>[],
        tools: InventoryItem<Tool>[],
    }
    middle: {
        units: InventoryItem<Unit>[],
        tools: InventoryItem<Tool>[],
    }
    right: {
        units: InventoryItem<Unit>[],
        tools: InventoryItem<Tool>[],
    }
}

declare class Horse {
    wodId: number;
    comment1: string;
    comment2: string;
    type: number;
    unitBoost: number;
    marketBoost: number;
    spyBoost: number;
    costFactorC1: number;
    costFactorC2: number;
    isInstantSpyHorse: boolean;
    isPegasusHorse: boolean;

    constructor(client: Client, castleData, horseType: number);
}

//#endregion

//#region Alliance
/** */
declare class Alliance {
    public allianceId: number;
    public allianceName: string;
    public allianceDescription: string;
    public languageId: string;
    public memberLevel: number;
    public memberList: AllianceMember[];
    public allianceStatusToOwnAlliance: number;
    public allianceFamePoints: number;
    public allianceFamePointsHighestReached: number
    public canInvitedForHardPact: boolean;
    public canInvitedForSoftPact: boolean;
    public isSearchingMembers: boolean;
    public isOpenAlliance: boolean;
    public freeRenames: number;
    public might: number;

    protected constructor(client: Client, data);

    public get landmarks(): (CapitalMapobject | KingstowerMapobject | MetropolMapobject | MonumentMapobject)[];

    private set _landmarks(value: (CapitalMapobject | MonumentMapobject | KingstowerMapobject)[]);

    private _add_or_update_landmarks(landmarks: Mapobject[]): void;
}

declare class MyAlliance extends Alliance {
    public isAutoWarOn: boolean;
    public applicationAmount: number;
    public announcement: string;
    public aquaPoints: number;
    public cargoPointsRanking: number;
    public storage: Good[];
    public statusList: AllianceStatusListItem[];
    public capitals: CapitalMapobject[];
    public metropols: MetropolMapobject[];
    public kingstowers: KingstowerMapobject[];
    public monuments: MonumentMapobject[];
    public highestMight: number;
    public highestFamePoints: number;

    private parseStorage(client: Client, data: Object): void;
}

declare class AllianceMember extends WorldMapOwnerInfo {
    public alliance: Alliance;
    public donations?: AllianceDonations;
    public activityStatus?: number;

    private constructor(client: Client, data, alliance: Alliance);
}

declare class AllianceStatusListItem {
    public allianceId: number;
    public allianceName: string;
    public allianceStatus: number;
    public allianceStatusConfirmed: boolean;

    private constructor(client: Client, data);
}

declare class AllianceDonations {
    public coins: number
    public rubies: number;
    public res: number;

    private constructor(client: Client, data: Array<number>);
}

declare class ChatMessage {
    public message: string;
    public sendDate: Date;
    public senderPlayerId: number;
    public senderPlayerName: string;
}

//#endregion

declare class CompactArmy {
    public left: InventoryItem<Unit>[];
    public middle: InventoryItem<Unit>[];
    public right: InventoryItem<Unit>[];
    public supportTools: InventoryItem<Tool>[];
    public finalWave: InventoryItem<Unit>[];
    public armySize: number;
    public soldierCount: number;
    public toolCount: number;

    private constructor(client: Client, data: object);
}

declare class Coordinate {
    public X: number;
    public Y: number;

    private constructor(client: Client, data: number[]);
}

declare class CastlePosition {
    public kingdomId: number;
    public objectId: number;
    public xPos: number;
    public yPos: number;
    public areaType: number;

    public get position(): Coordinate;
}

declare class Good extends InventoryItem<string> {
    private constructor(client: Client, data: [string, number]);
}

//#region Lord and Equipment
/** */
declare class Lord {
    public id: number;
    public isDummy: boolean;
    public name: string;
    public wins: number;
    public defeats: number;
    public winSpree: number;
    public equipments: Equipment[] | RelicEquipment[];
    public generalId: number;
    public isRelic?: boolean;
    public gems: Gem[] | RelicGem[];
    public effects: Effect[] | RelicEffect[];
    public wearerId: number;
    public pictureId: number;
    public attachedCastleId?: number;
    public rawData: RawLord;
}

declare class General {
    public generalId: number;
    public rawData: RawGeneral;
    public level: number;
    public xp: number;
    public xpBeforeBattle: number;
    public starTier: number;
    public isNew: number;
    public leveledUp: number;
    public attackAbilities: { slotId: number, abilityId: number }[];
    public defenseAbilities: { slotId: number, abilityId: number }[];
    public activatedSkillIds: number[];
    public wins: number;
    public defeats: number;
    public abilitiesPerWave: { [key: number]: { abilityId: number, waveId: number, abilityValue: number } };
}

declare class Equipment {
    public id: number;
    public slotId: number;
    public wearerId: number;
    public rarityId: number;
    public pictureId: number;
    public canSlotGem: boolean;
    public enhancementLevel: number;
    public setId: number;
    public effects: Effect[];
    public attachedGem?: Gem;
    public equippedLord?: Lord;
}

declare class RelicEquipment {
    public id: number;
    public slotId: number;
    public wearerId: number;
    public rarityId: number;
    public canSlotGem: boolean;
    public enhancementLevel: number;
    public relicTypeId: number;
    public relicCategoryId: number;
    public mightValue: number;
    public effects: RelicEffect[];
    public attachedGem?: RelicGem;
    public equippedLord?: Lord;
}

declare class Gem {
    public id: number;
    public setId?: number;
    public effects: Effect[];
    public attachedEquipment?: Equipment;
    public rawData: RawGem;
}

declare class RelicGem {
    public id: number;
    public slotId: number;
    public enhancementLevel: number;
    public relicTypeId: number;
    public relicCategoryId: number;
    public mightValue: number;
    public effects: RelicEffect[];
    public attachedEquipment?: RelicEquipment;
}

//#endregion

declare class Effect {
    public effectId: number;
    public power: number;
    public name: string;
    public capId: number;
    public uncappedPower: number;
    public rawData: RawEffect;
}

declare class RelicEffect extends Effect {
    public relicEffectId: number;
}

declare class Player extends WorldMapOwnerInfo {
    public castles: (CastleMapobject | CapitalMapobject)[];
    public villages: {
        public: {
            village: VillageMapobject,
            units?: InventoryItem<Unit>[]
        }[],
        private: { privateVillageId: number, uniqueId: number }[]
    };
    public kingstowers: {
        kingstower: KingstowerMapobject;
        units?: InventoryItem<Unit>[];
    }[];
    public monuments: {
        monument: MonumentMapobject;
        units?: InventoryItem<Unit>[];
    }[];
}

declare class Unit {
    public wodId: number;
    public isSoldier: boolean;
    public rangeAttack?: number;
    public meleeAttack?: number;
    public rangeBonus?: number;
    public meleeBonus?: number;
    public fightType?: number;
    public rangeDefence?: number;
    public meleeDefence?: number;
    public rawData: RawUnit;

    constructor(client: Client, wodId: number);
}

declare class Tool extends Unit {

}

declare class WorldMap {
    public kingdomId: number;
    public mapObjects: Mapobject[];

    private _addAreaMapObjects(objs: Mapobject[]): void;

    private _clear(): void;
}

declare class WorldMapSector extends WorldMap {
    public combine(...sectors: WorldMapSector[]): WorldMapSector
}

declare class WorldMapOwnerInfo {
    public playerId: number;
    public playerLevel: number;
    public paragonLevel: number;
    public noobEndTime: Date;

    public get honor(): number;

    public highestFamePoints: number;
    public fameTopX: number;

    public get isRuin(): boolean;

    public get allianceId(): number;

    public get allianceRank(): number;

    public peaceEndTime: Date;
    public castlePosList: CastlePosition[];

    public get might(): number;

    public relocateDurationEndTime: Date;
    public factionId: number;
    public factionIsSpectator: boolean;
    public factionProtectionStatus: number;
    public factionProtectionEndTime: Date;
    public factionNoobProtectionEndTime: Date;
    public isOutpostOwner: number;
    public isNPC: boolean;
    public crest: Crest;

    public get isRuin(): boolean;

    public get playerTotalLevel(): number;

    public get isParagon(): boolean;

    public get playerName(): string;
    public set playerName(): string;

    public get isInAlliance(): boolean;

    public get allianceName(): string;

    public getMainCastlePositionFromPosListByKingdomId(kingdomId: number): Coordinate;

    public getCastlePosListItemByPos(pos: Coordinate): CastlePosition;

    public getMainCastlePositionFromPosListForCurrentKingdom(): Coordinate;

    public getCastlePosListByKingdomId(kID: number): CastlePosition[];

    public get isOwnOwnerInfo(): boolean;

    public get famePoints(): number;

    public isSearchingAlliance(): boolean;

    public hasPremiumFlag(): boolean;

    public hasVIPFlag(): boolean;

    public isRankInfoVisible(): boolean;

    public get achievementPoints(): number;

    public get factionMainCampId(): number;

    public isMainCastlePosInKingdom(castlePos: CastlePosition, kingdomId: number): boolean;

    public titleVO//todo :IsleTitleViewVO
    public get prefixTitleId(): number;

    public get suffixTitleId(): number;

    public staticAreaName: string;

    public setNamesFactory(value/*todo :KingdomSkinNamesFactory*/, nameTextId: string);

    public getCrestByKingdomId(kingdomId: number, isShadowMovement: boolean = false): Crest;

    public get isNoobProtected(): boolean;

    public get isPeaceProtected(): boolean;

    public get isFactionNoobProtected(): boolean;

    public get isFactionProtected(): boolean;

    public getFactionMainCampPosition(): Coordinate;
}

//#region Mapobject
/** */
type Mapobject =
    BasicMapobject
    | AlienInvasionMapobject
    | BossDungeonMapobject
    | CapitalMapobject
    | CastleMapobject
    | DaimyoCastleMapobject
    | DaimyoTownshipMapobject
    | DungeonMapobject
    | DungeonIsleMapobject
    | DynamicMapobject
    | EmptyMapobject
    | EventDungeonMapobject
    | FactionCampMapobject
    | FactionCapitalMapobject
    | FactionTowerMapobject
    | FactionVillageMapobject
    | KingstowerMapobject
    | MetropolMapobject
    | MonumentMapobject
    | NomadInvasionMapobject
    | NomadKhanInvasionMapobject
    | RedAlienInvasionMapobject
    | ResourceIsleMapobject
    | SamuraiInvasionMapobject
    | ShadowAreaMapobject
    | ShapeshifterMapobject
    | VillageMapobject
    | WolfKingMapobject;

declare class AlienInvasionMapobject extends InteractiveMapobject {
    public dungeonLevel: number;
    public hasPeaceMode: boolean;
    public wasRerolled: boolean;
    public travelDistance: number;
    public eventId: number;
}

declare class BasicMapobject {
    public areaType: number;
    public position: Coordinate;
    public mapId?: number;
    public kingdomId?: number;

    protected constructor(client: Client, data: Array<string | number | object>);

    protected parseAreaInfoBattleLog(data): this;
}

declare class BossDungeonMapobject extends InteractiveMapobject {
    public dungeonLevel: number;
    public defeaterPlayerId: number;
}

declare class CapitalMapobject extends InteractiveMapobject {
    public depletionTimeEnd?: Date;
    public influencePoints: number;
}

declare class CastleMapobject extends InteractiveMapobject {
}

declare class DaimyoMapobject extends SamuraiInvasionMapobject {
    daimyoId: number;
    totalCooldown: number;
    skipCost: number;
}

declare class DaimyoCastleMapobject extends DaimyoMapobject {

}

declare class DaimyoTownshipMapobject extends DaimyoMapobject {

}

declare class DungeonIsleMapobject extends InteractiveMapobject {
    public isleId: number;
    public attackCount: number;
    public reappearDate?: Date;
    public isVisibleOnMap: boolean;
}

declare class DungeonMapobject extends InteractiveMapobject {
    public attackCount: number;
    public level: number;
    public resources: number;
    public coins: number;
    public rubies: number;
    public rubyProbability: number;
    public wallWodId: number;
    public gateWodId: number;
    public guards: number;
    public xp: number;
    private _rawData: RawDungeon;

    private _defence: {
        troops: {
            middle: InventoryItem<Unit>[],
            left: InventoryItem<Unit>[],
            center: InventoryItem<Unit>[],
            right: InventoryItem<Unit>[]
        },
        tools: { middle: InventoryItem<Unit>[], left: InventoryItem<Unit>[], right: InventoryItem<Unit>[] }
    };
    public get defence(): {
        troops: {
            left: InventoryItem<Unit>[],
            middle: InventoryItem<Unit>[],
            right: InventoryItem<Unit>[],
            center: InventoryItem<Unit>[]
        },
        tools: {
            left: InventoryItem<Tool>[],
            middle: InventoryItem<Tool>[],
            right: InventoryItem<Tool>[],
            center: InventoryItem<Tool>[]
        }
    };

    private _lord: Lord;
    public get lord(): Lord;
}

declare class DynamicMapobject extends BasicMapobject {

}

declare class EmptyMapobject extends BasicMapobject {

}

declare class EventDungeonMapobject extends InteractiveMapobject {
    public dungeonLevel: number;
    public isDefeated: boolean;
    public skinId: number;

    get areaName(): string;
}

declare class FactionCampMapobject extends FactionInteractiveMapobject {
    get areaName(): string;
}

declare class FactionCapitalMapobject extends FactionInteractiveMapobject {
    travelDistance: number;
    dungeonLevel: number;

    get areaName(): string;
}

declare class FactionInteractiveMapobject extends InteractiveMapobject {
    isDestroyed: boolean;
    aliveProtectorPositions: Array<Coordinate>

    get titleText(): number

    get levelText(): number

    get specialCampId(): number
}

declare class FactionTowerMapobject extends FactionInteractiveMapobject {
    travelDistance: number;
    dungeonLevel: number;
    attacksLeft: number;
    wallWodId: number;
    gateWodId: number;

    get areaName(): string;
}

declare class FactionVillageMapobject extends FactionInteractiveMapobject {
    travelDistance: number;
    dungeonLevel: number;

    get areaName(): string;
}

declare class InteractiveMapobject extends BasicMapobject {
    public objectId: number;
    public ownerId: number;
    public ownerInfo: WorldMapOwnerInfo;
    public keepLevel: number;
    public wallLevel: number;
    public gateLevel: number;
    public towerLevel: number;
    public moatLevel: number;
    public customName: string;
    public attackCooldownEnd?: Date;
    public sabotageCooldownEnd?: Date;
    public lastSpyDate?: Date;
    public occupierId: number;
    public equipmentId: number;
    public outpostType: number;
}

declare class InvasionMapobject extends InteractiveMapobject {
    public victoryCount: number;
    public difficultyCampId: number;
    public baseWallBonus: number;
    public baseGateBonus: number;
    public baseMoatBonus: number;
    public isVisibleOnMap: boolean;
    public eventId: number;
    public travelDistance: number;
}

declare class KingstowerMapobject extends InteractiveMapobject {
}

declare class MonumentMapobject extends InteractiveMapobject {
    public monumentType: number;
    public monumentLevel: number;
}

declare class MetropolMapobject extends CapitalMapobject {
}

declare class NomadInvasionMapobject extends InvasionMapobject {
}

declare class NomadKhanInvasionMapobject extends InvasionMapobject {
    public allianceCampId: number;
    public totalCooldown: number;
    public skipCost: number;
}

declare class RedAlienInvasionMapobject extends AlienInvasionMapobject {
}

declare class ResourceIsleMapobject extends InteractiveMapobject {
    public isleId: number;
    public occupationFinishedDate: Date;
}

declare class SamuraiInvasionMapobject extends InvasionMapobject {
}

declare class ShadowAreaMapobject extends InteractiveMapobject {
}

declare class ShapeshifterMapobject extends InteractiveMapobject {
    public campLevel: number;
    public playerAttacked: boolean;
    public shapeshifterAttacked: boolean;
    public shapeshifterId: number;
    public eventId: number;
    public travelDistance: number;
}

declare class VillageMapobject extends InteractiveMapobject {
    public villageType: number;
    public unitWallCount: number;
    public peasants: number;
    public guards: number;
    public productivityWoodBoost: number;
    public productivityStoneBoost: number;
    public productivityFoodBoost: number;
}

declare class WolfKingMapobject extends InteractiveMapobject {
    public level: number;
    public isDefeated: boolean;
    public isVisibleOnMap: boolean;
    public baseWallBonus: number;
    public baseGateBonus: number;
    public baseMoatBonus: number;
    public travelDistance: number;
}

//#endregion
//#region MailMessage
/** All types of MailMessages */
type MailMessage =
    BasicMessage
    | BattleLogConquerMessage
    | BattleLogNormalAttackMessage
    | BattleLogNPCAttackMessage
    | BattleLogOccupyMessage
    | AllianceNewsMessage
    | UserMessage
    | SpyPlayerSabotageSuccessfulMessage
    | SpyPlayerSabotageFailedMessage
    | SpyPlayerDefenceMessage
    | SpyPlayerEconomicMessage
    | SpyNPCMessage
    | MarketCarriageArrivedMessage
    | PrivateOfferBestsellerShopMessage
    | PrivateOfferDungeonChestMessage
    | PrivateOfferTimeChallengeMessage
    | PrivateOfferTippMessage
    | PrivateOfferWhaleChestMessage
    | BreweryMissingResourcesMessage
    | DoubleRubiesMessage
    | StarveInfoMessage
    | AttackCancelledAbortedMessage
    | AttackCancelledAutoRetreatMessage
    | AttackCancelledAutoRetreatEnemyMessage
    | SpyCancelledAbortedMessage
    | ProductionDowntimeMessage
    | PlayerGiftMessage
    | UserSurveyMessage
    | RebuyMessage
    | RuinInfoMessage
    | SpecialEventStartMessage
    | SpecialEventUpdateMessage
    | SpecialEventEndMessage
    | SpecialEventVIPInfoMessage
    | SpecialEventMonumentResetMessage
    | SpecialEventHospitalCapacityExceededMessage
    | AllianceWarEnemyAttackMessage
    | AllianceWarOwnAttackMessage
    | AllianceWarEnemyDeclarationMessage
    | AllianceWarEnemyEndMessage
    | AllianceWarEnemySabotageMessage
    | AllianceWarOwnDeclarationMessage
    | AllianceWarOwnSabotageMessage
    | ConquerableSiegeCancelledMessage
    | ConquerableNewSiegeMessage
    | ConquerableAreaConqueredMessage
    | ConquerableAreaLostMessage
    | PopupFacebookConnectionMessage
    | PopupLoginBonusMessage
    | PopupRegistrationGiftMessage
    | AllianceRequestMessage;

declare class BasicMessage {
    public messageId: number;
    public messageType: number;
    public subType: number;
    public metadata: string;
    public senderName: string;
    public subject: string;
    public playerId: number;
    public deliveryTime: Date;
    public isRead: boolean;
    public isArchived: boolean;
    public isForwarded: boolean;
    public canBeForwarded: boolean;

    protected constructor(client: Client, data: Array<any>);

    protected init(): Promise<void>;
}

declare class AllianceNewsMessage {
    public subject: string;
    public body: string;
}

declare class UserMessage {
    public subject: string;
    public body: string;
}

//#region BattleLogMessage
declare class BasicBattleLogMessage {
    public areaType: number;
    public subType: number;
    public hasAttackerWon: boolean;
    public isDefenseReport: boolean;
    public treasureMapId: number;
    public treasureMapNodeType: number;
    public kingdomId: number;
    public ownerId: number;
    public areaName: string;
    public subject: string;
    public battleLog: BattleLog;
}

declare class BattleLogConquerMessage extends BasicBattleLogMessage {
}

declare class BattleLogNormalAttackMessage extends BasicBattleLogMessage {
}

declare class BattleLogNPCAttackMessage extends BasicBattleLogMessage {
}

declare class BattleLogOccupyMessage extends BasicBattleLogMessage {
}

interface BattleLog {
    battleLogId: number,
    messageId: number,
    messageType: number,
    mapobject: Mapobject,
    attacker: BattleParticipant,
    defender: BattleParticipant,
    winner: BattleParticipant,
    loser: BattleParticipant,
    defWon: boolean,
    honor: number,
    survivalRate: number,
    ragePoints: number,
    shapeshifterPoints: number,
    shapeshifterId: number,
    rewardEquipment?: Equipment | RelicEquipment,
    rewardGem?: Gem,
    rewardMinuteSkips?: {},
    attackerHomeCastleId: number,
    attackerHadHospital: boolean,
    isAttackerHospitalFull: boolean,
    defenderHomeCastleId: number,
    defenderHadHospital: boolean,
    isDefenderHospitalFull: boolean,
    attackerAllianceSubscribers: number,
    defenderAllianceSubscribers: number,
    attackerHasIndividualSubscription: boolean,
    defenderHasIndividualSubscription: boolean,
    allianceName: string,
    attackerCommandant: Lord,
    attackerGeneral?: General,
    attackerLegendSkills: number[],
    defenderBaron: Lord
    defenderGeneral?: General,
    defenderLegendSkills: number[],
    courtyardAttacker: BattleLogUnit<Unit>[],
    courtyardDefender: BattleLogUnit<Unit>[],
    wavesAttacker: BattleLogArmyWave[],
    wavesDefender: BattleLogArmyWave[],
    finalWaveAttacker: BattleLogUnit<Unit>[],
    supportToolsAttacker: BattleLogUnit<Unit>[],
    supportToolsDefender: BattleLogUnit<Unit>[],
    autoSkipCooldownType: number;
    autoSkipC2: number;
    autoSkipMinuteSkips: Good[];
    autoSkipSeconds: number;
}

declare class BattleLogUnit<Unit> extends InventoryItem<Unit> {
    lost: number;

    constructor(item: Unit, count: number, lost: number);
}

declare class BattleLogArmyWave {
    public left: {
        soldiers: BattleLogUnit<Unit>[],
        tools: BattleLogUnit<Tool>[],
    }
    public middle: {
        soldiers: BattleLogUnit<Unit>[],
        tools: BattleLogUnit<Tool>[],
    }
    public right: {
        soldiers: BattleLogUnit<Unit>[],
        tools: BattleLogUnit<Tool>[],
    }
}

declare class BattleParticipant {
    public playerId: number;
    public ownerInfo: WorldMapOwnerInfo;
    public front: number;
    public startArmySize: number;
    public lostUnits: number;
    public lootGoods: Good[];
    public famePoints: number;
    public xp: number;
    public kingstowersEffect: number;
    public factionPoint: number;
    public attackBoost: number;
    public woundedUnits: number;
    public isEnvironment: boolean;
    public isShadowUnit: boolean;
}

//#endregion
//#region SpyMessage
declare class BasicSpyPlayerMessage extends BasicMessage {
    public spyLog: SpyLog;
    public isSuccessful: boolean;
}

declare class SpyPlayerSabotageSuccessfulMessage extends BasicSpyPlayerMessage {
    public areaId: number;
    public areaType: number;
    public areaName: string;
}

declare class SpyPlayerSabotageFailedMessage extends BasicSpyPlayerMessage {
    public ownerId: number;
    public areaType: number;
    public areaName: string;
    public kingdomId: number;
}

declare class SpyPlayerDefenceMessage extends BasicSpyPlayerMessage {
    public ownerId: number;
    public areaType: number;
    public areaName: string;
    public kingdomId: number;
}

declare class SpyPlayerEconomicMessage extends BasicSpyPlayerMessage {
    public ownerId: number;
    public areaType: number;
    public areaName: string;
    public kingdomId: number;
}

declare class SpyNPCMessage extends BasicMessage {
    public spyLog: SpyLog;
    public isSuccessful: boolean;
    public ownerId: number;
    public areaType: number;
    public areaName: string;
    public kingdomId: number;
}

interface SpyLog {
    messageId: number,
    castleId: number,
    castleAppearance: number,
    spyCount: number,
    guardCount: number,
    spyAccuracy: number,
    spyRisk: number,
    targetMapObject: Mapobject,
    originOwner: WorldMapOwnerInfo,
    targetOwner: WorldMapOwnerInfo,
    spyResources?: Good[],
    armyInfo?: {
        army: {
            left: InventoryItem<Unit>[],
            middle: InventoryItem<Unit>[],
            right: InventoryItem<Unit>[],
            keep: InventoryItem<Unit>[],
            unitsKeepInventory: InventoryItem<Unit>[],
            stronghold: InventoryItem<Unit>[]
        },
        spyTime: Date,
        defenderBaron: Lord,
        defenderGeneral?: General,
        defenderLegendSkills: []
    },
    shapeshifterId?: number,
}

//#endregion
//#region MarketCarriageMessage
declare class MarketCarriageArrivedMessage extends BasicMessage {
    areaName: string;
    tradeData: TradeData;
}

interface TradeData {
    messageId: number,
    sourceArea: WorldMapArea,
    targetArea: WorldMapArea,
    goods: Good[],
}

//#endregion

declare class BreweryMissingResourcesMessage extends BasicMessage {
    resourceName: string;
    areaId: number;
    kingdomId: number;
    areaName: string;
    areaType: number;
    breweryObjectId: number;
    breweryWodId: number;
}

declare class DoubleRubiesMessage extends BasicMessage {
}

declare class StarveInfoMessage extends BasicMessage {
    numberOfDesertedTroops: number;
    areaName: string;
    kingdomId: number;
    areaId: number;
    areaType: number;
    resourceName: string;
}

declare class ProductionDowntimeMessage extends BasicMessage {
    downtimeStatus: number;
    messageScope: number;
}

declare class PlayerGiftMessage extends BasicMessage {
    senderId: number;
    packageId: number;
    packageAmount: number;
}

declare class UserSurveyMessage extends BasicMessage {
    surveyId?: number;
}

declare class RebuyMessage extends BasicMessage {
    boosterId: number;
    description: string
}

declare class RuinInfoMessage extends BasicMessage {
    position: Coordinate;
    remainingRuinTime: Date;
}

declare class AllianceRequestMessage extends BasicMessage {
    allianceId: number;
    allianceName: string;
}

//#region AttackCancelledMessage
declare class BasicAttackCancelledMessage extends BasicMessage {
    kingdomId: number;
    targetPlayerId: number;
    areaName: string;
    position: Coordinate;
    areaType: number;
    reason: number;
}

declare class AttackCancelledAbortedMessage extends BasicAttackCancelledMessage {
}

declare class AttackCancelledAutoRetreatMessage extends BasicAttackCancelledMessage {
}

declare class AttackCancelledAutoRetreatEnemyMessage extends BasicAttackCancelledMessage {
}

declare class SpyCancelledAbortedMessage extends AttackCancelledAbortedMessage {
}

//#endregion
//#region PrivateOfferMessage
declare class BasicPrivateOfferMessage extends BasicMessage {
}

declare class PrivateOfferBestsellerShopMessage extends BasicPrivateOfferMessage {
    privateOfferId: number;
    privateOfferIteration: number;
}

declare class PrivateOfferDungeonChestMessage extends BasicPrivateOfferMessage {
    privateOfferId: number;
    privateOfferIteration: number;
}

declare class PrivateOfferTimeChallengeMessage extends BasicPrivateOfferMessage {
    privateOfferId: number;
    privateOfferIteration: number;
}

declare class PrivateOfferTippMessage extends BasicPrivateOfferMessage {
    helpMailImageId: number;
    helpMailTextId: number;
}

declare class PrivateOfferWhaleChestMessage extends BasicPrivateOfferMessage {
    privateOfferId: number;
    privateOfferIteration: number;
}

//#endregion
//#region SpecialEventMessage
declare class BasicSpecialEventMessage extends BasicMessage {
}

declare class SpecialEventStartMessage extends BasicSpecialEventMessage {
    eventId: number;
}

declare class SpecialEventUpdateMessage extends BasicSpecialEventMessage {
    eventId: number;
}

declare class SpecialEventEndMessage extends BasicSpecialEventMessage {
    eventId: number;
}

declare class SpecialEventMonumentResetMessage extends BasicSpecialEventMessage {
}

declare class SpecialEventVIPInfoMessage extends BasicSpecialEventMessage {
    vipLevel: number;
}

declare class SpecialEventHospitalCapacityExceededMessage extends BasicSpecialEventMessage {
    capacity: number
}

//#endregion
//#region AllianceWarMessage
declare class BasicAllianceWarMessage extends BasicMessage {
    enemyAllianceId: number;
    enemyAllianceName: string;
}

declare class AllianceWarEnemyAttackMessage extends BasicAllianceWarMessage {
    attackedPlayerId: number;
    attackedPlayerName: string;
}

declare class AllianceWarEnemyDeclarationMessage extends BasicAllianceWarMessage {
    ownAllianceId: number;
    ownAllianceName: string;
}

declare class AllianceWarEnemyEndMessage extends BasicAllianceWarMessage {
    ownAllianceId: number;
    ownAllianceName: string;
}

declare class AllianceWarEnemySabotageMessage extends BasicAllianceWarMessage {
    sabotagedPlayerId: number;
    sabotagedPlayerName: string;
}

declare class AllianceWarOwnAttackMessage extends BasicAllianceWarMessage {
    ownAllianceId: number;
    ownAllianceName: string;
}

declare class AllianceWarOwnDeclarationMessage extends BasicAllianceWarMessage {
    ownAllianceLeaderId: number;
    ownAllianceLeaderName: string;
}

declare class AllianceWarOwnSabotageMessage extends BasicAllianceWarMessage {
    ownAllianceId: number;
    ownAllianceName: string;
}

//#endregion
//#region ConquerableMessage
declare class BasicConquerableMessage extends BasicMessage {
    areaType: number;
    ownerId: number;
    areaName: string;
    attackerPlayerId: number;
    attackerName: string;
    kingdomId: number;
}

declare class ConquerableSiegeCancelledMessage extends BasicConquerableMessage {
}

declare class ConquerableNewSiegeMessage extends BasicConquerableMessage {
}

declare class ConquerableAreaConqueredMessage extends BasicConquerableMessage {
}

declare class ConquerableAreaLostMessage extends BasicConquerableMessage {
}

//#endregion
//#region PopupMessage
declare class BasicPopupMessage extends BasicMessage {
}

declare class PopupFacebookConnectionMessage extends BasicPopupMessage {
}

declare class PopupLoginBonusMessage extends BasicPopupMessage {
}

declare class PopupRegistrationGiftMessage extends BasicPopupMessage {
    isCollectable: boolean
    nextCollectableDayReward: number
}

//#endregion
//#endregion
//#region Events
/** */
interface ClientEvents {
    serverShutdown: [];
    serverShutdownEnd: [];
    connected: [];
    chatMessage: [message: ChatMessage];
    mailMessageAdd: [message: MailMessage];
    mailMessageRemove: [message: MailMessage];
    primeTime: [primeTime: PrimeTime];
    externalClientReady: [externalClient: Client];
}

interface MovementEvents {
    movementAdd: [movement: Movement];
    movementUpdate: [oldMovement: Movement, newMovement: Movement];
    movementCancelled: [movement: Movement];
}

interface ConstantsEvents {
    /** Equivalent of MOVEMENT_ADD */
    MOVEMENT_NEW: "movementAdd";
    MOVEMENT_ADD: "movementAdd";
    MOVEMENT_UPDATE: "movementUpdate";
    MOVEMENT_CANCEL: "movementCancelled";
    SERVER_SHUTDOWN: "serverShutdown";
    SERVER_SHUTDOWN_END: "serverShutdownEnd";
    CONNECTED: "connected";
    CHAT_MESSAGE: "chatMessage";
    MAIL_MESSAGE_NEW: "mailMessageAdd";
    MAIL_MESSAGE_ADD: "mailMessageAdd";
    MAIL_MESSAGE_REMOVE: "mailMessageRemove";
    PRIME_TIME: "primeTime";
    EXTERNAL_CLIENT_READY: "externalClientReady";
}

//#endregion
//#region Castle
/** */
declare class Castle {
    kingdomId: number;
    areaType: number;
    slumLevel: number;
    buildingInfo: CastleBuildingInfo;
    /** Only available at own castles */
    unitInventory: CastleUnitInventory;
    /** Only available at own castles */
    resourceStorage: CastleResourceStorage;
    /** Only available at own castles */
    productionData: CastleProductionData;
    /** Only available at own castles */
    buildingStorage: CastleBuildingStorage;
    /** Only available at own castles */
    builderDiscount: number;
    /** Only available at own castles */
    hunterInfo: { foodBoost: number, woodStoneReduction: number };
    mapobject: Mapobject;
}

declare class CastleBuildingInfo {
    public buildings: BasicBuilding[];
    public towers: BasicBuilding[];
    public gates: BasicBuilding[];
    public castleWall: BasicBuilding;
    public moat: BasicBuilding;
    public fixedPositionBuildings: BasicBuilding[];
    public mapobject: Mapobject;
    public buildingGround: BuildingGround[];
    public startPointX: number;
    public startPointY: