/// <reference types="node" />
import type { BankInfo, SlotType, IPosition, TradeSlotType, SlotInfo, StatusInfo, TokenType } from "./definitions/adventureland.js";
import type { BankPackName, CharacterType, CXData, DamageType, EmotionName, GData, ItemName, MapName, MonsterName, NPCName, SkillName } from "./definitions/adventureland-data.js";
import type { AchievementProgressData, CharacterData, ServerData, ChestOpenedData, ChestData, EntitiesData, EvalData, GameResponseData, NewMapData, PartyData, PQData, TrackerData, PlayersData, ItemData, ItemDataTrade, PlayerData, FriendData, GameResponseDataUpgradeChance, QInfo, ProjectileSkillGRDataObject, ChannelInfo, TradeHistoryData } from "./definitions/adventureland-server.js";
import type { Entity } from "./Entity.js";
import { Item } from "./Item.js";
import { Observer } from "./Observer.js";
import type { Player } from "./Player.js";
import type { GetEntitiesFilters, GetEntityFilters, GetPlayerFilters, GetPlayersFilters, LocateItemFilters, LocateItemsFilters, SmartMoveOptions } from "./definitions/alclient.js";
import { TradeItem } from "./TradeItem.js";
export declare class Character extends Observer implements CharacterData {
    userAuth: string;
    characterID: string;
    timeouts: Map<string, NodeJS.Timeout>;
    achievements: Map<string, AchievementProgressData>;
    get bank(): BankInfo;
    chests: Map<string, ChestData>;
    nextSkill: Map<SkillName, Date>;
    partyData: PartyData;
    ready: boolean;
    /** Because of game server limitations, if your character disconnects you need make a new Character object, you can't call `connect()` again. */
    noReconnect: boolean;
    afk: "code";
    age: number;
    apiercing: number;
    blast: number;
    controller: string;
    name: string;
    id: string;
    ctype: CharacterType;
    abs: boolean;
    angle: number;
    armor: number;
    attack: number;
    c: ChannelInfo;
    cid: number;
    cx: CXData;
    damage_type: DamageType;
    focus?: string;
    frequency: number;
    going_x: number;
    going_y: number;
    gold: number;
    heal: number;
    home: string;
    hp: number;
    level: number;
    m: number;
    mp_cost: number;
    max_hp: number;
    max_mp: number;
    move_num: number;
    moving: boolean;
    mp: number;
    npc?: NPCName;
    owner: string;
    party?: string;
    pdps: number;
    q: QInfo;
    range: number;
    resistance: number;
    rip: boolean;
    rpiercing: number;
    s: StatusInfo;
    skin: string;
    slots: SlotInfo;
    speed: number;
    stand?: boolean | "cstand" | "stand0";
    tp: boolean;
    emx: {
        [T in EmotionName]?: number;
    };
    explosion: number;
    incdmgamp: number;
    firesistance: number;
    fzresistance: number;
    mp_reduction: number;
    phresistance: number;
    pnresistance: number;
    stresistance: number;
    stun: number;
    int: number;
    str: number;
    dex: number;
    vit: number;
    for: number;
    max_xp: number;
    goldm: number;
    xpm: number;
    xp: number;
    luckm: number;
    isize: number;
    esize: number;
    cash: number;
    targets: number;
    target?: string;
    team?: string;
    evasion: number;
    miss: number;
    reflection: number;
    lifesteal: number;
    manasteal: number;
    crit: number;
    critdamage: number;
    dreturn: number;
    tax: number;
    xrange: number;
    items: (ItemData | null)[];
    cc: number;
    ipass?: string;
    friends?: string[];
    acx?: object;
    xcx?: string[];
    hitchhikers?: [string, GameResponseData | EvalData][];
    user: BankInfo;
    fear: number;
    courage: number;
    mcourage: number;
    pcourage: number;
    width: number;
    height: number;
    constructor(userID: string, userAuth: string, characterID: string, g: GData, serverData: ServerData);
    protected updateLoop(): Promise<void>;
    parseCharacter(data: CharacterData | PlayerData): void;
    protected parseEntities(data: EntitiesData): void;
    protected parseEval(data: EvalData): void;
    protected parseGameResponse(data: GameResponseData): void;
    protected parseNewMap(data: NewMapData): void;
    protected parseQData(data: PQData): void;
    protected setNextSkill(skill: SkillName, next: Date): void;
    protected updatePositions(): void;
    /**
     * TODO: Add fail check for logging in with too many characters to one server
     *
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    connect(): Promise<void>;
    /**
     * Disconnects your bot from the server, cancels all timeouts that have been registered, and turns off all socket listeners.
     */
    disconnect(): void;
    private getTime;
    /**
     * Logs a debug message to the console
     */
    debug(msg: string, military?: boolean): void;
    error(e: Error | string, trace?: boolean, military?: boolean): void;
    /**
     * This function will request all nearby entities and players from the server. You can use it to make sure we have the latest data.
     * NOTE: There is a rather high code call cost to this, don't call it too often.
     */
    requestEntitiesData(): Promise<EntitiesData>;
    /**
     * This function is a hack to get the server to respond with a player data update. It will respond with two...
     */
    requestPlayerData(): Promise<CharacterData>;
    /**
     * Accepts a friend request.
     *
     * @param {string} id
     * @return {*}  {Promise<FriendData>}
     * @memberof Character
     */
    acceptFriendRequest(id: string): Promise<FriendData>;
    /**
     * Accepts a magiport request from another character
     * @param name ID of the character that offered a magiport.
     */
    acceptMagiport(name: string): Promise<IPosition>;
    /**
     * Accepts another character's party invite.
     * @param id The ID of the character's party you want to accept the invite for.
     */
    acceptPartyInvite(id: string): Promise<PartyData>;
    acceptPartyRequest(id: string): Promise<PartyData>;
    /**
     * Performs a basic attack on the given target.
     *
     * NOTE: We can't name this function `attack` because of the property `attack` that tells us how much damage we do.
     * @param id The ID of the entity or player to attack
     */
    basicAttack(id: string): Promise<ProjectileSkillGRDataObject>;
    buy(itemName: ItemName, quantity?: number): Promise<number>;
    /**
     * Buy an item from an NPC (e.g. monsterhunter) with tokens
     * @param itemName The item you wish to purchase with tokens
     * @param useToken If set, we will only use this token to purchase the item, otherwise we will use any available token.
     */
    buyWithTokens(itemName: ItemName, useToken?: keyof GData["tokens"]): Promise<void>;
    buyFromMerchant(id: string, slot: TradeSlotType, rid: string, quantity?: number): Promise<ItemData>;
    /**
     * Buys an item from Ponty. Get items from `getPontyItems()`
     *
     * @param {ItemDataTrade} item
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    buyFromPonty(item: ItemDataTrade): Promise<void>;
    /**
     * Calculates the type of targets attacking you.
     *
     * The first element is the current number of targets of the given damage type.
     *
     * The second element is our character's courage
     *
     * @return {*}  {{
     *         magical: [number, number];
     *         physical: [number, number];
     *         pure: [number, number];
     *         }}
     * @memberof Character
     */
    calculateTargets(): {
        magical: number;
        physical: number;
        pure: number;
    };
    /**
     * Calculates the compound chance for the given item using the given scroll and offering.
     *
     * You need to be near the upgrade NPC, or have a computer, in order to calculate the compound chance.
     */
    calculateCompound(item1Pos: number, item2Pos: number, item3Pos: number, cscrollPos: number, offeringPos?: number): Promise<GameResponseDataUpgradeChance>;
    /**
     * Calculates the upgrade chance for the given item using the given scroll and offering.
     *
     * You need to be near the upgrade NPC, or have a computer, in order to calculate the upgrade chance.
     *
     * @param itemPos The position of the item to upgrade in your inventory
     * @param scrollPos The position of the scroll to use to upgrade the item in your inventory
     * @param offeringPos The position of the offering to use to upgrade the item in your inventory
     * @returns
     */
    calculateUpgrade(itemPos: number, scrollPos?: number, offeringPos?: number): Promise<GameResponseDataUpgradeChance>;
    calculateDamageRange(defender: Character | Entity | Player, skill?: SkillName): [number, number];
    /**
     * Returns the *minimum* gold required to obtain the given item.
     * @deprecated use `Item.calculateMinimumCost()`
     *
     * @param {ItemData} item - The item to calculate the minimum cost for
     * @return {*}  {number} - The cost of the item
     * @memberof Character
     */
    calculateItemCost(item: ItemData): number;
    /**
     * @deprecated use `Item.calculateGrade()`
     */
    calculateItemGrade(item: ItemData): number;
    canBuy(item: ItemName, options?: {
        ignoreLocation?: boolean;
        quantity?: number;
    }): boolean;
    canBuyWithTokens(item: ItemName, token: TokenType, options?: {
        ignoreLocation?: boolean;
        quantity?: number;
    }): boolean;
    /**
     * Returns true if you have the required items and gold to craft the item, you have
     * enough space in your inventory to craft the item, and you are near the NPC where you
     * can craft this item.
     *
     * @param {ItemName} itemToCraft
     * @return {*}  {boolean}
     * @memberof Character
     */
    canCraft(itemToCraft: ItemName, options?: {
        /** If true, we won't check if we're near the NPC that crafts this item */
        ignoreLocation?: boolean;
        /** If true, we will consider it craftable if we can buy the remaining items from an NPC */
        ignoreNpcItems?: boolean;
    }): boolean;
    /**
     * Returns true if you have the required gold to dismantle the item, and you
     * are near the craftsman NPC (or have a computer/supercomputer).
     *
     * NOTE: We currently lack the ability to calculate the cost of dismantling
     * compounded items; so although these items /can/ be dismantled, they will
     * return false until we get the necessary info.
     *
     * @param itemToDismantle ItemName id of item to be dismantled
     * @param options
     * @param options.ignoreInventory whether to ignore whether we have the item or not
     * @returns true or false
     */
    canDismantle(itemToDismantle: ItemName, options?: {
        ignoreInventory?: boolean;
        ignoreLocation?: boolean;
    }): boolean;
    /**
     * Returns true if you have enough of the exchangeable items, and you are
     * near the NPC where you can exchange this item.
     *
     * @param {ItemName} itemToExchange
     * @param {{
     *         ignoreLocation?: boolean
     *     }} [options]
     * @return {*}  {boolean}
     * @memberof Character
     */
    canExchange(itemToExchange: ItemName, options?: {
        ignoreLocation?: boolean;
    }): boolean;
    /**
     * Returns true if we can 100% kill the entity in one shot.
     *
     * @param {Entity} entity
     * @param {SkillName} [skill="attack"]
     * @return {*}  {boolean}
     * @memberof Character
     */
    canKillInOneShot(entity: Entity, skill?: SkillName): boolean;
    /**
     * Returns true if we can sell items from where we are standing
     *
     * @return {*}  {boolean}
     * @memberof Character
     */
    canSell(): boolean;
    /**
     * Returns true if you can compound the given combination of items from where you're standing
     *
     * @param {number} itemPos1
     * @param {number} itemPos2
     * @param {number} itemPos3
     * @param {number} scrollPos
     * @param {number} [offeringPos]
     * @return {*}  {boolean}
     * @memberof Character
     */
    canCompound(itemPos1: number, itemPos2: number, itemPos3: number, scrollPos?: number, offeringPos?: number): boolean;
    /**
     * Returns true if you can upgrade the given combination of items from where you're standing
     *
     * @param {number} itemPos
     * @param {number} scrollPos
     * @param {number} [offeringPos]
     * @return {*}  {boolean}
     * @memberof Character
     */
    canUpgrade(itemPos: number, scrollPos?: number, offeringPos?: number): boolean;
    /**
     * Returns true if we can use the skill.
     * This function checks various requirements, such as level, having a required item equipped, etc.
     * If you only want to check the cooldown, use isOnCooldown(skill) or getCooldown(skill).
     *
     * @param {SkillName} skill
     * @param {{
     *         ignoreCooldown?: boolean,
     *         ignoreEquipped?: boolean,
     *         ignoreLocation?: boolean,
     *         ignoreMP?: boolean,
     *     }} [options]
     * @return {*}  {boolean}
     * @memberof Character
     */
    canUse(skill: SkillName, options?: {
        ignoreCooldown?: boolean;
        ignoreEquipped?: boolean;
        ignoreLocation?: boolean;
        ignoreMP?: boolean;
    }): boolean;
    closeMerchantStand(): Promise<void>;
    /**
     * Combines 3 items to 1 at a higher level
     *
     * @param item1Pos
     * @param item2Pos
     * @param item3Pos
     * @param cscrollPos
     * @param offeringPos
     * @returns
     */
    compound(item1Pos: number, item2Pos: number, item3Pos: number, cscrollPos: number, offeringPos?: number): Promise<boolean>;
    /**
     * Crafts the given item name using items in the character's inventory.
     *
     * @param {ItemName} item
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    craft(item: ItemName): Promise<void>;
    depositGold(gold: number): Promise<void>;
    /**
     * Deposits an item in your bank.
     *
     * @param {number} inventoryPos
     * @param {BankPackName} [bankPack]
     * @param {*} [bankSlot=-1]
     * @return {*}  {unknown}
     * @memberof Character
     */
    depositItem(inventoryPos: number, bankPack?: BankPackName, bankSlot?: number): Promise<unknown>;
    /**
     * Destroys an item
     *
     * NOTE: Currently (as of 2024-02-15) gives a 1/1,000,000 chance to get a level 13 item
     *       if the item is upgradable
     *
     * @param num The inventory slot for the item we should destroy
     */
    destroy(num: number, quantity?: number): Promise<unknown>;
    dismantle(slot: number): Promise<void>;
    donateGold(amount: number): Promise<void>;
    /**
     * Perform an emotion
     *
     * @param {EmotionName} emotionName
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    emote(emotionName: EmotionName): Promise<void>;
    /**
     * Use this function to enter dungeons.
     *
     * See `transport` for traveling through normal doors.
     *
     * @param {MapName} map
     * @param {string} [instance] Instance ID string. If not set, a key will be consumed from your inventory to create a new one.
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    enter(map: MapName, instance?: string): Promise<void>;
    /**
     * Equip a single item.
     *
     * @see equip_batch Optimized for equipping multiple items (i.e. a loadout) at once
     *
     * @param inventoryPos
     * @param equipSlot
     * @returns
     */
    equip(inventoryPos: number, equipSlot?: SlotType): Promise<void>;
    /**
     * Equip a defined set of items
     *
     * @see equip Equipping a single item
     */
    equipBatch(toEquip: {
        num: number;
        slot: SlotType;
    }[]): Promise<unknown>;
    exchange(inventoryPos: number): Promise<string>;
    finishMonsterHuntQuest(): Promise<void>;
    /**
     * Returns a list of nearby entities, with optional filters
     *
     * @param {GetEntitiesFilters} [filters={}]
     * @return {*}  {Entity[]}
     * @memberof Character
     */
    getEntities(filters?: GetEntitiesFilters): Entity[];
    /**
     * Returns a nearby entity, with optional filters.
     * Note the filters with the returnX pattern, as they are specific to `getEntity()`.
     *
     * @param {GetEntityFilters} [filters={}]
     * @return {*}  {Entity}
     * @memberof Character
     */
    getEntity(filters?: GetEntityFilters): Entity;
    /**
     * Returns a list of empty inventory slot indexes
     *
     * @param items The inventory to look in
     */
    getEmptyInventorySlots(items?: ItemData[]): number[];
    /**
     * Returns the index of the first empty slot in the given inventory
     *
     * @param {*} [items=this.items] The inventory to look in
     * @return {*}  {number} The index of the first empty slot
     * @memberof Character
     */
    getFirstEmptyInventorySlot(items?: ItemData[]): number;
    /**
     * Get the holidayspirit buff. NOTE: You can only get this buff if the `holidayseason` event is active.
     *
     * NOTE: It might be the case that you can get a fun token when getting holidayspirit, but only if you currently
     * don't have holidayspirit (i.e. you don't top it up, and only get it again once it's completely run out).
     *
     * TODO: Add promises
     */
    getHolidaySpirit(): void;
    /**
     * Returns a nested map of items that the player has in their bank.
     */
    getBankItems(): Map<BankPackName, Map<number, Item>>;
    /**
     * Returns a map of items that the player has in their inventory.
     *
     * The key is the slot that the item is located, the value is an Item object with the
     * item data
     */
    getItems(): Map<number, Item>;
    /**
     * Returns the items that we are selling in our trade slots.
     *
     * @see getWantedItems for items the player is buying
     */
    getItemsForSale(): Map<TradeSlotType, TradeItem>;
    /**
     * Returns the items that we are purchasing in our trade slots
     *
     * @see getItemsForSale for items the player is selling
     */
    getWantedItems(): Map<TradeSlotType, TradeItem>;
    getLostAndFoundItems(): Promise<ItemDataTrade[]>;
    getMonsterHuntQuest(): Promise<void>;
    getPlayer(filters?: GetPlayerFilters): Player;
    getPlayers(filters?: GetPlayersFilters): Player[];
    /**
     * Returns a list of the players that are online on the server
     *
     * @return {*}  {Promise<PlayersData>}
     * @memberof Character
     */
    getServerPlayers(): Promise<PlayersData>;
    getPontyItems(): Promise<ItemDataTrade[]>;
    getServerReserveGold(): Promise<number>;
    /**
     * A helper function for creating promises for skills
     * @param skill The skill we're checking the success or failure for
     * @param options Overrides
     * @returns A promise that will resolve or reject according to the server response
     */
    protected getResponsePromise(skill: SkillName | "buy" | "destroy" | "equip_batch" | "imove" | "join" | "set_home", response?: string, options?: {
        extraGameResponseCheck?: (data: GameResponseData) => boolean;
        timeoutMs?: number;
    }): Promise<unknown>;
    /**
     * Retrieves the entity our character is currently targeting.
     *
     * @return {*}  {Entity}
     * @memberof Character
     */
    getTargetEntity(): Entity;
    /**
     * Retrieves tracker data
     *
     * @return {*}  {Promise<TrackerData>}
     * @memberof Character
     */
    getTrackerData(): Promise<TrackerData>;
    getTradeHistory(): Promise<TradeHistoryData>;
    /**
     * If we are disabled, we cannot move or attack
     * @returns If we are disabled
     */
    isDisabled(): boolean;
    /**
     * Returns true if our inventory is full, false otherwise
     *
     * @return {*}  {boolean}
     * @memberof Character
     */
    isFull(): boolean;
    /**
     * Returns true if our character is scared, false otherwise
     *
     * @return {*}  {boolean}
     * @memberof Character
     */
    isScared(): boolean;
    /**
     * Joins a daily event.
     *
     * @param eventName
     */
    join(eventName: MapName | MonsterName): Promise<unknown>;
    /**
     * Removes a party member
     *
     * @param {string} toKick
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    kickPartyMember(toKick: string): Promise<void>;
    /**
     * For use on 'cyberland' and 'jail' to leave the map. You will be transported to the spawn on "main".
     *
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    leaveMap(): Promise<void>;
    leaveParty(): Promise<void>;
    /**

     *
     * @param {number} x
     * @param {number} y
     * @param {{ disableSafetyCheck: boolean }} [options]
     *
     *
     * @return {*}  {Promise<IPosition>}
     * @memberof Character
     */
    /**
     * Moves the character to a given location. If the character can not move there safely,
     * i.e. there's a wall in the way, then we will move to the closest we can walk there in
     * a straight line.
     *
     * If you want this function to return after we complete the move, use `await`.
     *
     * If you start a new move before the last move is finished, the last move's promise will resolve.
     *
     * @param {number} x
     * @param {number} y
     * @param {{ disableSafetyCheck?: boolean, disableArrivalCheck?: boolean }} [options]
     *
     * disableSafetyCheck - If set to true, move() will not check map bounds
     *
     * resolveOnStart - If set to true, move() will resolve the promise when the move is confirmed, and not when it finishes
     *
     * @return {*}  {Promise<IPosition>}
     * @memberof Character
     */
    move(x: number, y: number, options?: {
        disableAlreadyThereCheck?: boolean;
        disableSafetyCheck?: boolean;
        disableErrorLogs?: boolean;
        resolveOnStart?: boolean;
    }): Promise<IPosition>;
    openChest(id: string): Promise<ChestOpenedData>;
    openMerchantStand(): Promise<void>;
    playSlots(bet?: number, num?: number, dir?: "up" | "down"): Promise<boolean>;
    regenHP(): Promise<void>;
    regenMP(): Promise<void>;
    /**
     * If you are dead, you can call this function to respawn.
     *
     * @param {boolean} [safe] If set, you will spawn in Wizard's cave instead of near the goos.
     * @return {*}  {Promise<IPosition>}
     * @memberof Character
     */
    respawn(safe?: boolean): Promise<IPosition>;
    scare(): Promise<string[]>;
    sell(itemPos: number, quantity?: number): Promise<boolean>;
    sellToMerchant(id: string, slot: TradeSlotType, rid: string, q: number): Promise<void>;
    sendCM(to: string[], message: unknown): Promise<void>;
    sendMail(to: string, subject: string, message: string, item?: boolean): Promise<void>;
    /**
     * Sends a PM to another character.
     * NOTE: This function's promise will only resolve after 5 seconds due to game limitations.
     *       Use caution when awaiting the promises!
     *
     * @param to The character ID to send a PM to
     * @param message The message
     * @returns true if we are pretty sure the PM was sent
     */
    sendPM(to: string, message: string): Promise<boolean>;
    /**
     * Sends a message to the server chat
     * @param message The message to send
     * @returns
     */
    say(message: string): Promise<void>;
    sendFriendRequest(id: string): Promise<void>;
    sendGold(to: string, amount: number): Promise<number>;
    sendItem(to: string, inventoryPos: number, quantity?: number): Promise<void>;
    /**
     * Invites the given character to our party.
     * @param id The character ID to invite to our party.
     */
    sendPartyInvite(id: string): Promise<void>;
    /**
     * Requests to join another character's party.
     * @param id The character ID to request a party invite from.
     */
    sendPartyRequest(id: string): Promise<void>;
    /**
     * Sets the home server to the current server you're on
     */
    setHome(): Promise<unknown>;
    /**
     * Shifts a booster to the given type
     *
     * @param {number} booster the inventory position of the booster
     * @param {("goldbooster" | "luckbooster" | "xpbooster")} to the type you want to shift it to
     * @memberof Character
     */
    shiftBooster(booster: number, to: "goldbooster" | "luckbooster" | "xpbooster"): Promise<void>;
    protected lastSmartMove: number;
    smartMoving: IPosition & {
        map: MapName;
    };
    /**
     * Used to move long distances strategically, i.e. avoiding walking through walls.
     * You can use this function to move between maps, too.
     *
     * @param {(IPosition | ItemName | MapName | MonsterName | NPCName)} to
     * @param {SmartMoveOptions} [options]
     * @return {*}  {Promise<IPosition>}
     * @memberof Character
     */
    smartMove(to: IPosition | ItemName | MapName | MonsterName | NPCName | BankPackName, options?: SmartMoveOptions): Promise<IPosition>;
    /**
     * Splits a stack of items in to two stacks
     *
     * @param pos The stack to split items from
     * @param q The number of items to split in to the new stack
     * @returns The slot number of the new stack
     */
    splitItem(pos: number, q: number): Promise<number>;
    /**
     * Starts "Konami" mode.
     *
     * In Konami mode, you can only attack the monster it specifies.
     *
     * You have a (very low) chance to get a special item in this mode.
     *
     * To exit Konami mode, you need to disconnect and reconnect
     *
     * @return {*}  {Promise<MonsterName>} The type of monster you need to target
     * @memberof Character
     */
    startKonami(): Promise<MonsterName>;
    stopSmartMove(): Promise<IPosition>;
    stopWarpToTown(): Promise<void>;
    /**
     * Swaps two items in your bank
     *
     * @param {number} itemPosA
     * @param {number} itemPosB
     * @param {BankPackName} pack
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    swapBankItems(itemPosA: number, itemPosB: number, pack: BankPackName): Promise<void>;
    /**
     * Swaps or two items in your inventory
     *
     * @param {number} itemPosA
     * @param {number} itemPosB
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    swapItems(itemPosA: number, itemPosB: number): Promise<unknown>;
    takeMailItem(mailID: string): Promise<void>;
    throwSnowball(target: string, snowball?: number): Promise<string>;
    /**
     * Use this function to travel through normal doors.
     *
     * See `enter` for entering dungeons.
     *
     * @param {MapName} map The map to move to
     * @param {number} spawn The spawn to move to for the given map
     * @return {*}  {Promise<void>}
     * @memberof Character
     */
    transport(map: MapName, spawn: number): Promise<void>;
    /**
     * Unequips the item in the given slot.
     * Also used to remove items from the merchant stand.
     *
     * @param {(SlotType | TradeSlotType)} slot
     * @return {*}  {Promise<number>} The position of the unequipped item in the inventory
     * @memberof Character
     */
    unequip(slot: SlotType | TradeSlotType): Promise<number>;
    /**
     * Unfriend another player.
     * NOTE: `data.name` may not equal `id`. The event uses the player's 1st character's name.
     *
     * @param {string} id
     * @return {*}  {Promise<FriendData>}
     * @memberof Character
     */
    unfriend(id: string): Promise<FriendData>;
    /**
     * Upgrades the given item using the given scroll and offering.
     *
     * You need to be near the upgrade NPC, or have a computer, in order to upgrade.
     *
     * @param itemPos The position of the item to upgrade in your inventory
     * @param scrollPos The position of the scroll to use to upgrade the item in your inventory
     * @param offeringPos The position of the offering to use to upgrade the item in your inventory
     * @returns
     */
    upgrade(itemPos: number, scrollPos: number, offeringPos?: number): Promise<boolean>;
    usePotion(itemPos: number): Promise<void>;
    warpToJail(): Promise<IPosition>;
    warpToTown(): Promise<IPosition>;
    withdrawGold(gold: number): Promise<void>;
    withdrawItem(bankPack: BankPackName, bankPos: number, inventoryPos?: number): Promise<unknown>;
    /**
     * Performs the zapperzap skill you can use if you have a zapper equipped.
     *
     * @param id The ID of the entity or player to attack
     */
    zapperZap(id: string): Promise<unknown>;
    /**
     * Returns true if the entity has a >0% chance to die from projectiles already cast.
     *
     * @return {*}  {boolean}
     * @memberof Entity
     */
    couldDieToProjectiles(): boolean;
    /**
     * Returns the number of items that match the given parameters
     * @param itemName The item to look for
     * @param inventory Where to look for the item
     * @param filters Filters to help search for specific properties on items
     */
    countItem(item: ItemName, inventory?: ItemData[], filters?: LocateItemsFilters): number;
    getCooldown(skill: SkillName): number;
    /**
     * Returns a boolean corresponding to whether or not we have a PvP marked item in our inventory
     * @param inv The inventory to look in
     */
    hasPvPMarkedItem(inv?: ItemData[]): boolean;
    /**
     * Check if we have the given item in the given inventory
     *
     * @param {ItemName | ItemName[]} iN The item(s) to look for. If given an array, it will check if we have *any* item in that list, not *all* items.
     * @param {*} [inv=this.items] Where to look for the item(s)
     * @param {LocateItemsFilters} [filters]
     * @return {*}  {boolean}
     * @memberof Character
     */
    hasItem(iN: ItemName | ItemName[], inv?: ItemData[], filters?: LocateItemsFilters): boolean;
    /**
     * Returns true if we are compounding something, false otherwise.
     *
     * NOTE: `Compounding`, `Upgrading`, and `Exchanging` are separate things and can be performed simultaneously.
     * @returns true if we are compounding something
     */
    isCompounding(): boolean;
    /**
     * Returns a boolean corresponding to whether or not we have a given item equipped.
     * @param iN The item(s) to look for. If given an array, this will check if *one* of the items is equipped, **not all**.
     * @param filters Extra parameters to make sure the item has
     */
    isEquipped(iN: ItemName | ItemName[], filters?: LocateItemsFilters): boolean;
    /**
     * Returns true if we are exchanging something, false otherwise.
     *
     * NOTE: `Exchanging`, `Upgrading`, and `Compounding` are separate things and can be performed simultaneously.
     * @returns true if we are exchanging something
     */
    isExchanging(): boolean;
    /**
     * Returns a boolean corresponding to whether or not we have the given item listed for purchase.
     * @param itemName The item to look for
     * @returns
     */
    isListedForPurchase(itemName: ItemName): boolean;
    /**
     * Returns a boolean corresponding to whether or not we have the given item listed for sale.
     * @param itemName The item to look for
     * @returns
     */
    isListedForSale(itemName: ItemName): boolean;
    /**
     * Returns true if our skill is on cooldown, false otherwise.
     * This function does not check if you can use the skill.
     * If you want to check if you have all the requirements to use it, see canUse(skill).
     *
     * @param {SkillName} skill
     * @return {*}  {boolean}
     * @memberof Character
     */
    isOnCooldown(skill: SkillName): boolean;
    /**
     * Returns true if we are upgrading something, false otherwise.
     *
     * NOTE: `Upgrading`, `Compounding`, and `Exchanging` are separate things and can be performed simultaneously.
     * @returns true if we are upgrading something
     */
    isUpgrading(): boolean;
    /**
     * Can we attack other players?
     *
     * @return {*}  {boolean}
     * @memberof Character
     */
    isPVP(): boolean;
    /**
     * Returns the index of the item in the given inventory
     * @param iN The item(s) to look for
     * @param inv Where to look for the item
     * @param filters Filters to help search for specific properties on items
     */
    locateItem(iN: ItemName | ItemName[], inv?: ItemData[], filters?: LocateItemFilters): number;
    /**
     * Returns a list of indexes of the items in the given inventory
     * @param iN The item(s) to look for. If given an array, this will check if *one* of the items is equipped, **not all**.
     * @param inv Where to look for the item
     * @param filters Filters to help search for specific properties on items
     */
    locateItems(iN: ItemName | ItemName[], inv?: ItemData[], filters?: LocateItemsFilters): number[];
    /**
     * Returns an object with keys for each item name.
     * Each item object has keys for each level.
     * Each level object is an array of item positions.
     *
     * Set `minAmount` to 2 to find duplicate items. Set `minAmount` to 3 to find triplicate items.
     *
     * @param {*} [inventory=this.items]
     * @param {{ minAmount?: number }} [options]
     * @return {*}  {{
     *         [name in ItemName]?: {
     *             [level in number]?: number[];
     *         }
     *     }}
     * @memberof Character
     */
    locateItemsByLevel(inventory?: ItemData[], options?: {
        excludeLockedItems?: boolean;
        excludeSpecialItems?: boolean;
        minAmount?: number;
    }): {
        [name in ItemName]?: {
            [level in number]?: number[];
        };
    };
}