ggejs/typings/index.d.ts

A powerful Node.js module for interacting with the server of Goodgame Empire & Goodgame Empire: Four Kingdoms

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

export const Constants: IConstants;

/** Base class for a player account */
export class BaseClient extends EventEmitter {
    public socketManager: SocketManager;

    public alliances: AllianceManager;
    public clientUserData: ClientUserDataManager;
    public equipments: EquipmentManager;
    public movements: MovementManager;
    public players: PlayerManager;
    public worldMaps: WorldMapManager;

    public bannedUntil: Date = new Date(0);
    public uniqueAccountId: string;
    public logger: Logger;

    private _id: UUID;
    private _networkId: number;

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

    private _language: string;

    public set language(val: string);

    private _mailMessages: MailMessage[];

    public get mailMessages(): MailMessage[];

    public set reconnectTimeout(val: number);

    private get _socket(): WebSocket;

    public async sendChatMessage(message: string): Promise<void>;

    public async sendMailMessage(playerName: string, subject: string, message: string): Promise<void>;

    public async 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 _sendPingPong(): Promise<void>;

    private abstract _reconnect();
}

export class E4KClient extends BaseClient {
    private _externalClient: ExternalClient;

    /**
     * Login with your credentials
     * @param name Your player account name
     * @param password Your player account password
     */
    public connect(name: string, password: string): Promise<E4KClient>;

    public getExternalClient(serverType: IConstants.ServerType.TempServer | IConstants.ServerType.AllianceBattleGround): Promise<ExternalClient>;

    public requestLoginData(): Promise<{ M: string, P: string }>;

    public safeAccount(mail: string, password: string): Promise<{ M: string, P: string, PB: string }>;

    private _generateExternalServerLoginToken(serverType: IConstants.ServerType.TempServer | IConstants.ServerType.AllianceBattleGround): Promise<{
        token: string,
        ip: string,
        port: string,
        zone: string,
        zoneId: string,
        instanceId: string,
        isCrossPlay: boolean
    }>;

    private _login(name: string, password: string): Promise<void>;

    private _reconnect(): Promise<E4KClient>;

    private _verifyLoginData(name: string, password: string): Promise<{ M: string, P: string }>;
}

export class ExternalClient extends BaseClient {
    public connect(loginToken: string): Promise<ExternalClient>;

    private _loginWithToken(loginToken: string): Promise<void>;

    private _reconnect(): Promise<ExternalClient>;
}

export class EmpireClient extends BaseClient {
    private _externalClient: ExternalClient;

    /**
     * Login with your credentials
     * @param name Your player account name
     * @param password Your player account password
     */
    public connect(name: string, password: string): Promise<E4KClient>;

    public getExternalClient(serverType: IConstants.ServerType.TempServer | IConstants.ServerType.AllianceBattleGround): Promise<ExternalClient>;

    private _generateExternalServerLoginToken(serverType: IConstants.ServerType.TempServer | IConstants.ServerType.AllianceBattleGround): Promise<{
        token: string,
        ip: string,
        port: string,
        zone: string,
        zoneId: string,
        instanceId: string,
        isCrossPlay: boolean
    }>;

    private _login(name: string, password: string): Promise<void>;

    private _reconnect(): Promise<E4KClient>;
}

export private type CommandCallback<T> = {
    id: UUID,
    clientId: UUID,
    match: (params: Object) => boolean,
    resolve: (value: T) => void,
    reject: (errorCode?: number) => void
}

export class EmpireError extends Error {
    errorCode: number | string;
}

export class Logger {
    verbosity: number;

    e(...message: any[]): void;

    w(...message: any[]): void;

    i(...message: any[]): void;

    d(...message: any[]): void;

    t(...message: any[]): void;
}

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

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 Managers

export class SocketManager {
    reconnectTimeout: number = 300;
    serverType: number = 1;

    constructor(client: BaseClient, serverInstance: NetworkInstance);

    get connectionStatus(): number;
    private set connectionStatus(connectionStatus: number);

    async connect(): Promise<void>;

    async reconnect(): Promise<void>;

    async disconnect(): Promise<void>;

    sendCommand(commandId: string, paramObject: Object): boolean;

    setConnected(): void;

    private writeToSocket(msg: string): boolean;
}

export class BaseManager extends EventEmitter {
    protected _client: BaseClient;

    protected constructor(client: BaseClient);
}

export class AllianceManager extends BaseManager {
    private constructor(client: BaseClient);

    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>>
}

export class ClientUserDataManager {
    public boostData: PremiumBoostData;
    public questData: QuestData;

