hive-bedrock-api 0.0.7 → 0.0.8-beta.1

package/lib/config.d.ts

@@ -1,6 +1,7 @@
-export declare type Game = "sky" | "wars" | "hide" | "sg" | "dr" | "murder" | Game[];
+export declare type Game = string | "sky" | "wars" | "hide" | "sg" | "dr" | "murder";
+export declare type GameWithArray = "sky" | "wars" | "hide" | "sg" | "dr" | "murder" | Game[];
 export declare type Mode = "all" | "monthly";
 export declare type PlayerIdentifier = string;
 export declare const API_ENDPOINT: string;
-export declare const API_GAMES: Array<"sky" | "wars" | "hide" | "sg" | "dr" | "murder">;
+export declare const API_GAMES: Game[];
 export declare const API_MODES: Array<Mode>;

package/lib/getStats.d.ts

@@ -1,2 +1,2 @@
 import { Game, Mode } from "./config";
-export default function getStats(playerIdentifier: string, game: Game, mode: Mode): Promise<"hi" | undefined>;
+export default function getStats(playerIdentifier: string, game: Game, mode: Mode): Promise<unknown>;

package/lib/getStats.js

@@ -35,14 +35,34 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("./config");
+var fetchData_1 = __importDefault(require("./misc/fetchData"));
 function getStats(playerIdentifier, game, mode) {
     return __awaiter(this, void 0, void 0, function () {
         return __generator(this, function (_a) {
-            if (!Array.isArray(game)) {
-                return [2 /*return*/, "hi"];
-            }
-            return [2 /*return*/];
+            return [2 /*return*/, new Promise(function (resolve, reject) {
+                    var gameOption = Array.from(typeof game == "string" ? [game] : game);
+                    for (var i in gameOption) {
+                        if (!config_1.API_GAMES.includes(gameOption[i]))
+                            reject("Unkown game '".concat(gameOption[i], "'."));
+                    }
+                    if (!config_1.API_MODES.includes(mode))
+                        reject("Unkown mode '".concat(mode, "'."));
+                    if (mode == "all") {
+                        var userStats = (0, fetchData_1.default)(gameOption.map(function (gameValue) { return "/game/all/".concat(gameValue, "/").concat(playerIdentifier); }));
+                        resolve(userStats);
+                    }
+                    if (mode == "monthly") {
+                        var userStats = (0, fetchData_1.default)(gameOption.map(function (gameValue) {
+                            return "/game/monthly/player/".concat(gameValue, "/").concat(playerIdentifier);
+                        }));
+                        resolve(userStats);
+                    }
+                })];
         });
     });
 }

package/lib/index.d.ts

@@ -1,3 +1,4 @@
 import getStats from "./getStats";
 import fetchData from "./misc/fetchData";
-export { getStats, fetchData };
+import getGame, { getAllGames } from "./misc/getGame";
+export { getStats, fetchData, getGame, getAllGames };

package/lib/index.js

@@ -1,10 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchData = exports.getStats = void 0;
+exports.getAllGames = exports.getGame = exports.fetchData = exports.getStats = void 0;
 var getStats_1 = __importDefault(require("./getStats"));
 exports.getStats = getStats_1.default;
 var fetchData_1 = __importDefault(require("./misc/fetchData"));
 exports.fetchData = fetchData_1.default;
+var getGame_1 = __importStar(require("./misc/getGame"));
+exports.getGame = getGame_1.default;
+Object.defineProperty(exports, "getAllGames", { enumerable: true, get: function () { return getGame_1.getAllGames; } });

package/lib/misc/Response.d.ts

@@ -0,0 +1,22 @@
+import { AxiosResponse } from "axios";
+import { APIPath } from "./fetchData";
+import ResponseData from "./ResponseData";
+interface ResponseType {
+    hasFailed: boolean;
+    status: number;
+    message: string;
+    response: AxiosResponse;
+}
+interface RatelimitsType {
+    limit: number;
+    remaining: number;
+}
+export default class Response {
+    apiPath: APIPath;
+    response: ResponseType;
+    ratelimits: RatelimitsType;
+    data: ResponseData;
+    constructor(apiPath: APIPath, apiResponse: AxiosResponse);
+    getStats(): ResponseData;
+}
+export {};

