import { Effect, Item, Location, Monster } from "kolmafia";
import { Delayed } from "libram";
export declare const draggableFights: readonly ["backup", "wanderer", "yellow ray", "freefight", "freerun"];
export type DraggableFight = (typeof draggableFights)[number];
export declare function isDraggableFight<T>(fight: T | string): fight is DraggableFight;
interface UnlockableZone {
    zone: string;
    available: () => boolean;
    unlocker: Item;
    noInv: boolean;
}
export type WandererFactoryOptions = {
    ascend: boolean;
    estimatedTurns: () => number;
    freeFightExtraValue: (loc: Location) => number;
    itemValue: (item: Item) => number;
    effectValue: (effect: Effect, duration: number) => number;
    plentifulMonsters: Monster[];
    prioritizeCappingGuzzlr: boolean;
    digitzesRemaining?: (turns: number) => number;
    valueOfAdventure?: number;
    takeTurnForProfit?: boolean;
};
export type WandererFactory = (type: DraggableFight, locationSkiplist: Location[], options: WandererFactoryOptions) => WandererTarget[];
export type WandererLocation = {
    location: Location;
    targets: WandererTarget[];
    value: number;
    peridotMonster: Monster;
};
export declare const UnlockableZones: UnlockableZone[];
export declare function underwater(location: Location): boolean;
export declare function canAdventureOrUnlock(loc: Location, includeUnlockable?: boolean): boolean;
export declare function unlock(loc: Location, value: number): boolean;
export declare function canWander(location: Location, type: DraggableFight): boolean;
export declare class WandererTarget {
    name: string;
    zoneValue: number;
    monsterValues: Map<Monster, number>;
    location: Location;
    prepareTurn: () => boolean;
    /**
     * Process for determining where to put a wanderer to extract additional value from it
     * @param name name of this wanderer - for documentation/logging purposes
     * @param location returns the location to adventure to target this; null only if something goes wrong
     * @param zoneValue value of an encounter existing within a zone, regardless of which monster you fight
     * @param monsterValues A map of monsters and their expected value from this wanderer for encountering it
     * @param prepareTurn attempt to set up, spending meat and or items as necessary
     */
    constructor(name: string, location: Location, zoneValue: number, monsterValues?: Map<Monster, number>, prepareTurn?: () => boolean);
}
export declare function defaultFactory(): WandererTarget[];
export declare function wandererTurnsAvailableToday(options: WandererFactoryOptions, location: Location, requiresMonsterKill: boolean): number;
export declare function bofaValue({ plentifulMonsters, itemValue, effectValue }: WandererFactoryOptions, monster: Monster): number;
export declare function getAvailableUltraRareZones(): Location[];
export declare function hasNameCollision(monster: Monster): boolean;
export declare const unperidotableZones: Location[];
/**
 * Retrieve an element from a map if it exists; setting a value for the given key if it doesn't.
 * @param map The map in question.
 * @param key The key to try to retrieve from the map.
 * @param defaultValue A delayed value to assign to the key in the map if there isn't already an existing object.
 * @returns The retrieved value, which, by the end of this function, will exist in the map.
 */
export declare function ensureMapElement<K, V>(map: Map<K, V>, key: K, defaultValue: Delayed<V>): V;
/**
 * Add the values of a numeric-valued map to another with the same key type, mutating the first map.
 * @param left The "left" addend map. This map will be mutated by this function.
 * @param right The "right" addend map, to be added to the left.
 */
export declare function addMaps<K>(left: Map<K, number>, right: Map<K, number>): void;
export declare function availableMonsters(location: Location): Monster[];
export declare const UNPERIDOTABLE_MONSTERS: Set<Monster>;
export {};