osrs-tools 0.2.3 → 1.0.1

package/README.md

@@ -1,9 +1,9 @@
-# Old School RuneScape Quest Tool
+# Old School RuneScape Tools
 
 [![NPM Version][npm-image]][npm-url] [![Downloads][downloads-image]][downloads-url] [![GitHub Issues][issues-img]][new-issue]  
 [![types](https://img.shields.io/npm/types/osrs-tools.svg?style=flat-square)](https://github.com/jamescer/osrs-tools/blob/master/src/types.ts)
 
-The **Old School RuneScape Quest Tool** is a Node.js package designed to provide comprehensive data for all current Old School RuneScape (OSRS) quests, slayer tasks, and related game mechanics. This tool is ideal for developers looking to integrate OSRS data into their projects, whether for personal use, game guides, or community tools.
+The **Old School RuneScape Tools** repo is a Node.js package designed to provide comprehensive data for all current Old School RuneScape (OSRS) quests, slayer tasks, and related game mechanics. This tool is ideal for developers looking to integrate OSRS data into their projects, whether for personal use, game guides, or community tools.
 
 ## Features
 
@@ -13,93 +13,66 @@ The **Old School RuneScape Quest Tool** is a Node.js package designed to provide
 - Built-in support for tracking quest and slayer progress.
 - Easy-to-use API for developers of all skill levels.
 
-## Installation
+## Overview
 
-Install the package via npm:
+This package provides a comprehensive, programmatic interface to Old School RuneScape (OSRS) quest, slayer, and account data. It is designed for developers, tool creators, and enthusiasts who want to:
 
-```bash
-npm install osrs-tools --save
-```
+- Access and analyze detailed quest data, including requirements, rewards, and quest steps.
+- Retrieve and filter slayer master tasks, including requirements, locations, and weights.
+- Simulate or build tools for quest progression, slayer assignment, and account planning.
+- Integrate OSRS data into bots, web apps, Discord bots, or personal utilities.
+- Track quest and slayer progress, or build custom checklists and planners.
 
-## Usage
+## What You Can Do
 
-Here’s how to use the tool in your project:
+- **Quest Data**: Use the `QuestTool` class and related functions to get all quest data as objects or arrays. Filter quests by requirements, rewards, or completion status. Build quest guides, checklists, or progress trackers.
+- **Slayer Masters & Tasks**: Import any Slayer Master (e.g., `Turael`, `Duradel`, `Krystilia`) to access their full list of tasks, requirements, and locations. Randomly assign tasks, filter by requirements, or analyze task weights for planning.
+- **Account Modeling**: Use the `OsrsAccount` and `Skill` models to represent and manipulate player accounts, including skill levels and quest completions. Simulate account progression or validate requirements for quests and tasks.
+- **Slayer Rewards**: Access lists of unlockable Slayer rewards and buyable items, including costs and descriptions, for use in planning or calculators.
+- **Data Integration**: All data is available as TypeScript/JavaScript objects, making it easy to integrate into web apps, bots, or scripts. The structure is ideal for both backend and frontend use.
+- **Extendable**: The modular design allows you to add new quests, tasks, or masters, or to extend models for custom use cases.
 
-### Importing the Module
+## Example Use Cases
 
-```javascript
-import { QuestTool, questArray, questObject } from 'osrs-tools';
-```
+- **Quest Progress Tracker**: Build a web or mobile app that tracks quest completion, shows requirements, and suggests next quests based on your account.
+- **Slayer Task Generator**: Create a Discord bot or web tool that assigns random slayer tasks based on your current level and unlocked masters.
+- **Account Planner**: Simulate an account's progression, checking which quests or tasks are available at each stage.
+- **Data Analysis**: Analyze quest or slayer data for guides, statistics, or optimization (e.g., fastest quest cape route, most efficient slayer path).
 
-### Working with Quests
+## Data Structure Highlights
 
-```javascript
-// Instantiate the QuestTool class
-const tool = new QuestTool();
+- **Quests**: Each quest is represented as a class with requirements, rewards, and steps. Data is available in both object and array formats for flexibility.
+- **Slayer Masters**: Each master is a class instance with a list of `Task` objects, each containing requirements, weights, and locations.
+- **Tasks**: Tasks include all relevant requirements (combat, slayer, quest), possible monsters, and location data.
+- **Account Models**: The `OsrsAccount` and `Skill` classes allow you to represent and manipulate player data programmatically.
 
-// Get quest data as an array
-const questArrayData = questArray();
+## Installation
 
-// Get quest data as an object
-const questObjectData = questObject();
+Install the package via npm:
 
-// Output the quest data
-console.log(questArrayData);
-console.log(questObjectData);
+```bash
+npm install osrs-tools --save
 ```
 
-### Working with Slayer Masters and Tasks
-
-```javascript
-import { Turael, Duradel } from 'osrs-tools';
-
-// Access Turael's tasks
-console.log(Turael.getTasks());
+## Usage
 
-// Get a random task from Duradel
-const randomTask = Duradel.getRandomTask();
-console.log(randomTask);
-```
+Here’s how to use the tool in your project:
 
-### Slayer Rewards and Unlocks
+### Importing the Module
 
 ```javascript
-import { SlayerUnlocks, SlayerBuys } from 'osrs-tools';
-
-// List all available Slayer unlocks
-console.log(SlayerUnlocks);
-
-// List all items available for purchase with Slayer points
-console.log(SlayerBuys);
+import { QuestTool, questArray, questObject } from 'osrs-tools';
 ```
 
-## API Reference
-
-### Quest API
-
-| Method            | Description                                                             | Type              |
-| ----------------- | ----------------------------------------------------------------------- | ----------------- |
-| `new QuestTool()` | Constructor for the `QuestTool` class.                                  | Class Constructor |
-| `questObject()`   | Function that returns an object with quest data (keys are quest names). | Function          |
-| `questArray()`    | Function that returns an array of quests, ordered alphabetically.       | Function          |
+### Module Optional Dependencies
+If you want to use your account to test quest tool compatibilities or check what you can unlock for slayer, I am referencing the repository  [osrs-json-hiscores](https://www.npmjs.com/package/osrs-json-hiscores)
 
-### Slayer API
-
-| Class/Method         | Description                                                                 |
-| -------------------- | ------------------------------------------------------------------------- |
-| `SlayerMaster`       | Represents a Slayer Master, including tasks, location, and requirements. |
-| `getTasks()`         | Returns a list of tasks assigned by the Slayer Master.                   |
-| `getRandomTask()`    | Returns a random task based on task weights.                             |
-| `SlayerUnlocks`      | Predefined list of Slayer unlocks with costs and descriptions.           |
-| `SlayerBuys`         | Predefined list of items available for purchase with Slayer points.      |
-
-## To-Do
+```bash
+npm install osrs-json-hiscores --save
+```
 
-- Implement a recursive function for determining quest completion.
-- Develop a quest completion tracking array.
-- Refactor `questArray()` and `questObject()` to return objects instead of functions.
-- Continue work on the **Recipe for Disaster** quest.
-- Fix and validate all Slayer data.
+### Todo
+- Fix quest data and ensure all requirements exist
 
 ## Contributing
 

package/dist/Requirement.d.ts

@@ -1,5 +1,6 @@
 interface Requirement {
     description: string;
+    type: RequirementType;
 }
 declare class LevelRequirement implements Requirement {
     type: RequirementType;

package/dist/account/OsrsAccount.d.ts

@@ -1,31 +1,80 @@
-interface OsrsAccountObject {
+interface SkillDetail {
+    rank: number;
+    level: number;
+    xp: number;
+}
+interface Skill {
+    level: number;
+}
+interface Skills {
+    [skillName: string]: Skill;
+}
+interface SkillsDetail {
+    [skillName: string]: SkillDetail;
+}
+interface BossScore {
+    rank: number;
+    score: number;
+}
+interface Bosses {
+    [bossName: string]: BossScore;
+}
+interface ClueScore {
+    rank: number;
+    score: number;
+}
+interface Clues {
+    [clueType: string]: ClueScore;
+}
+interface BountyHunter {
+    hunterV2?: BossScore;
+    rogueV2?: BossScore;
+    hunter?: BossScore;
+    rogue?: BossScore;
+}
+interface OsrsAccountData {
     name: string;
-    main: {
-        combatLevel: number;
-        questPoints: number;
-        skills: {
-            [skillName: string]: {
-                level: number;
-            };
-        };
-    };
+    combatLevel: number;
+    questPoints: number;
+    skills: Skills;
+    skillsDetail?: SkillsDetail;
+    bosses?: Bosses;
+    clues?: Clues;
+    bountyHunter?: BountyHunter;
+    lastManStanding?: BossScore;
+    pvpArena?: BossScore;
+    soulWarsZeal?: BossScore;
+    riftsClosed?: BossScore;
+    colosseumGlory?: BossScore;
+    collectionsLogged?: BossScore;
+    leaguePoints?: BossScore;
+    deadmanPoints?: BossScore;
 }
 declare class OsrsAccount {
-    private osrsAccount;
-    constructor(accountObject: OsrsAccountObject | null);
-    getName(): string | undefined;
+    #private;
+    constructor(data: OsrsAccountData);
+    static fromJson(json: any): OsrsAccount;
+    get name(): string;
+    get combatLevel(): number;
+    get questPoints(): number;
+    get skills(): Skills;
+    get skillsDetail(): SkillsDetail | undefined;
+    get bosses(): Bosses | undefined;
+    get clues(): Clues | undefined;
+    get bountyHunter(): BountyHunter | undefined;
+    get lastManStanding(): BossScore | undefined;
+    get pvpArena(): BossScore | undefined;
+    get soulWarsZeal(): BossScore | undefined;
+    get riftsClosed(): BossScore | undefined;
+    get colosseumGlory(): BossScore | undefined;
+    get collectionsLogged(): BossScore | undefined;
+    get leaguePoints(): BossScore | undefined;
+    get deadmanPoints(): BossScore | undefined;
+    getSkill(skillName: string): Skill | undefined;
+    getSkillDetail(skillName: string): SkillDetail | undefined;
+    getBossScore(bossName: string): BossScore | undefined;
+    getClueScore(clueType: string): ClueScore | undefined;
     toString(): string;
-    getSkills(): {
-        [skillName: string]: {
-            level: number;
-        };
-    } | undefined;
-    getSkill(skillName: string): {
-        level: number;
-    } | undefined;
-    getQuestPoints(): number | undefined;
-    setQuestPoints(x: number): void;
-    getCombatLevel(): number | undefined;
-    setCombatLevel(): void;
-}
-export { OsrsAccount };
+    toJson(): OsrsAccountData;
+}
+export { OsrsAccount, OsrsAccountData, Skills, Skill, SkillsDetail, Bosses, BossScore, Clues, ClueScore, BountyHunter, };

package/dist/account/OsrsAccount.js

@@ -1,64 +1,188 @@
 "use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _OsrsAccount_name, _OsrsAccount_combatLevel, _OsrsAccount_questPoints, _OsrsAccount_skills, _OsrsAccount_skillsDetail, _OsrsAccount_bosses, _OsrsAccount_clues, _OsrsAccount_bountyHunter, _OsrsAccount_lastManStanding, _OsrsAccount_pvpArena, _OsrsAccount_soulWarsZeal, _OsrsAccount_riftsClosed, _OsrsAccount_colosseumGlory, _OsrsAccount_collectionsLogged, _OsrsAccount_leaguePoints, _OsrsAccount_deadmanPoints;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OsrsAccount = void 0;
 class OsrsAccount {
-    constructor(accountObject) {
-        this.osrsAccount = accountObject ? accountObject : null;
-        this.setQuestPoints(0);
-        this.setCombatLevel();
+    constructor(data) {
+        _OsrsAccount_name.set(this, void 0);
+        _OsrsAccount_combatLevel.set(this, void 0);
+        _OsrsAccount_questPoints.set(this, void 0);
+        _OsrsAccount_skills.set(this, void 0);
+        _OsrsAccount_skillsDetail.set(this, void 0);
+        _OsrsAccount_bosses.set(this, void 0);
+        _OsrsAccount_clues.set(this, void 0);
+        _OsrsAccount_bountyHunter.set(this, void 0);
+        _OsrsAccount_lastManStanding.set(this, void 0);
+        _OsrsAccount_pvpArena.set(this, void 0);
+        _OsrsAccount_soulWarsZeal.set(this, void 0);
+        _OsrsAccount_riftsClosed.set(this, void 0);
+        _OsrsAccount_colosseumGlory.set(this, void 0);
+        _OsrsAccount_collectionsLogged.set(this, void 0);
+        _OsrsAccount_leaguePoints.set(this, void 0);
+        _OsrsAccount_deadmanPoints.set(this, void 0);
+        __classPrivateFieldSet(this, _OsrsAccount_name, data.name, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_combatLevel, data.combatLevel, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_questPoints, data.questPoints, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_skills, data.skills, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_skillsDetail, data.skillsDetail, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_bosses, data.bosses, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_clues, data.clues, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_bountyHunter, data.bountyHunter, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_lastManStanding, data.lastManStanding, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_pvpArena, data.pvpArena, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_soulWarsZeal, data.soulWarsZeal, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_riftsClosed, data.riftsClosed, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_colosseumGlory, data.colosseumGlory, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_collectionsLogged, data.collectionsLogged, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_leaguePoints, data.leaguePoints, "f");
+        __classPrivateFieldSet(this, _OsrsAccount_deadmanPoints, data.deadmanPoints, "f");
     }
-    getName() {
-        var _a;
-        return (_a = this.osrsAccount) === null || _a === void 0 ? void 0 : _a.name;
+    static fromJson(json) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const name = json.name || '';
+        const combatLevel = (_c = (_b = (_a = json.main) === null || _a === void 0 ? void 0 : _a.combatLevel) !== null && _b !== void 0 ? _b : json.combatLevel) !== null && _c !== void 0 ? _c : 3;
+        const questPoints = (_f = (_e = (_d = json.main) === null || _d === void 0 ? void 0 : _d.questPoints) !== null && _e !== void 0 ? _e : json.questPoints) !== null && _f !== void 0 ? _f : 0;
+        // Accept both lower and upper case skill keys
+        const skills = {};
+        const skillsDetail = {};
+        const srcSkills = ((_g = json.main) === null || _g === void 0 ? void 0 : _g.skills) || json.skills || {};
+        for (const key of Object.keys(srcSkills)) {
+            skills[key.toLowerCase()] = { level: srcSkills[key].level };
+            skillsDetail[key.toLowerCase()] = {
+                rank: srcSkills[key].rank,
+                level: srcSkills[key].level,
+                xp: srcSkills[key].xp,
+            };
+        }
+        const bosses = json.bosses
+            ? Object.assign({}, json.bosses) : undefined;
+        const clues = json.clues ? Object.assign({}, json.clues) : undefined;
+        const bountyHunter = json.bountyHunter
+            ? Object.assign({}, json.bountyHunter) : undefined;
+        const lastManStanding = json.lastManStanding;
+        const pvpArena = json.pvpArena;
+        const soulWarsZeal = json.soulWarsZeal;
+        const riftsClosed = json.riftsClosed;
+        const colosseumGlory = json.colosseumGlory;
+        const collectionsLogged = json.collectionsLogged;
+        const leaguePoints = json.leaguePoints;
+        const deadmanPoints = json.deadmanPoints;
+        return new OsrsAccount({
+            name,
+            combatLevel,
+            questPoints,
+            skills,
+            skillsDetail,
+            bosses,
+            clues,
+            bountyHunter,
+            lastManStanding,
+            pvpArena,
+            soulWarsZeal,
+            riftsClosed,
+            colosseumGlory,
+            collectionsLogged,
+            leaguePoints,
+            deadmanPoints,
+        });
     }
-    toString() {
-        var _a, _b, _c, _d;
-        return (((_b = (_a = this.osrsAccount) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "") +
-            ":  \nCombat Level: " +
-            ((_d = (_c = this.osrsAccount) === null || _c === void 0 ? void 0 : _c.main.combatLevel) !== null && _d !== void 0 ? _d : "") +
-            "\nQuestPoints: " +
-            this.getQuestPoints());
-    }
-    getSkills() {
-        var _a;
-        return (_a = this.osrsAccount) === null || _a === void 0 ? void 0 : _a.main.skills;
+    get name() {
+        return __classPrivateFieldGet(this, _OsrsAccount_name, "f");
+    }
+    get combatLevel() {
+        return __classPrivateFieldGet(this, _OsrsAccount_combatLevel, "f");
+    }
+    get questPoints() {
+        return __classPrivateFieldGet(this, _OsrsAccount_questPoints, "f");
+    }
+    get skills() {
+        return __classPrivateFieldGet(this, _OsrsAccount_skills, "f");
+    }
+    get skillsDetail() {
+        return __classPrivateFieldGet(this, _OsrsAccount_skillsDetail, "f");
+    }
+    get bosses() {
+        return __classPrivateFieldGet(this, _OsrsAccount_bosses, "f");
+    }
+    get clues() {
+        return __classPrivateFieldGet(this, _OsrsAccount_clues, "f");
+    }
+    get bountyHunter() {
+        return __classPrivateFieldGet(this, _OsrsAccount_bountyHunter, "f");
+    }
+    get lastManStanding() {
+        return __classPrivateFieldGet(this, _OsrsAccount_lastManStanding, "f");
+    }
+    get pvpArena() {
+        return __classPrivateFieldGet(this, _OsrsAccount_pvpArena, "f");
+    }
+    get soulWarsZeal() {
+        return __classPrivateFieldGet(this, _OsrsAccount_soulWarsZeal, "f");
+    }
+    get riftsClosed() {
+        return __classPrivateFieldGet(this, _OsrsAccount_riftsClosed, "f");
+    }
+    get colosseumGlory() {
+        return __classPrivateFieldGet(this, _OsrsAccount_colosseumGlory, "f");
+    }
+    get collectionsLogged() {
+        return __classPrivateFieldGet(this, _OsrsAccount_collectionsLogged, "f");
+    }
+    get leaguePoints() {
+        return __classPrivateFieldGet(this, _OsrsAccount_leaguePoints, "f");
+    }
+    get deadmanPoints() {
+        return __classPrivateFieldGet(this, _OsrsAccount_deadmanPoints, "f");
     }
     getSkill(skillName) {
-        var _a;
-        return (_a = this.osrsAccount) === null || _a === void 0 ? void 0 : _a.main.skills[skillName.toLowerCase()];
+        return __classPrivateFieldGet(this, _OsrsAccount_skills, "f")[skillName.toLowerCase()];
     }
-    getQuestPoints() {
+    getSkillDetail(skillName) {
         var _a;
-        return (_a = this.osrsAccount) === null || _a === void 0 ? void 0 : _a.main.questPoints;
+        return (_a = __classPrivateFieldGet(this, _OsrsAccount_skillsDetail, "f")) === null || _a === void 0 ? void 0 : _a[skillName.toLowerCase()];
     }
-    setQuestPoints(x) {
-        if (x >= 0 && this.osrsAccount) {
-            this.osrsAccount.main.questPoints = x;
-        }
+    getBossScore(bossName) {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _OsrsAccount_bosses, "f")) === null || _a === void 0 ? void 0 : _a[bossName];
     }
-    getCombatLevel() {
+    getClueScore(clueType) {
         var _a;
-        return (_a = this.osrsAccount) === null || _a === void 0 ? void 0 : _a.main.combatLevel;
-    }
-    setCombatLevel() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
-        if (this.osrsAccount) {
-            const attklvl = (_b = (_a = this.osrsAccount.main.skills.attack) === null || _a === void 0 ? void 0 : _a.level) !== null && _b !== void 0 ? _b : 1;
-            const strlvl = (_d = (_c = this.osrsAccount.main.skills.strength) === null || _c === void 0 ? void 0 : _c.level) !== null && _d !== void 0 ? _d : 1;
-            const deflvl = (_f = (_e = this.osrsAccount.main.skills.defence) === null || _e === void 0 ? void 0 : _e.level) !== null && _f !== void 0 ? _f : 1;
-            const rangedlvl = (_h = (_g = this.osrsAccount.main.skills.ranged) === null || _g === void 0 ? void 0 : _g.level) !== null && _h !== void 0 ? _h : 1;
-            const magiclvl = (_k = (_j = this.osrsAccount.main.skills.magic) === null || _j === void 0 ? void 0 : _j.level) !== null && _k !== void 0 ? _k : 1;
-            const praylvl = (_m = (_l = this.osrsAccount.main.skills.prayer) === null || _l === void 0 ? void 0 : _l.level) !== null && _m !== void 0 ? _m : 1;
-            const hplvl = (_p = (_o = this.osrsAccount.main.skills.hitpoints) === null || _o === void 0 ? void 0 : _o.level) !== null && _p !== void 0 ? _p : 10;
-            const x = [
-                0.325 * (attklvl + strlvl),
-                0.325 * ((3 * rangedlvl) / 2),
-                0.325 * ((3 * magiclvl) / 2),
-            ];
-            const cbMax = Math.max(...x);
-            this.osrsAccount.main.combatLevel =
-                0.25 * (deflvl + hplvl + praylvl / 2) + cbMax;
-        }
+        return (_a = __classPrivateFieldGet(this, _OsrsAccount_clues, "f")) === null || _a === void 0 ? void 0 : _a[clueType];
+    }
+    toString() {
+        return `${__classPrivateFieldGet(this, _OsrsAccount_name, "f")}:\nCombat Level: ${__classPrivateFieldGet(this, _OsrsAccount_combatLevel, "f")}\nQuestPoints: ${__classPrivateFieldGet(this, _OsrsAccount_questPoints, "f")}`;
+    }
+    toJson() {
+        return {
+            name: __classPrivateFieldGet(this, _OsrsAccount_name, "f"),
+            combatLevel: __classPrivateFieldGet(this, _OsrsAccount_combatLevel, "f"),
+            questPoints: __classPrivateFieldGet(this, _OsrsAccount_questPoints, "f"),
+            skills: __classPrivateFieldGet(this, _OsrsAccount_skills, "f"),
+            skillsDetail: __classPrivateFieldGet(this, _OsrsAccount_skillsDetail, "f"),
+            bosses: __classPrivateFieldGet(this, _OsrsAccount_bosses, "f"),
+            clues: __classPrivateFieldGet(this, _OsrsAccount_clues, "f"),
+            bountyHunter: __classPrivateFieldGet(this, _OsrsAccount_bountyHunter, "f"),
+            lastManStanding: __classPrivateFieldGet(this, _OsrsAccount_lastManStanding, "f"),
+            pvpArena: __classPrivateFieldGet(this, _OsrsAccount_pvpArena, "f"),
+            soulWarsZeal: __classPrivateFieldGet(this, _OsrsAccount_soulWarsZeal, "f"),
+            riftsClosed: __classPrivateFieldGet(this, _OsrsAccount_riftsClosed, "f"),
+            colosseumGlory: __classPrivateFieldGet(this, _OsrsAccount_colosseumGlory, "f"),
+            collectionsLogged: __classPrivateFieldGet(this, _OsrsAccount_collectionsLogged, "f"),
+            leaguePoints: __classPrivateFieldGet(this, _OsrsAccount_leaguePoints, "f"),
+            deadmanPoints: __classPrivateFieldGet(this, _OsrsAccount_deadmanPoints, "f"),
+        };
     }
 }
 exports.OsrsAccount = OsrsAccount;
+_OsrsAccount_name = new WeakMap(), _OsrsAccount_combatLevel = new WeakMap(), _OsrsAccount_questPoints = new WeakMap(), _OsrsAccount_skills = new WeakMap(), _OsrsAccount_skillsDetail = new WeakMap(), _OsrsAccount_bosses = new WeakMap(), _OsrsAccount_clues = new WeakMap(), _OsrsAccount_bountyHunter = new WeakMap(), _OsrsAccount_lastManStanding = new WeakMap(), _OsrsAccount_pvpArena = new WeakMap(), _OsrsAccount_soulWarsZeal = new WeakMap(), _OsrsAccount_riftsClosed = new WeakMap(), _OsrsAccount_colosseumGlory = new WeakMap(), _OsrsAccount_collectionsLogged = new WeakMap(), _OsrsAccount_leaguePoints = new WeakMap(), _OsrsAccount_deadmanPoints = new WeakMap();

package/dist/quest/Quest.d.ts

@@ -1,4 +1,40 @@
 import { Requirement } from '../Requirement';
+interface QuestRewardExperience {
+    skill: string;
+    amount: number;
+}
+interface QuestRewardItem {
+    name: string;
+    quantity?: number;
+    note?: string;
+}
+interface QuestRewardUnlock {
+    description: string;
+    url?: string;
+}
+interface QuestRewardLamp {
+    amount: number;
+    skillRestriction?: string | string[];
+    note?: string;
+}
+interface QuestRewardPoints {
+    type: string;
+    amount: number;
+}
+interface QuestRewardPet {
+    name: string;
+    note?: string;
+}
+interface QuestRewards {
+    experience?: QuestRewardExperience[];
+    items?: QuestRewardItem[];
+    unlocks?: QuestRewardUnlock[];
+    lamps?: QuestRewardLamp[];
+    points?: QuestRewardPoints[];
+    pets?: QuestRewardPet[];
+    questPoints: number;
+    areas?: string[];
+}
 interface Quest {
     id: number;
     name: string;
@@ -25,15 +61,7 @@ interface Quest {
         [skill: string]: number;
     };
     recommendedPrayers: string[];
-    rewards: {
-        experience?: {
-            [skill: string]: number;
-        };
-        items?: string[];
-        questPoints: number;
-        areas?: string[];
-        grants?: string[];
-    };
+    rewards: QuestRewards;
     [key: string]: any;
 }
 export { Quest };

package/dist/quest/QuestTool.d.ts

@@ -1,51 +1,36 @@
 import { OsrsAccount } from '../account/OsrsAccount';
 import { Quest } from './Quest';
 declare class QuestTool {
-    private questObject;
-    private questArray;
-    private subQuestArray;
     private osrsAccount;
-    constructor();
-    /**
-     * to string func
-     * @todo    Implement this function
-     * @return  {String} The string representation of the class object.
-     */
-    toString(): string;
-    /**
-     * Get the data for a quest
-     * @param  {String} questName The name of the quest
-     * @return {Object} The data for the input quest in a JSON object.
-     * */
-    getQuest(questName: string): Quest | undefined;
-    /**
-     * Get the data for a quest
-     * @param  {String} questName The name of the quest
-     * @return {Object} The data for the input quest in a JSON object.
-     * */
-    getQuestByName(questName: string): Quest | undefined;
-    /**
-     * Get the data for a quest
-     * @param  {String} subQuestName The name of the subquest
-     * @return {Object} The data for the input subquest in a JSON object.
-     * */
-    getSubQuest(subQuestName: string): any | undefined;
-    /**
-     * Add two numbers together
-     * @todo Need to implement Recipe for disaster functionality
-     * @param  {String} quest The either string or quest object of the quest to be determined completeable or not.
-     * @return {Boolean}  If the account currently tied to the tool can complete the quest.
-     * */
-    canCompleteQuest(quest: string | Quest | undefined): boolean;
+    constructor(account?: OsrsAccount);
     /**
      * Set the account to be used in this quest tool
      * @param  {OsrsAccount} acc1 The osrs Account to be associated with this class object.
-     * */
+     */
     setOsrsAccount(acc1: OsrsAccount): boolean;
     /**
      * Get the osrs account associated with this quest tool
      * @return  {OsrsAccount | undefined} The osrs Account associated with this class object.
-     * */
+     */
     getOsrsAccount(): OsrsAccount | undefined;
+    /**
+     * Determine if the account can complete a quest, including recursively checking quest requirements.
+     * @param quest The quest to check (must be a Quest instance)
+     * @param visited (internal) Set of quest names already checked to prevent infinite recursion
+     */
+    canCompleteQuest(quest: Quest | undefined, visited?: Set<string>): boolean;
+    /**
+     * Static utility to get a Quest instance by its name.
+     * This assumes all quests are exported as default from their respective files in quest/all/.
+     * @param questName The name of the quest to retrieve
+     * @returns Quest instance or undefined if not found
+     */
+    static getQuestByName(questName: string): Quest | undefined;
+    /**
+     * Get the maximum boost for a given skill, based on OSRS Wiki data.
+     * @param skillName The name of the skill (case-insensitive, e.g. 'Attack', 'Herblore')
+     * @returns The maximum boost amount for the skill (positive integer, or 0 if unboostable)
+     */
+    static getMaxSkillBoost(skillName: string): number;
 }
 export { QuestTool };