package/lib/misc/Response.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ResponseData_1 = __importDefault(require("./ResponseData"));
+var Response = /** @class */ (function () {
+    function Response(apiPath, apiResponse) {
+        this.apiPath = apiPath;
+        this.response = {
+            hasFailed: apiResponse.status == 200 ? false : true,
+            status: apiResponse.status,
+            message: apiResponse.statusText,
+            response: apiResponse,
+        };
+        this.ratelimits = {
+            limit: parseInt(apiResponse.headers["x-ratelimit-limit"]) | 0,
+            remaining: parseInt(apiResponse.headers["x-ratelimit-remaining"]) | 0,
+        };
+        this.data = new ResponseData_1.default(this.apiPath, apiResponse.data);
+    }
+    Response.prototype.getStats = function () {
+        return this.data;
+    };
+    return Response;
+}());
+exports.default = Response;

package/lib/misc/ResponseData.d.ts

@@ -0,0 +1,50 @@
+import { APIPath } from "./fetchData";
+import { GameOutput } from "./getGame";
+interface PlayerResponseData {
+    index?: number;
+    human_index?: number;
+    username?: string;
+    UUID?: string;
+    uncapped_xp?: number;
+    xp?: number;
+    played?: number;
+    victories?: number;
+    first_played?: number;
+    deaths?: number;
+    kills?: number;
+    final_kills?: number;
+    treasure_destroyed?: number;
+    prestige?: number;
+    mystery_chests_destroyed?: number;
+    ores_mined?: number;
+    spells_used?: number;
+    checkpoints?: number;
+    activated?: number;
+    hider_kills?: number;
+    seeker_kills?: number;
+    crates?: number;
+    deathmatches?: number;
+    cows?: number;
+    coins?: number;
+    murders?: number;
+    murderer_eliminations?: number;
+}
+interface XPObject {
+    level: number;
+    xpToNextLevel: number;
+    xpToMaxLevel: number;
+    percentageToNextLevel: number;
+    percentageToMaxLevel: number;
+}
+export default class ResponseData {
+    apiPath: APIPath;
+    data: PlayerResponseData;
+    game: GameOutput;
+    xp: XPObject;
+    constructor(apiPath: APIPath, responseData: PlayerResponseData);
+    private _saveRaw;
+    private _currentGame;
+    get rawData(): PlayerResponseData;
+    private _addCustomValues;
+}
+export {};

package/lib/misc/ResponseData.js

