osrs-tools 0.2.2 → 1.0.0

package/README.md

@@ -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 completion detection
 
 ## Contributing
 

package/dist/Requirement.d.ts

@@ -0,0 +1,65 @@
+interface Requirement {
+    description: string;
+    type: RequirementType;
+}
+declare class LevelRequirement implements Requirement {
+    type: RequirementType;
+    skillName: string;
+    level: number;
+    boostable: boolean;
+    constructor(skillName: string, level: number, boostable?: boolean);
+    get description(): string;
+}
+declare enum RequirementType {
+    SlayerLevel = "SlayerLevel",
+    Level = "Level",
+    CombatLevel = "CombatLevel",
+    Quest = "Quest",
+    QuestPoint = "QuestPoint",
+    Item = "Item",
+    Location = "Location",
+    SlayerUnlock = "SlayerUnlock"
+}
+declare class SlayerUnlockRequirement implements Requirement {
+    type: RequirementType;
+    name: string;
+    constructor(name: string);
+    get description(): string;
+}
+declare class SlayerLevelRequirement implements Requirement {
+    type: RequirementType;
+    level: number;
+    constructor(level: number);
+    get description(): string;
+}
+declare class CombatLevelRequirement implements Requirement {
+    type: RequirementType;
+    level: number;
+    constructor(level: number);
+    get description(): string;
+}
+declare class QuestRequirement implements Requirement {
+    type: RequirementType;
+    questName: string;
+    constructor(questName: string);
+    get description(): string;
+}
+declare class QuestPointRequirement implements Requirement {
+    type: RequirementType;
+    amount: number;
+    constructor(amount: number);
+    get description(): string;
+}
+declare class ItemRequirement implements Requirement {
+    type: RequirementType;
+    itemName: string;
+    constructor(itemName: string);
+    get description(): string;
+}
+declare class LocationRequirement implements Requirement {
+    type: RequirementType;
+    locationName: string;
+    constructor(locationName: string);
+    get description(): string;
+}
+export { CombatLevelRequirement, QuestPointRequirement, ItemRequirement, LevelRequirement, LocationRequirement, QuestRequirement, Requirement, RequirementType, SlayerLevelRequirement, SlayerUnlockRequirement, };

package/dist/Requirement.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlayerUnlockRequirement = exports.SlayerLevelRequirement = exports.RequirementType = exports.QuestRequirement = exports.LocationRequirement = exports.LevelRequirement = exports.ItemRequirement = exports.QuestPointRequirement = exports.CombatLevelRequirement = void 0;
+// TODO: Add a requirement type for all "levels" (combat, slayer, farming, crafting etc.)
+class LevelRequirement {
+    constructor(skillName, level, boostable = false) {
+        this.type = RequirementType.Level;
+        this.boostable = false; // Indicates if the level can be boosted
+        this.boostable = boostable;
+        this.skillName = skillName;
+        this.level = level;
+    }
+    get description() {
+        return `Level ${this.level}`;
+    }
+}
+exports.LevelRequirement = LevelRequirement;
+// Enum for requirement types
+var RequirementType;
+(function (RequirementType) {
+    RequirementType["SlayerLevel"] = "SlayerLevel";
+    RequirementType["Level"] = "Level";
+    RequirementType["CombatLevel"] = "CombatLevel";
+    RequirementType["Quest"] = "Quest";
+    RequirementType["QuestPoint"] = "QuestPoint";
+    RequirementType["Item"] = "Item";
+    RequirementType["Location"] = "Location";
+    RequirementType["SlayerUnlock"] = "SlayerUnlock";
+})(RequirementType || (exports.RequirementType = RequirementType = {}));
+// Slayer Unlock requirement
+class SlayerUnlockRequirement {
+    constructor(name) {
+        this.type = RequirementType.SlayerUnlock;
+        this.name = name;
+    }
+    get description() {
+        return `Slayer unlock: ${this.name}`;
+    }
+}
+exports.SlayerUnlockRequirement = SlayerUnlockRequirement;
+// Slayer level requirement
+class SlayerLevelRequirement {
+    constructor(level) {
+        this.type = RequirementType.SlayerLevel;
+        this.level = level;
+    }
+    get description() {
+        return `Slayer level ${this.level}`;
+    }
+}
+exports.SlayerLevelRequirement = SlayerLevelRequirement;
+// Combat level requirement
+class CombatLevelRequirement {
+    constructor(level) {
+        this.type = RequirementType.CombatLevel;
+        this.level = level;
+    }
+    get description() {
+        return `Combat level ${this.level}`;
+    }
+}
+exports.CombatLevelRequirement = CombatLevelRequirement;
+// Quest requirement
+class QuestRequirement {
+    constructor(questName) {
+        this.type = RequirementType.Quest;
+        this.questName = questName;
+    }
+    get description() {
+        return `Completed quest: ${this.questName}`;
+    }
+}
+exports.QuestRequirement = QuestRequirement;
+class QuestPointRequirement {
+    constructor(amount) {
+        this.type = RequirementType.Quest;
+        this.amount = amount;
+    }
+    get description() {
+        return `Quest Points Needed: ${this.amount}`;
+    }
+}
+exports.QuestPointRequirement = QuestPointRequirement;
+// Item requirement
+class ItemRequirement {
+    constructor(itemName) {
+        this.type = RequirementType.Item;
+        this.itemName = itemName;
+    }
+    get description() {
+        return `Has item: ${this.itemName}`;
+    }
+}
+exports.ItemRequirement = ItemRequirement;
+// Location requirement
+class LocationRequirement {
+    constructor(locationName) {
+        this.type = RequirementType.Location;
+        this.locationName = locationName;
+    }
+    get description() {
+        return `Access to location: ${this.locationName}`;
+    }
+}
+exports.LocationRequirement = LocationRequirement;