    private constructor(client: BaseClient);

    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[];

    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;

    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

    public get myAlliance(): MyAlliance

    private set myAlliance(val: MyAlliance)

    private set userLevel(val: number);

    private set userParagonLevel(val: number);

    private set userHonor(val: number);

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

    private set registrationTimestamp(val: number);

    private set vipTimeExpireTimestamp(val: number)

    public isLegendLevel(): boolean;

    public titlePoints(titleType: number): number

    public currentTitle(titleType: number): Title

    public highestTitlePoints(titleType: number): number

    private setGlobalCurrency(val: Good);

    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
}

export class EquipmentManager extends BaseManager {
    private constructor(client: BaseClient);

    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 getCommanders(): Lord[];

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

    public getBarons(): Lord[];

    public getGenerals(): General[];

    public getEquipmentInventory(): Promise<(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 _setCommandersAndBarons(barons: Lord[], commanders: Lord[]): void;

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

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

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

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

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

export class MovementManager extends BaseManager {
    private constructor(client: BaseClient);

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

    public 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 async createAttackMovement(castleFrom: InteractiveMapobject, castleTo: Mapobject | CastlePosition, army: Army, lord: Lord, horse?: Horse): Promise<ArmyAttackMovement>;

    public async createSpyMovement(castleFrom: InteractiveMapobject, castleTo: Mapobject | CastlePosition, spyCount: number, spyType: number, spyEffect: number, horse?: Horse): Promise<SpyMovement>;

    public async createMarketMovement(castleFrom: InteractiveMapobject, castleTo: Mapobject | CastlePosition, goods: Good[], horse?: Horse): Promise<MarketMovement>;

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

    private _remove(_movementId: number): void;
}

export class PlayerManager extends BaseManager {
    private constructor(client: BaseClient);

    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>
}

export 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;

export 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: BaseClient, data: object);
}

export 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: BaseClient, data);
}

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

    protected constructor(client: BaseClient, data);
}

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

    protected constructor(client: BaseClient, data);
}

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

    protected constructor(client: BaseClient, data);
}

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

    protected constructor(client: BaseClient, data);
}

export class SupportDefenceMovement extends ArmytravelMovement {
}

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

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

export class Army {
    waves: ArmyWave[];
    finalWave: InventoryItem<Unit>[];
    supportTools: Tool[];
}

export interface ArmyWave {
    left: {
        units: InventoryItem<Unit>[],
        tools: InventoryItem<Tool>[],
    };
    middle: {
        units: InventoryItem<Unit>[],
        tools: InventoryItem<Tool>[],
    };
    right: {
        units: InventoryItem<Unit>[],
        tools: InventoryItem<Tool>[],
    };
}

export 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(castleData: Castle, horseType: number);
}

//#endregion

//#region Alliance
/** */
export 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: BaseClient, data);

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

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

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

export 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: BaseClient, data: Object): void;
}

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

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

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

    private constructor(client: BaseClient, data);
}

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

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

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

//#endregion

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

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

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

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

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

    public get position(): Coordinate;
}

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

//#region Lord and Equipment
/** */
export 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;
}

export 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 } };
}

export 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;
}

export 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;
}

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

export 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

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

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

export 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>[];
    }[];
}

export 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: BaseClient, wodId: number);
}

export class Tool extends Unit {

}

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

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

    private _clear(): void;
}

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

export class WorldMapOwnerInfo {
    public playerId: number;
    public playerLevel: number;
    public paragonLevel: number;
    public noobEndTime: Date;
    public highestFamePoints: number;
    public fameTopX: number;
    public peaceEndTime: Date;
    public castlePosList: CastlePosition[];
    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 titleVO// TODO: :IsleTitleViewVO
    public staticAreaName: string;

    public get honor(): number;

    public get isRuin(): boolean;

    public get allianceId(): number;

    public get allianceRank(): number;

    public get might(): number;

    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 get isOwnOwnerInfo(): boolean;

    public get famePoints(): number;

    public get achievementPoints(): number;

    public get factionMainCampId(): number;

    public get prefixTitleId(): number;

    public get suffixTitleId(): number;

    public get isNoobProtected(): boolean;

    public get isPeaceProtected(): boolean;

    public get isFactionNoobProtected(): boolean;

    public get isFactionProtected(): boolean;

    public getMainCastlePositionFromPosListByKingdomId(kingdomId: number): Coordinate;

    public getCastlePosListItemByPos(pos: Coordinate): CastlePosition;

    public getMainCastlePositionFromPosListForCurrentKingdom(): Coordinate;

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