@@ -0,0 +1,136 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("../config");
+var getGame_1 = __importDefault(require("./getGame"));
+var XP_1 = require("./XP");
+var _rawData = {};
+var ResponseData = /** @class */ (function () {
+    function ResponseData(apiPath, responseData) {
+        this.apiPath = apiPath;
+        this.data = responseData;
+        this.game = (0, getGame_1.default)(this._currentGame());
+        this._saveRaw(responseData);
+        this._addCustomValues();
+        if (this.data.xp) {
+            var xpClass = new XP_1.XP(this.game.key, this.data.xp);
+            this.xp = {
+                level: xpClass.getLevel(),
+                xpToNextLevel: xpClass.getXPToNextLevel(),
+                xpToMaxLevel: xpClass.getXPToMaxLevel(),
+                percentageToNextLevel: xpClass.getPercentageToNextLevel(),
+                percentageToMaxLevel: xpClass.getPercentageToMaxLevel(),
+            };
+        }
+        else {
+            this.xp = {
+                level: 0,
+                xpToNextLevel: 0,
+                xpToMaxLevel: 0,
+                percentageToNextLevel: 0,
+                percentageToMaxLevel: 0,
+            };
+        }
+    }
+    ResponseData.prototype._saveRaw = function (responseData) {
+        _rawData = responseData;
+    };
+    ResponseData.prototype._currentGame = function () {
+        for (var game in config_1.API_GAMES) {
+            if (this.apiPath.includes("/".concat(config_1.API_GAMES[game], "/"))) {
+                return config_1.API_GAMES[game];
+            }
+        }
+        return "";
+    };
+    Object.defineProperty(ResponseData.prototype, "rawData", {
+        get: function () {
+            return _rawData;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ResponseData.prototype._addCustomValues = function () {
+        var _a, _b;
+        var values = {};
+        var rawData = this.rawData;
+        // xpr (xp per round)
+        if (rawData.xp && rawData.played) {
+            values.xpr = rawData.xp / rawData.played;
+        }
+        // win_percentage, games_lost
+        if (rawData.played && rawData.victories) {
+            values.win_percentage = parseFloat((rawData.victories / rawData.played).toFixed(4));
+            values.games_lost = rawData.played - rawData.victories;
+        }
+        // kpr (kills per round)
+        var kills = (_b = (_a = rawData.kills) !== null && _a !== void 0 ? _a : rawData.hider_kills) !== null && _b !== void 0 ? _b : rawData.murders;
+        if (kills && rawData.played) {
+            values.kpr = parseFloat((kills / rawData.played).toFixed(2));
+        }
+        // dpr (deaths per round)
+        if (rawData.deaths && rawData.played) {
+            values.dpr = parseFloat((rawData.deaths / rawData.played).toFixed(2));
+        }
+        // chpr (checkpoints per round)
+        if (rawData.checkpoints && rawData.played) {
+            values.chpr = parseFloat((rawData.checkpoints / rawData.played).toFixed(2));
+        }
+        // kdr (kill death raito)
+        if (rawData.kills && rawData.deaths) {
+            values.kdr = parseFloat((rawData.kills / rawData.deaths).toFixed(2));
+        }
+        // sdr (seeker kills / death raito)
+        if (rawData.seeker_kills && rawData.deaths) {
+            values.sdr = parseFloat((rawData.seeker_kills / rawData.deaths).toFixed(2));
+        }
+        // fdr (final kills / death raito)
+        if (rawData.final_kills && rawData.deaths) {
+            values.fdr = parseFloat((rawData.final_kills / rawData.deaths).toFixed(2));
+        }
+        // fpr (final kills per round)
+        if (rawData.final_kills && rawData.played) {
+            values.fpr = parseFloat((rawData.final_kills / rawData.played).toFixed(2));
+        }
+        // tpr (treasures per round)
+        if (rawData.treasure_destroyed && rawData.played) {
+            values.tpr = parseFloat((rawData.treasure_destroyed / rawData.played).toFixed(2));
+        }
+        // mpr (mystery chests per round)
+        if (rawData.mystery_chests_destroyed && rawData.played) {
+            values.mpr = parseFloat((rawData.mystery_chests_destroyed / rawData.played).toFixed(2));
+        }
+        // cpr (coins per round)
+        if (rawData.coins && rawData.played) {
+            values.cpr = parseFloat((rawData.coins / rawData.played).toFixed(2));
+        }
+        // dmpr (deathmatches per round)
+        if (rawData.deathmatches && rawData.played) {
+            values.dmpr = parseFloat((rawData.deathmatches / rawData.played).toFixed(2));
+        }
+        // crpr (crates per round)
+        if (rawData.crates && rawData.played) {
+            values.crpr = parseFloat((rawData.crates / rawData.played).toFixed(2));
+        }
+        // copr (cows per round)
+        if (rawData.cows && rawData.played) {
+            values.copr = parseFloat((rawData.cows / rawData.played).toFixed(2));
+        }
+        this.data = __assign(__assign({}, this.data), values);
+    };
+    return ResponseData;
+}());
+exports.default = ResponseData;

package/lib/misc/XP.d.ts

@@ -0,0 +1,20 @@
+import { Game } from "../config";
+interface Level {
+    level: number;
+    xp: number;
+}
+export declare class XP {
+    xp: number;
+    game: Game;
+    max: number;
+    cap: number;
+    increment: number;
+    constructor(game: Game, xp: number);
+    _getTable(): Level[];
+    getLevel(round?: boolean): number;
+    getPercentageToNextLevel(): number;
+    getXPToNextLevel(): number;
+    getPercentageToMaxLevel(): number;
+    getXPToMaxLevel(): number;
+}
+export {};

package/lib/misc/XP.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XP = void 0;
+var getGame_1 = __importDefault(require("./getGame"));
+var XP = /** @class */ (function () {
+    function XP(game, xp) {
+        this.xp = xp;
+        this.game = (0, getGame_1.default)(game).key;
+        this.max = (0, getGame_1.default)(game).maxLevel;
+        this.cap = (0, getGame_1.default)(game).xpCap;
+        this.increment = (0, getGame_1.default)(game).xpIncrement;
+    }
+    XP.prototype._getTable = function () {
+        var _a;
+        var table = [];
+        var currentXP = 0;
+        for (var i = 0; i < this.max; i++) {
+            var lastValue = ((_a = table[table.length - 1]) === null || _a === void 0 ? void 0 : _a.xp) || 0;
+            table[i] = { level: i + 1, xp: lastValue + currentXP };
+            if (this.cap == 0 && i != this.max) {
+                currentXP = currentXP + this.increment;
+            }
+            else if (i != this.max - 1 && i < this.cap - 1)
+                currentXP = currentXP + this.increment;
+        }
+        return table;
+    };
+    XP.prototype.getLevel = function (round) {
+        if (round === void 0) { round = true; }
+        var increment = this.increment / 2;
+        var level = (-increment +
+            Math.sqrt(Math.pow(increment, 2) - 4 * increment * -this.xp)) /
+            (2 * increment) +
+            1;
+        if (this.cap && level > this.cap)
+            level =
+                this.cap +
+                    (this.xp -
+                        (increment * Math.pow(this.cap - 1, 2) +
+                            (this.cap - 1) * increment)) /
+                        ((this.cap - 1) * increment * 2);
+        var rounded = parseInt(level.toString());
+        if (round)
+            return rounded;
+        return level;
+    };
+    XP.prototype.getPercentageToNextLevel = function () {
+        var table = this._getTable();
+        var level = this.getLevel();
+        var currentLevel = table[level - 1];
+        var nextLevel = table[level];
+        if (!nextLevel)
+            return 1;
+        var levelDone = this.xp - currentLevel.xp;
+        var levelXP = nextLevel.xp - currentLevel.xp;
+        return levelDone / levelXP;
+    };
+    XP.prototype.getXPToNextLevel = function () {
+        var table = this._getTable();
+        var level = this.getLevel();
+        var currentLevel = table[level - 1];
+        var nextLevel = table[level];
+        if (!nextLevel)
+            return 0;
+        var levelDone = this.xp - currentLevel.xp;
+        var levelXP = nextLevel.xp - currentLevel.xp;
+        return levelXP - levelDone;
+    };
+    XP.prototype.getPercentageToMaxLevel = function () {
+        var table = this._getTable();
+        if (this.xp > table[table.length - 1].xp)
+            return 1;
+        return this.xp / table[table.length - 1].xp;
+    };
+    XP.prototype.getXPToMaxLevel = function () {
+        var table = this._getTable();
+        if (this.xp > table[table.length - 1].xp)
+            return 0;
+        return table[table.length - 1].xp - this.xp;
+    };
+    return XP;
+}());
+exports.XP = XP;

package/lib/misc/fetchData.d.ts

@@ -1,11 +1,4 @@
-declare type Game = "sky" | "wars" | "hide" | "sg" | "dr" | "murder";
-declare type APIPath = `/game/all/${Game}/${string}` | `/game/all/${Game}/[playerIdentifier]` | `/game/all/${Game}` | `/game/monthly/${Game}` | `/game/monthly/${Game}/${number}/${number}/${number}/${number}` | `/game/monthly/${Game}/[year]/[month]/[amount]/[skip]` | `/game/monthly/player/${Game}/${string}` | `/game/monthly/player/${Game}/[playerIdentifier]` | `/game/monthly/player/${Game}/${string}/${number}/${number}` | `/game/monthly/player/${Game}/[playerIdentifier]/[year]/[month]`;
-export default function fetchData(apiPath: APIPath): Promise<{
-    response: {
-        status: any;
-        message: any;
-    };
-    ratelimits: {};
-    data: {};
-} | undefined>;
-export {};
+import { Game } from "../config";
+import Response from "./Response";
+export declare type APIPath = `/game/all/${Game}/${string}` | `/game/all/${Game}` | `/game/monthly/${Game}` | `/game/monthly/${Game}/${number}/${number}/${number}/${number}` | `/game/monthly/player/${Game}/${string}` | `/game/monthly/player/${Game}/${string}/${number}/${number}`;
+export default function fetchData(apiPaths: APIPath[]): Promise<Response[]>;

package/lib/misc/fetchData.js

@@ -41,31 +41,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var axios_1 = __importDefault(require("axios"));
 var config_1 = require("../config");
-function fetchData(apiPath) {
+var Response_1 = __importDefault(require("./Response"));
+function fetch(apiPath) {
     return __awaiter(this, void 0, void 0, function () {
-        var request, err_1, _a, status_1, statusText;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var request, err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
-                    _b.trys.push([0, 2, , 3]);
+                    _a.trys.push([0, 2, , 3]);
                     return [4 /*yield*/, axios_1.default.get(config_1.API_ENDPOINT + apiPath)];
                 case 1:
-                    request = _b.sent();
-                    return [3 /*break*/, 3];
+                    request = _a.sent();
+                    return [2 /*return*/, [apiPath, request]];
                 case 2:
-                    err_1 = _b.sent();
-                    _a = err_1 === null || err_1 === void 0 ? void 0 : err_1.response, status_1 = _a.status, statusText = _a.statusText;
-                    return [2 /*return*/, {
-                            response: {
-                                status: status_1,
-                                message: statusText,
-                            },
-                            ratelimits: {},
-                            data: {},
-                        }];
+                    err_1 = _a.sent();
+                    return [2 /*return*/, [apiPath, err_1 === null || err_1 === void 0 ? void 0 : err_1.response]];
                 case 3: return [2 /*return*/];
             }
         });
     });
 }
+function fetchData(apiPaths) {
+    return __awaiter(this, void 0, void 0, function () {
+        var responses, responseValues;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.all(apiPaths.map(function (path) { return fetch(path); }))];
+                case 1:
+                    responses = _a.sent();
+                    responseValues = responses.map(function (_a) {
+                        var apiPath = _a[0], response = _a[1];
+                        return new Response_1.default(apiPath, response);
+                    });
+                    return [2 /*return*/, responseValues];
+            }
+        });
+    });
+}
 exports.default = fetchData;