package/dist/account/OsrsAccount.d.ts

@@ -0,0 +1,80 @@
+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;
+    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;
+    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;
+    toJson(): OsrsAccountData;
+}
+export { OsrsAccount, OsrsAccountData, Skills, Skill, SkillsDetail, Bosses, BossScore, Clues, ClueScore, BountyHunter, };

package/dist/account/OsrsAccount.js

@@ -0,0 +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(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");
+    }
+    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,
+        });
+    }
+    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) {
+        return __classPrivateFieldGet(this, _OsrsAccount_skills, "f")[skillName.toLowerCase()];
+    }
+    getSkillDetail(skillName) {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _OsrsAccount_skillsDetail, "f")) === null || _a === void 0 ? void 0 : _a[skillName.toLowerCase()];
+    }
+    getBossScore(bossName) {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _OsrsAccount_bosses, "f")) === null || _a === void 0 ? void 0 : _a[bossName];
+    }
+    getClueScore(clueType) {
+        var _a;
+        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/account/Skill.d.ts

@@ -0,0 +1,25 @@
+export declare enum Skill {
+    Attack = "Attack",
+    Defence = "Defence",
+    Strength = "Strength",
+    Hitpoints = "Hitpoints",
+    Ranged = "Ranged",
+    Prayer = "Prayer",
+    Magic = "Magic",
+    Cooking = "Cooking",
+    Woodcutting = "Woodcutting",
+    Fletching = "Fletching",
+    Fishing = "Fishing",
+    Firemaking = "Firemaking",
+    Crafting = "Crafting",
+    Smithing = "Smithing",
+    Mining = "Mining",
+    Herblore = "Herblore",
+    Agility = "Agility",
+    Thieving = "Thieving",
+    Slayer = "Slayer",
+    Farming = "Farming",
+    Runecraft = "Runecraft",
+    Hunter = "Hunter",
+    Construction = "Construction"
+}

package/dist/account/Skill.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Skill = void 0;
+var Skill;
+(function (Skill) {
+    Skill["Attack"] = "Attack";
+    Skill["Defence"] = "Defence";
+    Skill["Strength"] = "Strength";
+    Skill["Hitpoints"] = "Hitpoints";
+    Skill["Ranged"] = "Ranged";
+    Skill["Prayer"] = "Prayer";
+    Skill["Magic"] = "Magic";
+    Skill["Cooking"] = "Cooking";
+    Skill["Woodcutting"] = "Woodcutting";
+    Skill["Fletching"] = "Fletching";
+    Skill["Fishing"] = "Fishing";
+    Skill["Firemaking"] = "Firemaking";
+    Skill["Crafting"] = "Crafting";
+    Skill["Smithing"] = "Smithing";
+    Skill["Mining"] = "Mining";
+    Skill["Herblore"] = "Herblore";
+    Skill["Agility"] = "Agility";
+    Skill["Thieving"] = "Thieving";
+    Skill["Slayer"] = "Slayer";
+    Skill["Farming"] = "Farming";
+    Skill["Runecraft"] = "Runecraft";
+    Skill["Hunter"] = "Hunter";
+    Skill["Construction"] = "Construction";
+})(Skill || (exports.Skill = Skill = {}));

package/dist/misc/Item.d.ts

@@ -0,0 +1,7 @@
+export declare class Item {
+    id: number;
+    name: string;
+    description?: string;
+    value?: number;
+    constructor(id: number, name: string, description?: string, value?: number);
+}

package/dist/misc/Item.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Item = void 0;
+class Item {
+    constructor(id, name, description, value) {
+        this.id = id;
+        this.name = name;
+        this.description = description;
+        this.value = value;
+    }
+}
+exports.Item = Item;