libram 0.8.28 → 0.8.30

package/dist/diet/knapsack.js

@@ -0,0 +1,128 @@
+import { sum } from "../utils";
+class Not {
+    thing;
+    constructor(thing) {
+        this.thing = thing;
+    }
+}
+/**
+ * Assuming list is already sorted, count adjacent items.
+ * Effectively run-length encoding.
+ *
+ * @param list List to count
+ * @param isEqual Function that determines item equality
+ * @returns List of 2-tuples relating item to count
+ */
+function aggregate(list, isEqual) {
+    const aggregatedList = [];
+    for (const item of list) {
+        if (aggregatedList.length === 0) {
+            aggregatedList.push([item, 1]);
+        }
+        else {
+            const last = aggregatedList[aggregatedList.length - 1];
+            const [lastItem] = last;
+            if (isEqual ? isEqual(item, lastItem) : item === lastItem) {
+                last[1]++;
+            }
+            else {
+                aggregatedList.push([item, 1]);
+            }
+        }
+    }
+    return aggregatedList;
+}
+/**
+ * Solve the knapsack problem.
+ *
+ * @param values Array of {[item, value, weight, maximum]} tuples for knapsack parameter.
+ * @param capacity Capacity of knapsack.
+ * @returns Tuple {[totalValue, items]} of selected items and total value of those items.
+ */
+export function knapsack(values, capacity) {
+    if (!Number.isFinite(capacity)) {
+        throw new Error("Invalid capacity.");
+    }
+    // Invert negative values into a fake value for not using it.
+    const valuesInverted = values.map(([thing, value, weight, maximum]) => (weight < 0 && maximum !== undefined
+        ? [new Not(thing), -value, -weight, maximum]
+        : [thing, value, weight, maximum]));
+    const capacityAdjustment = sum(values, ([, , weight, maximum]) => weight < 0 && maximum !== undefined ? -weight * maximum : 0);
+    const adjustedCapacity = capacity + capacityAdjustment;
+    if (adjustedCapacity < 0) {
+        // We don't have enough cleaners to create any space, so can't fit anything.
+        return [-Infinity, []];
+    }
+    // Sort values by weight.
+    const valuesSorted = [...valuesInverted].sort((x, y) => x[2] - y[2]);
+    // Convert the problem into 0/1 knapsack - just include as many copies as possible of each item.
+    const values01 = [].concat(...valuesSorted.map(([thing, value, weight, maximum]) => {
+        if (!Number.isFinite(weight) || weight < 0) {
+            throw new Error(`Invalid weight ${weight} for ${thing instanceof Not ? `not ${thing.thing}` : thing}`);
+        }
+        const maxQuantity = Math.floor(maximum ?? adjustedCapacity / weight);
+        if (maxQuantity < 0) {
+            throw new Error(`Invalid max quantity ${maxQuantity} for ${thing instanceof Not ? `not ${thing.thing}` : thing}`);
+        }
+        return new Array(maxQuantity).fill([
+            thing,
+            value,
+            weight,
+        ]);
+    }));
+    const memoizationTable = new Array(values01.length);
+    for (let i = 0; i < values01.length; i++) {
+        memoizationTable[i] = new Array(adjustedCapacity).fill(null);
+    }
+    const [value, invertedSolution] = bestSolution(memoizationTable, values01, values01.length - 1, adjustedCapacity);
+    // Still need to replace Not<T>s with right quantity of T's.
+    const aggregatedSolution = aggregate(invertedSolution);
+    const countMap = new Map(aggregatedSolution);
+    let valueAdjustment = 0;
+    const solution = aggregatedSolution.filter(([thingOrNot]) => !(thingOrNot instanceof Not));
+    for (const [thingOrNot, value, , maximum] of valuesSorted) {
+        if (thingOrNot instanceof Not) {
+            const notCount = countMap.get(thingOrNot) ?? 0;
+            if (maximum === undefined) {
+                throw new Error(`Cannot find maximum for item ${thingOrNot.thing}.`);
+            }
+            if (notCount > maximum) {
+                throw new Error(`Somehow picked ${notCount} more than the maximum ${notCount} for item ${thingOrNot.thing}.`);
+            }
+            if (notCount < maximum) {
+                solution.push([thingOrNot.thing, maximum - notCount]);
+            }
+            valueAdjustment -= maximum * value;
+        }
+    }
+    return [value + valueAdjustment, solution];
+}
+/**
+ * Find the best solution to a knapsack subproblem.
+ *
+ * @param memoizationTable Memoization table for dynamic programming approach.
+ * @param values Array of {[item, value, weight, maximum]} tuples for knapsack parameter.
+ * @param currentIndex Current index into values array - only add items before this index.
+ * @param remainingCapacity Remaining capacity of knapsack.
+ * @returns Tuple of value to item
+ */
+function bestSolution(memoizationTable, values, currentIndex, remainingCapacity) {
+    // If we've used all our capacity, this solution is no good.
+    if (remainingCapacity < 0)
+        return [-Infinity, []];
+    if (remainingCapacity === 0 || currentIndex < 0)
+        return [0, []];
+    const memoized = memoizationTable[currentIndex][remainingCapacity - 1];
+    if (memoized !== null)
+        return memoized;
+    const [item, value, weight] = values[currentIndex];
+    const [valueIncludeRest, itemsInclude] = bestSolution(memoizationTable, values, currentIndex - 1, remainingCapacity - weight);
+    const valueInclude = valueIncludeRest + value;
+    const [valueExclude, itemsExclude] = bestSolution(memoizationTable, values, currentIndex - 1, remainingCapacity);
+    // Pick the better of the two options between including/excluding.
+    const result = valueInclude > valueExclude
+        ? [valueInclude, [...itemsInclude, item]]
+        : [valueExclude, itemsExclude];
+    memoizationTable[currentIndex][remainingCapacity - 1] = result;
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export * from "./actions";
+export * from "./ascend";
+export * from "./Clan";
+export * from "./challengePaths";
+export * from "./combat";
+export * as Counter from "./counter";
+export * from "./diet";
+export * from "./Dungeon";
+export * from "./lib";
+export * from "./maximize";
+export { numericModifiers, statModifiers, booleanModifiers, classModifiers, monsterModifiers, effectModifiers, skillModifiers, } from "./modifierTypes";
+export * from "./mood";
+export * from "./moonSign";
+export * from "./propertyTyping";
+export * from "./resources";
+export * from "./since";
+export * from "./template-string";
+export { default as Kmail } from "./Kmail";
+export { default as logger } from "./logger";
+export * as console from "./console";
+export * as property from "./property";
+export * as propertyTypes from "./propertyTypes";
+export * from "./utils";
+export { get, PropertiesManager, set, setProperties, withProperties, withProperty, withChoices, withChoice, } from "./property";
+export { get as getModifier, getTotalModifier } from "./modifier";
+export { Session } from "./session";
+export type { LogLevels } from "./logger";
+export type { Modifiers } from "./modifier";
+export type { NumericModifier, StringModifier, ClassModifier, StatModifier, BooleanModifier, EffectModifier, SkillModifier, } from "./modifierTypes";

package/dist/index.js

@@ -0,0 +1,26 @@
+export * from "./actions";
+export * from "./ascend";
+export * from "./Clan";
+export * from "./challengePaths";
+export * from "./combat";
+export * as Counter from "./counter";
+export * from "./diet";
+export * from "./Dungeon";
+export * from "./lib";
+export * from "./maximize";
+export { numericModifiers, statModifiers, booleanModifiers, classModifiers, monsterModifiers, effectModifiers, skillModifiers, } from "./modifierTypes";
+export * from "./mood";
+export * from "./moonSign";
+export * from "./propertyTyping";
+export * from "./resources";
+export * from "./since";
+export * from "./template-string";
+export { default as Kmail } from "./Kmail";
+export { default as logger } from "./logger";
+export * as console from "./console";
+export * as property from "./property";
+export * as propertyTypes from "./propertyTypes";
+export * from "./utils";
+export { get, PropertiesManager, set, setProperties, withProperties, withProperty, withChoices, withChoice, } from "./property";
+export { get as getModifier, getTotalModifier } from "./modifier";
+export { Session } from "./session";

package/dist/lib.d.ts

@@ -0,0 +1,508 @@
+/** @module GeneralLibrary */
+import { Effect, Element, Familiar, Item, Location, Monster, runCombat, Servant, Skill, Slot, Stat, Thrall } from "kolmafia";
+/**
+ * Determines the current maximum Accordion Thief songs the player can have in their head
+ *
+ * @category General
+ * @returns Maximum number of songs for player
+ */
+export declare function getSongLimit(): number;
+/**
+ * Determine whether the Skill or Effect provided is an Accordion Thief song
+ *
+ * @category General
+ * @param skillOrEffect The Skill or Effect
+ * @returns Whether it's a song
+ */
+export declare function isSong(skillOrEffect: Skill | Effect): boolean;
+/**
+ * List all active Effects
+ *
+ * @category General
+ * @returns List of Effects
+ */
+export declare function getActiveEffects(): Effect[];
+/**
+ * List currently active Accordion Thief songs
+ *
+ * @category General
+ * @returns List of song Effects
+ */
+export declare function getActiveSongs(): Effect[];
+/**
+ * List number of active Accordion Thief songs
+ *
+ * @category General
+ * @returns Number of songs
+ */
+export declare function getSongCount(): number;
+/**
+ * Determine whether player can remember another Accordion Thief song
+ *
+ * @category General
+ * @param quantity Number of songs to test the space for
+ * @returns Whether player can remember another song
+ */
+export declare function canRememberSong(quantity?: number): boolean;
+/**
+ * Determine the locations in which the given monster can be encountered naturally
+ *
+ * @category General
+ * @param monster Monster to find
+ * @returns Locations for monster
+ */
+export declare function getMonsterLocations(monster: Monster): Location[];
+/**
+ * Determine the player's remaining liver space
+ *
+ * @category General
+ * @returns Remaining liver space
+ */
+export declare function getRemainingLiver(): number;
+/**
+ * Determine the player's remaining stomach space
+ *
+ * @category General
+ * @returns Remaining stomach space
+ */
+export declare function getRemainingStomach(): number;
+/**
+ * Determine the player's remaining spleen space
+ *
+ * @category General
+ * @returns Remaining spleen space
+ */
+export declare function getRemainingSpleen(): number;
+/**
+ * Determine whether the player "has" any entity which one could feasibly "have".
+ *
+ * @category General
+ * @param thing Thing to check
+ * @param quantity Minimum quantity the player must have to pass
+ * @returns Whether the player meets the requirements of owning the supplied thing
+ */
+export declare function have(thing: Effect | Familiar | Item | Servant | Skill | Thrall, quantity?: number): boolean;
+/**
+ * Determine whether a given item is in the player's campground
+ *
+ * @category General
+ * @param item The Item KoLmafia uses to represent the campground item
+ * @returns Whether the item is in the campground
+ */
+export declare function haveInCampground(item: Item): boolean;
+export declare enum Wanderer {
+    Digitize = "Digitize Monster",
+    Enamorang = "Enamorang Monster",
+    Familiar = "Familiar",
+    Holiday = "Holiday Monster",
+    Kramco = "Kramco",
+    Nemesis = "Nemesis Assassin",
+    Portscan = "portscan.edu",
+    Romantic = "Romantic Monster",
+    Vote = "Vote Monster"
+}
+/**
+ * Determine whether the player has the specified counter
+ *
+ * @param counterName Name of the counter
+ * @param minTurns Minimum turns the counter is set to
+ * @param maxTurns Maximum turns the counter is set to
+ * @category General
+ * @returns Whether player has the counter
+ */
+export declare function haveCounter(counterName: string, minTurns?: number, maxTurns?: number): boolean;
+/**
+ * Determine whether the player has the specified wanderer's counter
+ *
+ * @param wanderer Wanderer to check
+ * @category Wanderers
+ * @returns Whether player has the wanderer counter
+ */
+export declare function haveWandererCounter(wanderer: Wanderer): boolean;
+/**
+ * Determine whether the player will encounter a vote wanderer on the next turn,
+ * providing an "I Voted!" sticker is equipped.
+ *
+ * @category Wanderers
+ * @returns Whether the vote wanderer is due
+ */
+export declare function isVoteWandererNow(): boolean;
+/**
+ * Tells us whether we can expect a given wanderer now. Behaves differently
+ * for different types of wanderer.
+ *
+ * - For deterministic wanderers, return whether the player will encounter
+ *   the queried wanderer on the next turn
+ *
+ * - For variable wanderers (window), return whether the player is within
+ *   an encounter window for the queried wanderer
+ *
+ * - For variable wanderers (chance per turn), returns true unless the player
+ *   has exhausted the number of wanderers possible
+ *
+ * @category Wanderers
+ * @param wanderer Wanderer to check
+ * @returns Whether the wanderer is due
+ */
+export declare function isWandererNow(wanderer: Wanderer): boolean;
+/**
+ * Determines the chance the player will encounter a sausage goblin on the
+ * next turn, providing the Kramco Sausage-o-Matic is equipped.
+ *
+ * @category Wanderers
+ * @returns Chance that the sausage goblin is due (as a number between 0 and 1)
+ */
+export declare function getKramcoWandererChance(): number;
+/**
+ * Determines the chance the player will encounter an Artistic Goth Kid or
+ * Mini-Hipster wanderer on the next turn, providing a familiar is equipped.
+ *
+ * NOTE: You must complete one combat with the Artistic Goth Kid before you
+ * can encounter any wanderers. Consequently,ƒ the first combat with the
+ * Artist Goth Kid is effectively 0% chance to encounter a wanderer.
+ *
+ * @category Wanderers
+ * @returns Chance that the familiar wanderer is due (as a number between 0 and 1)
+ */
+export declare function getFamiliarWandererChance(): number;
+/**
+ * Determines the chance the player will encounter the specified wanderer
+ * on the next turn.
+ *
+ * @category Wanderers
+ * @param wanderer Wanderer to check
+ * @returns Chance that the specified wanderer is due (as a number between 0 and 1)
+ */
+export declare function getWandererChance(wanderer: Wanderer): number;
+/**
+ * Determines whether the player's current familiar is equal to the one supplied
+ *
+ * @category General
+ * @param familiar Familiar to check
+ * @returns Whether it is the player's current familiar
+ */
+export declare function isCurrentFamiliar(familiar: Familiar): boolean;
+/**
+ * Determines the fold group (if any) of which the given item is a part
+ *
+ * @category General
+ * @param item Item that is part of the required fold group
+ * @returns List of items in the fold group
+ */
+export declare function getFoldGroup(item: Item): Item[];
+/**
+ * Determines the zap group (if any) of which the given item is a part
+ *
+ * @category General
+ * @param item Item that is part of the required zap group
+ * @returns List of items in the zap group
+ */
+export declare function getZapGroup(item: Item): Item[];
+/**
+ * Get a map of banished monsters keyed by what banished them
+ *
+ * @category General
+ * @returns Map of banished monsters
+ */
+export declare function getBanishedMonsters(): Map<Item | Skill, Monster>;
+/**
+ * Determines whether the item is usable
+ *
+ * This function will be an ongoing work in progress
+ *
+ * @param item Item to check
+ * @returns Whether item is usable
+ */
+export declare function canUse(item: Item): boolean;
+/**
+ * Turn KoLmafia `none`s to JavaScript `null`s
+ *
+ * @param thing Thing that can have a mafia "none" value
+ * @returns The thing specified or `null`
+ */
+export declare function noneToNull<T>(thing: T): T | null;
+/**
+ * Determine the average value from the sort of range that KoLmafia encodes as a string
+ *
+ * @param range KoLmafia-style range string
+ * @returns Average value fo range
+ */
+export declare function getAverage(range: string): number;
+/**
+ * Deternube tge average adventures expected from consuming an Item
+ *
+ * If item is not a consumable, will just return "0".
+ *
+ * @param item Consumable item
+ * @returns Average aventures from consumable
+ */
+export declare function getAverageAdventures(item: Item): number;
+/**
+ * Remove an effect
+ *
+ * @category General
+ * @param effect Effect to remove
+ * @returns Success
+ */
+export declare function uneffect(effect: Effect): boolean;
+/**
+ * Get the player id from a player name
+ * @param name the name of the player
+ * @param onMissing Pass "throw" or omit to throw an error if the player is not found
+ * @returns the player id, or throws if no such player exists
+ */
+export declare function getPlayerIdFromName(name: string, onMissing?: "throw"): number;
+/**
+ * Get the player id from a player name (if it exists)
+ * @param name the name of the player
+ * @param onMissing Pass "throw" to throw an error if the player is not found, or "return-null" to return null
+ * @returns the player id if the player exists, or handles according to onMissing
+ */
+export declare function getPlayerIdFromName(name: string, onMissing: "throw" | "return-null"): number | null;
+/**
+ * Get the player id from a player name
+ * @param id the id of the player
+ * @param onMissing Pass "throw" or omit to throw an error if the player is not found
+ * @returns the player id, or throws if no such player exists
+ */
+export declare function getPlayerNameFromId(id: number, onMissing?: "throw"): string;
+/**
+ * Get the player id from a player name (if it exists)
+ * @param id the id of the player
+ * @param onMissing Pass "throw" to throw an error if the player is not found, or "return-null" to return null * @returns the player id, or null if no such player exists
+ * @returns the player id if the player exists, or handles according to onMissing
+ */
+export declare function getPlayerNameFromId(id: number, onMissing: "throw" | "return-null"): string | null;
+export declare type Player = {
+    name: string;
+    id: number;
+};
+/**
+ * Get both the name and id of a player from either their name or id
+ *
+ * @param idOrName Id or name of player
+ * @param onMissing Pass "throw" or omit to throw an error if the player is not found
+ * @returns Object containing id and name of player
+ * @throws {Error} Throws an error if the player is not found
+ */
+export declare function getPlayerFromIdOrName(idOrName: number | string, onMissing?: "throw"): Player;
+/**
+ * Get both the name and id of a player from either their name or id
+ *
+ * @param idOrName Id or name of player
+ * @param onMissing Pass "return-null" to return null if the player is not found
+ * @returns Object containing id and name of player if it exists, or handles according to onMissing
+ */
+export declare function getPlayerFromIdOrName(idOrName: number | string, onMissing: "throw" | "return-null"): Player | null;
+/**
+ * Determine the step as a number for a given quest property.
+ *
+ * @param questName Name of quest property to check.
+ * @returns Quest step
+ */
+export declare function questStep(questName: string): number;
+export declare class EnsureError extends Error {
+    constructor(cause: Item | Familiar | Effect, reason?: string);
+}
+/**
+ * Tries to get an effect using the default method
+ *
+ * @param ef effect to try to get
+ * @param turns turns to aim for; default of 1
+ * @throws {EnsureError} Throws an error if the effect cannot be guaranteed
+ */
+export declare function ensureEffect(ef: Effect, turns?: number): void;
+/**
+ * Determiens the average value (based on mallprice and autosell) of a collection of items
+ *
+ * @param items items whose value you care about
+ * @returns Average value of items
+ */
+export declare function getSaleValue(...items: Item[]): number;
+export declare const Environment: {
+    readonly Outdoor: "outdoor";
+    readonly Indoor: "indoor";
+    readonly Underground: "underground";
+    readonly Underwater: "underwater";
+};
+export declare type EnvironmentType = typeof Environment[keyof typeof Environment];
+/**
+ * Determines the weight-coefficient of any leprechaunning that this familiar may find itself doing
+ * Assumes the familiar is nude and thus fails for hatrack & pantsrack
+ * For the Mutant Cactus Bud, returns the efficacy-multiplier instead
+ *
+ * @param familiar The familiar whose leprechaun multiplier you're interested in
+ * @returns Weight-coefficient
+ */
+export declare function findLeprechaunMultiplier(familiar: Familiar): number;
+/**
+ * Determines the weight-coefficient of any baby gravy fairying that this familiar may find itself doing
+ * Assumes the familiar is nude and thus fails for hatrack & pantsrack
+ * For the Mutant Fire Ant, returns the efficacy-multiplier instead
+ *
+ * @param familiar The familiar whose fairy multiplier you're interested in
+ * @returns Weight-coefficient
+ */
+export declare function findFairyMultiplier(familiar: Familiar): number;
+export declare const holidayWanderers: Map<string, Monster[]>;
+/**
+ * Get today's holiday wanderers
+ *
+ * @returns List of holiday wanderer Monsters
+ */
+export declare function getTodaysHolidayWanderers(): Monster[];
+/**
+ * Determines whether or not we can safely call visitUrl(), based on whether we're in a fight, multi-fight, choice, etc
+ *
+ * @returns Whether urls can be safely visited
+ */
+export declare function canVisitUrl(): boolean;
+/**
+ * Calculate damage taken from a specific element after factoring in resistance
+ *
+ * @param baseDamage Base damage
+ * @param element Element
+ * @returns damage after factoring in resistances
+ */
+export declare function damageTakenByElement(baseDamage: number, element: Element): number;
+/**
+ * Get information from telescope
+ *
+ * @returns An object with all information the telescope gives you about the sorceress's contests and maze
+ */
+export declare function telescope(): {
+    statContest?: Stat;
+    elementContest?: Element;
+    hedge1?: Element;
+    hedge2?: Element;
+    hedge3?: Element;
+};
+/**
+ * Visit the desc_x.php page for a given thing
+ *
+ * @param thing Thing to examine
+ * @returns Contents of desc_x.php page
+ */
+export declare function examine(thing: Item | Familiar | Effect | Skill): string;
+/**
+ * Picks an option based on your primestat
+ *
+ * @param options An object keyed by stat; it must either contain all stats, or have a `default` parameter.
+ * @returns The option corresponding to your primestat.
+ */
+export declare const byStat: <S>(options: import("./utils").Switch<import("kolmafia").StatType, S>) => S;
+/**
+ * Picks an option based on your player class
+ *
+ * @param options An object keyed by player class; it must either contain all classes, or have a `default` parameter.
+ * @returns The option corresponding to your player class.
+ */
+export declare const byClass: <S>(options: import("./utils").Switch<import("kolmafia").ClassType, S>) => S;
+/**
+ * Use an item with visitUrl instead of `use`; this is sometimes useful
+ *
+ * @param item The item you want to use
+ * @returns The html of the resulting page
+ */
+export declare function directlyUse(item: Item): string;
+/**
+ * Unequip all instances of a given equipped item
+ *
+ * @param item The item in question
+ * @returns Whether we succeeded completely--`false` if we unequip some but not all instances of the item.
+ */
+export declare function unequip(item: Item): boolean;
+/**
+ * Empty a given slot.
+ *
+ * @param slot The slot in question
+ * @returns Whether we successfully emptied the slot
+ */
+export declare function unequip(slot: Slot): boolean;
+/**
+ * @returns a Date object corresponding to the current in-game day, at midnight
+ */
+export declare function gameDay(): Date;
+/**
+ * @param [type="all"] the type of crafting to check for free crafts
+ * @returns the number of free crafts available of that type
+ */
+export declare function freeCrafts(type?: "food" | "smith" | "booze" | "all"): number;
+export declare const realmTypes: readonly ["spooky", "stench", "hot", "cold", "sleaze", "fantasy", "pirate"];
+export declare type RealmType = typeof realmTypes[number];
+/**
+ * @param identifier which realm to check for
+ * @returns if that realm is available
+ */
+export declare function realmAvailable(identifier: RealmType): boolean;
+/**
+ * Compute the currently available Lucky Gold Ring Currencies
+ * @param realm the realm type to consider
+ * @returns The currency for the given zone
+ */
+export declare function realmCurrency(realm: RealmType): Item | null;
+/**
+ * Compute which Lucky Gold Ring currencies are currently available
+ * @returns a list of currently available currencies
+ */
+export declare function lgrCurrencies(): Item[];
+declare const ACCOUNT_COMBAT_FLAGS: readonly ["aabosses", "wowbar", "bothcombatinterf", "compactmanuel", "eternalmrj", "disablelovebugs", "boringdarts"];
+/**
+ * Different flags you can set on your account for how to handle combat:
+ * aabosses refers to the flag that lets autoattack trigger against special monsters
+ * wowbar refers to the flag to use the Combat Action Bar
+ * bothcombatinterf refers to the flag to use both the CAB
+ * compactmanuel refers to the flag to display monster manuel data horizontally
+ * eternalmrg refers to the flag to enable endless factoid delight
+ * disablelovebugs disables love bugs
+ * boringdarts avoid rendering the dartboard in combat
+ */
+export declare type AccountCombatFlag = typeof ACCOUNT_COMBAT_FLAGS[number];
+/**
+ * Get the current value of all of your account's combat setting flags
+ * @param flags An array of the flags you want to get, defaults to all of them
+ * @returns An array of objects that contain the flags and their values as booleans
+ */
+export declare function getCombatFlags(flags?: AccountCombatFlag[]): {
+    flag: AccountCombatFlag;
+    value: boolean;
+}[];
+/**
+ * Sets the given combat setting flags on your account
+ *
+ * @param flags A spread array of objects that contain a flag and its desired value; these look like the return value of `getCombatFlags`
+ * @returns the result of the associated `visitUrl` call
+ */
+export declare function setCombatFlags(...flags: {
+    flag: AccountCombatFlag;
+    value: boolean;
+}[]): string;
+/**
+ * Perform a given action with certain combat setting flags set, returning them to their initial values if possible
+ *
+ * @param action The action you want to do with the given combat setting flags
+ * @param flags A spread array of objects that contain a combat setting flag and its desired value; these look like the return value of `getCombatFlags`
+ * @returns The result of the action
+ */
+export declare function withCombatFlags<T>(action: () => T, ...flags: {
+    flag: AccountCombatFlag;
+    value: boolean;
+}[]): T;
+/**
+ * Determines whether you currently have an effect intrinsically
+ * @param effect The effect in question
+ * @returns Whether you have that effect as an intrinsic. Alternately you could just have over 2147483647 turns of that effect, but that seems unlikely.
+ */
+export declare function haveIntrinsic(effect: Effect): boolean;
+/**
+ * Extracts a map of gained items from a string, for example from the result
+ * of a combat.
+ *
+ * NOTE: Make sure you trust the source of that text.
+ *
+ * @param text The text to extract items from
+ * @returns A map of items and their quantities
+ */
+export declare function extractItems(text: string): Map<Item, number>;
+export declare type CombatParams = Parameters<typeof runCombat>;
+export {};