    public isSearchingAlliance(): boolean;

    public hasPremiumFlag(): boolean;

    public hasVIPFlag(): boolean;

    public isRankInfoVisible(): boolean;

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

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

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

    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
    | AllianceRaidPortalMapobject;

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

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

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

    protected parseAreaInfoBattleLog(data): this;
}

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

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

export class CastleMapobject extends InteractiveMapobject {
}

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

export class DaimyoCastleMapobject extends DaimyoMapobject {

}

export class DaimyoTownshipMapobject extends DaimyoMapobject {

}

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

export 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;
}

export class DynamicMapobject extends BasicMapobject {

}

export class EmptyMapobject extends BasicMapobject {

}

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

    get areaName(): string;
}

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

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

    get areaName(): string;
}

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

    get titleText(): number

    get levelText(): number

    get specialCampId(): number
}

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

    get areaName(): string;
}

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

    get areaName(): string;
}

export 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;
}

export 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;
}

export class KingstowerMapobject extends InteractiveMapobject {
}

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

export class MetropolMapobject extends CapitalMapobject {
}

export class NomadInvasionMapobject extends InvasionMapobject {
}

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

export class RedAlienInvasionMapobject extends AlienInvasionMapobject {
}

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

export class SamuraiInvasionMapobject extends InvasionMapobject {
}

export class ShadowAreaMapobject extends InteractiveMapobject {
}

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

export 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;
}

export 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;
}

export class AllianceRaidPortalMapobject extends InteractiveMapobject {
    public travelDistance: number;
}

//#endregion
//#region MailMessage
/** All types of MailMessages */
export 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
    | AttackAdvisorFailedMessage
    | AttackAdvisorSummaryMessage
    | AttackCountThresholdMessage
    | DivisionChangeMessage;

export 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: BaseClient, data: Array<any>);

    public async delete(): Promise<void>;
}

export class AllianceNewsMessage {
    public subject: string;
    private _body: string;

    public async getBody(): Promise<string>;
}

export class UserMessage {
    public subject: string;
    private _body: string;

    public async getBody(): Promise<string>;
}

//#region BattleLogMessage
export 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;
    private _battleLog: BattleLog | undefined;

    public async getBattleLog(): Promise<BattleLog>;
}

export class BattleLogConquerMessage extends BasicBattleLogMessage {
}

export class BattleLogNormalAttackMessage extends BasicBattleLogMessage {
}

export class BattleLogNPCAttackMessage extends BasicBattleLogMessage {
}

export 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;
}

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

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

export 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>[],
    }
}

export 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
export class BasicSpyPlayerMessage extends BasicMessage {
    public isSuccessful: boolean;
    private _spyLog: SpyLog | undefined;

    public async getSpyLog(): Promise<SpyLog>;
}

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

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

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

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

export class SpyNPCMessage extends BasicMessage {
    public isSuccessful: boolean;
    public ownerId: number;
    public areaType: number;
    public areaName: string;
    public kingdomId: number;
    private _spyLog: SpyLog | undefined;

    public async getSpyLog(): Promise<SpyLog>;
}

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>[],
            supportTools: InventoryItem<Unit>[],
            stronghold: InventoryItem<Unit>[]
        },
        spyTime: Date,
        defenderBaron: Lord,
        defenderGeneral?: General,
        defenderLegendSkills: []
    }
}

//#endregion
//#region MarketCarriageMessage
export class MarketCarriageArrivedMessage extends BasicMessage {
    public areaName: string;
    private _tradeData: TradeData | undefined;

    public async getTradeData(): Promise<TradeData>;
}

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

//#endregion

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

export class DoubleRubiesMessage extends BasicMessage {
}

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

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

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

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

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

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

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

export class AttackCountThresholdMessage extends BasicMessage {
}

export class DivisionChangeMessage extends BasicMessage {
    public eventId: number;
    public divisionChangeType: number;
    public isForAlliance: boolean;
    public startDivision: number;
    public endDivision: number;
    public rank: number;
    public points: number;
    public pointsToThreshold: number;

    public get typeAffix(): string;

    public async getDivisionChangeMessage(): Promise<this>;
}

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

export class AttackCancelledAbortedMessage extends BasicAttackCancelledMessage {
}

export class AttackCancelledAutoRetreatMessage extends BasicAttackCancelledMessage {
}

export class AttackCancelledAutoRetreatEnemyMessage extends BasicAttackCancelledMessage {
}

export class SpyCancelledAbortedMessage extends AttackCancelledAbortedMessage {
}

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

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

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

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

export class PrivateOfferTippMessage extends