package/lib/misc/getGame.d.ts

@@ -0,0 +1,11 @@
+import { Game } from "../config";
+export interface GameOutput {
+    key: Game;
+    name: string;
+    maxLevel: number;
+    maxPrestige: number;
+    xpCap: number;
+    xpIncrement: number;
+}
+export default function getGame(game: Game): GameOutput;
+export declare function getAllGames(): GameOutput[];

package/lib/misc/getGame.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllGames = void 0;
+var games = new Map([
+    [
+        "wars",
+        {
+            key: "wars",
+            name: "Treasure Wars",
+            maxLevel: 100,
+            maxPrestige: 5,
+            xpCap: 52,
+            xpIncrement: 150,
+        },
+    ],
+    [
+        "sg",
+        {
+            key: "sg",
+            name: "Survival Games",
+            maxLevel: 30,
+            maxPrestige: 0,
+            xpCap: 0,
+            xpIncrement: 150,
+        },
+    ],
+    [
+        "sky",
+        {
+            key: "sky",
+            name: "Skywars",
+            maxLevel: 75,
+            maxPrestige: 0,
+            xpCap: 52,
+            xpIncrement: 150,
+        },
+    ],
+    [
+        "murder",
+        {
+            key: "murder",
+            name: "Murder Mystery",
+            maxLevel: 100,
+            maxPrestige: 0,
+            xpCap: 82,
+            xpIncrement: 100,
+        },
+    ],
+    [
+        "build",
+        {
+            key: "build",
+            name: "Just Build",
+            maxLevel: 20,
+            maxPrestige: 0,
+            xpCap: 0,
+            xpIncrement: 100,
+        },
+    ],
+    [
+        "hide",
+        {
+            key: "hide",
+            name: "Hide and Seek",
+            maxLevel: 50,
+            maxPrestige: 0,
+            xpCap: 0,
+            xpIncrement: 100,
+        },
+    ],
+    [
+        "dr",
+        {
+            key: "dr",
+            name: "DeathRun",
+            maxLevel: 40,
+            maxPrestige: 0,
+            xpCap: 0,
+            xpIncrement: 200,
+        },
+    ],
+]);
+function getGame(game) {
+    var blank = {
+        key: "",
+        name: "",
+        maxLevel: 0,
+        maxPrestige: 0,
+        xpCap: 0,
+        xpIncrement: 0,
+    };
+    switch (game) {
+        case "wars":
+            var value = games.get("wars");
+            return value ? value : blank;
+        case "sg":
+            var value = games.get("sg");
+            return value ? value : blank;
+        case "sky":
+            var value = games.get("sky");
+            return value ? value : blank;
+        case "murder":
+            var value = games.get("murder");
+            return value ? value : blank;
+        case "build":
+            var value = games.get("build");
+            return value ? value : blank;
+        case "hide":
+            var value = games.get("hide");
+            return value ? value : blank;
+        case "dr":
+            var value = games.get("dr");
+            return value ? value : blank;
+        default:
+            return blank;
+    }
+}
+exports.default = getGame;
+function getAllGames() {
+    var arrayValue = Array.from(games.values());
+    return arrayValue;
+}
+exports.getAllGames = getAllGames;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hive-bedrock-api",
-    "version": "0.0.7",
+    "version": "0.0.8-beta.1",
     "description": "An API wrapper for the Hive Minecraft Bedrock Edition server.",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",