@dchighs/dc-core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marcuth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/calculators/calculate-attack-damage.d.ts

@@ -0,0 +1,17 @@
+export type CalculateAttackDamageDragonOption = {
+    category: number;
+    level: number;
+    rank: number;
+    stars: number;
+};
+export type CalculateAttackDamageOptions = {
+    attackPower: number;
+    dragon: CalculateAttackDamageDragonOption;
+};
+export type CalculateAttackDamageResult = {
+    minimum: number;
+    maximum: number;
+    average: number;
+    random: number;
+};
+export declare function calculateAttackDamage({ attackPower, dragon }: CalculateAttackDamageOptions): CalculateAttackDamageResult;

package/dist/calculators/calculate-attack-damage.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAttackDamage = calculateAttackDamage;
+const validate_dragon_level_compatibility_with_stars_1 = require("../tools/validate-dragon-level-compatibility-with-stars");
+const validate_dragon_category_1 = require("../tools/validate-dragon-category");
+const validate_dragon_rank_1 = require("../tools/validate-dragon-rank");
+const dragons_1 = require("../settings/dragons");
+const damageVariant = dragons_1.dragonSettings.attacks.damageVariant;
+function calculateAttackDamage({ attackPower, dragon }) {
+    (0, validate_dragon_level_compatibility_with_stars_1.validateDragonLevelCompatibilityWithStars)({ level: dragon.level, stars: dragon.stars, throwOnError: true });
+    (0, validate_dragon_category_1.validateDragonCategory)(dragon.category, { throwOnError: true });
+    (0, validate_dragon_rank_1.validateDragonRank)(dragon.rank, { throwOnError: true });
+    const categoryKey = dragon.category;
+    const initialDamage = dragons_1.dragonSettings.attacks.categoryPowers[categoryKey];
+    const levelBonus = dragon.level ** 1.5 + 10;
+    let rankBonus = 0;
+    let starsBonus = 0;
+    if (dragon.rank > 0) {
+        const rankKey = dragon.rank;
+        rankBonus = dragons_1.dragonSettings.attacks.rankPowers[rankKey];
+    }
+    if (dragon.stars > 0) {
+        starsBonus = dragons_1.dragonSettings.attacks.oneStarPower * dragon.stars;
+    }
+    const damage = 1.5 * (1 + rankBonus + starsBonus) * (initialDamage * levelBonus / 250) + attackPower;
+    const minimum = Math.round(damageVariant[0] * damage);
+    const maximum = Math.round(damageVariant[1] * damage);
+    const avarage = Math.round((minimum + maximum) / 2);
+    const randomFactor = Math.random() * (damageVariant[1] - damageVariant[0]) + damageVariant[0];
+    const randomDamage = Math.round(randomFactor * damage);
+    return {
+        minimum: minimum,
+        maximum: maximum,
+        average: avarage,
+        random: randomDamage,
+    };
+}

package/dist/calculators/calculate-dragon-feed-cost.d.ts

@@ -0,0 +1,5 @@
+export type CalculateDragonFeedCostOptions = {
+    initialLevel: number;
+    finalLevel: number;
+};
+export declare function calculateDragonFeedCost({ initialLevel, finalLevel }: CalculateDragonFeedCostOptions): number;

package/dist/calculators/calculate-dragon-feed-cost.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDragonFeedCost = calculateDragonFeedCost;
+const validate_dragon_level_1 = require("../tools/validate-dragon-level");
+const feed_costs_1 = require("../settings/feed-costs");
+function calculateDragonFeedCost({ initialLevel, finalLevel }) {
+    [initialLevel, finalLevel].forEach(level => (0, validate_dragon_level_1.validateDragonLevel)(level, { throwOnError: true }));
+    if (initialLevel > finalLevel) {
+        throw new Error("Initial dragon level cannot be higher than final dragon level.");
+    }
+    if (initialLevel === finalLevel) {
+        return 0;
+    }
+    let cost = 0;
+    for (let i = 0; i < finalLevel; i++) {
+        const costPerLevel = feed_costs_1.feedCostSettings[i].total;
+        cost += costPerLevel;
+    }
+    return cost;
+}

package/dist/calculators/calculate-element-strengths.d.ts

@@ -0,0 +1 @@
+export declare function calculateElementStrengths(element: string): import("..").DragonElement[] | never[];

package/dist/calculators/calculate-element-strengths.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateElementStrengths = calculateElementStrengths;
+const validate_element_name_1 = require("../tools/validate-element-name");
+const elements_1 = require("../settings/elements");
+function calculateElementStrengths(element) {
+    (0, validate_element_name_1.validateElementName)(element, { throwOnError: true });
+    const elementKey = element;
+    const elementSetting = elements_1.elementSettings[elementKey];
+    const elementStrengths = elementSetting.strengths;
+    return elementStrengths;
+}

package/dist/calculators/calculate-element-weaknesses.d.ts

@@ -0,0 +1 @@
+export declare function calculateElementWeaknesses(element: string): import("..").DragonElement[] | never[];

package/dist/calculators/calculate-element-weaknesses.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateElementWeaknesses = calculateElementWeaknesses;
+const validate_element_name_1 = require("../tools/validate-element-name");
+const elements_1 = require("../settings/elements");
+function calculateElementWeaknesses(element) {
+    (0, validate_element_name_1.validateElementName)(element, { throwOnError: true });
+    const elementKey = element;
+    const elementSetting = elements_1.elementSettings[elementKey];
+    const elementWeaknesses = elementSetting.weaknesses;
+    return elementWeaknesses;
+}

package/dist/calculators/calculate-elements-strengths.d.ts

@@ -0,0 +1 @@
+export declare function calculateElementsStrengths(elements: string[]): string[];

package/dist/calculators/calculate-elements-strengths.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateElementsStrengths = calculateElementsStrengths;
+const validate_element_name_1 = require("../tools/validate-element-name");
+const elements_1 = require("../settings/elements");
+function calculateElementsStrengths(elements) {
+    elements.forEach(element => (0, validate_element_name_1.validateElementName)(element, { throwOnError: true }));
+    const allElementStrengths = [];
+    for (const element of elements) {
+        const elementKey = element;
+        const elementSetting = elements_1.elementSettings[elementKey];
+        const elementStrengths = elementSetting.strengths;
+        allElementStrengths.push(...elementStrengths);
+    }
+    const uniqueElements = [...new Set(allElementStrengths)];
+    return uniqueElements;
+}

package/dist/calculators/calculate-orb-recall-gain.d.ts

@@ -0,0 +1,5 @@
+export type CalculateOrbRecallGainOptions = {
+    level: number;
+    stars?: number;
+};
+export declare function calculateOrbRecallGain({ level, stars }: CalculateOrbRecallGainOptions): number;

package/dist/calculators/calculate-orb-recall-gain.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateOrbRecallGain = calculateOrbRecallGain;
+const validate_dragon_level_compatibility_with_stars_1 = require("../tools/validate-dragon-level-compatibility-with-stars");
+const orb_recall_return_1 = require("../settings/orb-recall-return");
+function calculateOrbRecallGain({ level, stars }) {
+    const adjustedStars = stars !== null && stars !== void 0 ? stars : 0;
+    const adjustedLevel = Math.min(level, 30);
+    (0, validate_dragon_level_compatibility_with_stars_1.validateDragonLevelCompatibilityWithStars)({
+        level: level,
+        stars: adjustedStars,
+        throwOnError: true
+    });
+    let totalOrbs = 0;
+    for (let levelIndex = 0; levelIndex < adjustedLevel; levelIndex++) {
+        const orbsPerLevel = orb_recall_return_1.orbRecallReturnSettings.perLevels[levelIndex];
+        totalOrbs += orbsPerLevel;
+    }
+    for (let starIndex = 0; starIndex < adjustedStars; starIndex++) {
+        const orbsPerStar = orb_recall_return_1.orbRecallReturnSettings.perStars[starIndex];
+        totalOrbs += orbsPerStar;
+    }
+    return totalOrbs;
+}

package/dist/calculators/index.d.ts

@@ -0,0 +1,7 @@
+import { calculateElementsStrengths } from "./calculate-elements-strengths";
+import { calculateElementWeaknesses } from "./calculate-element-weaknesses";
+import { calculateElementStrengths } from "./calculate-element-strengths";
+import { calculateDragonFeedCost } from "./calculate-dragon-feed-cost";
+import { calculateOrbRecallGain } from "./calculate-orb-recall-gain";
+import { calculateAttackDamage } from "./calculate-attack-damage";
+export { calculateOrbRecallGain, calculateAttackDamage, calculateDragonFeedCost, calculateElementsStrengths, calculateElementWeaknesses, calculateElementStrengths };

package/dist/calculators/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateElementStrengths = exports.calculateElementWeaknesses = exports.calculateElementsStrengths = exports.calculateDragonFeedCost = exports.calculateAttackDamage = exports.calculateOrbRecallGain = void 0;
+const calculate_elements_strengths_1 = require("./calculate-elements-strengths");
+Object.defineProperty(exports, "calculateElementsStrengths", { enumerable: true, get: function () { return calculate_elements_strengths_1.calculateElementsStrengths; } });
+const calculate_element_weaknesses_1 = require("./calculate-element-weaknesses");
+Object.defineProperty(exports, "calculateElementWeaknesses", { enumerable: true, get: function () { return calculate_element_weaknesses_1.calculateElementWeaknesses; } });
+const calculate_element_strengths_1 = require("./calculate-element-strengths");
+Object.defineProperty(exports, "calculateElementStrengths", { enumerable: true, get: function () { return calculate_element_strengths_1.calculateElementStrengths; } });
+const calculate_dragon_feed_cost_1 = require("./calculate-dragon-feed-cost");
+Object.defineProperty(exports, "calculateDragonFeedCost", { enumerable: true, get: function () { return calculate_dragon_feed_cost_1.calculateDragonFeedCost; } });
+const calculate_orb_recall_gain_1 = require("./calculate-orb-recall-gain");
+Object.defineProperty(exports, "calculateOrbRecallGain", { enumerable: true, get: function () { return calculate_orb_recall_gain_1.calculateOrbRecallGain; } });
+const calculate_attack_damage_1 = require("./calculate-attack-damage");
+Object.defineProperty(exports, "calculateAttackDamage", { enumerable: true, get: function () { return calculate_attack_damage_1.calculateAttackDamage; } });

package/dist/enums/config-filter-item.d.ts

@@ -0,0 +1,42 @@
+export declare enum ConfigFilterItem {
+    Chests = "chests",
+    Items = "items",
+    Levels = "levels",
+    BreedOposite = "breed_oposite",
+    TreasureItems = "treasure_items",
+    SanctuaryBreeding = "sanctuary_breeding",
+    HelpViews = "help_views",
+    DeityWorldDragons = "deity_world_dragons",
+    ProgressiveIsland = "progressive_island",
+    News = "news",
+    Dragonarium = "dragonarium",
+    GridIsland = "grid_island",
+    DragonBook = "dragon_book",
+    DragonTournaments = "dragon_tournaments",
+    FogIsland = "fog_island",
+    HeroicRaces = "heroic_races",
+    SpecialBreeding = "special_breeding",
+    MazeIsland = "maze_island",
+    TowerIsland = "tower_island",
+    DragonCollections = "dragon_collections",
+    EventIsland = "event_island",
+    Skills = "skills",
+    TreeOfLife = "tree_of_life",
+    TreeOfLifeRecall = "tree_of_life_recall",
+    TreeOfLifePowerup = "tree_of_life_powerup",
+    HabitatTokens = "habitat_tokens",
+    MaxDragonLevels = "max_dragon_levels",
+    Collectibles = "collectibles",
+    PuzzleIsland = "puzzle_island",
+    VipPass = "vip_pass",
+    DragonSkins = "dragon_skins",
+    DragonWars = "dragon_wars",
+    FarmCrops = "farm_crops",
+    Breeding = "breeding",
+    LiveopsChallenges = "liveops_challenges",
+    AssetVersioning = "asset_versioning",
+    BattlePass = "battle_pass",
+    DragonMastery = "dragon_mastery",
+    RunnerIsland = "runner_island",
+    Perks = "perks"
+}

package/dist/enums/config-filter-item.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigFilterItem = void 0;
+var ConfigFilterItem;
+(function (ConfigFilterItem) {
+    ConfigFilterItem["Chests"] = "chests";
+    ConfigFilterItem["Items"] = "items";
+    ConfigFilterItem["Levels"] = "levels";
+    ConfigFilterItem["BreedOposite"] = "breed_oposite";
+    ConfigFilterItem["TreasureItems"] = "treasure_items";
+    ConfigFilterItem["SanctuaryBreeding"] = "sanctuary_breeding";
+    ConfigFilterItem["HelpViews"] = "help_views";
+    ConfigFilterItem["DeityWorldDragons"] = "deity_world_dragons";
+    ConfigFilterItem["ProgressiveIsland"] = "progressive_island";
+    ConfigFilterItem["News"] = "news";
+    ConfigFilterItem["Dragonarium"] = "dragonarium";
+    ConfigFilterItem["GridIsland"] = "grid_island";
+    ConfigFilterItem["DragonBook"] = "dragon_book";
+    ConfigFilterItem["DragonTournaments"] = "dragon_tournaments";
+    ConfigFilterItem["FogIsland"] = "fog_island";
+    ConfigFilterItem["HeroicRaces"] = "heroic_races";
+    ConfigFilterItem["SpecialBreeding"] = "special_breeding";
+    ConfigFilterItem["MazeIsland"] = "maze_island";
+    ConfigFilterItem["TowerIsland"] = "tower_island";
+    ConfigFilterItem["DragonCollections"] = "dragon_collections";
+    ConfigFilterItem["EventIsland"] = "event_island";
+    ConfigFilterItem["Skills"] = "skills";
+    ConfigFilterItem["TreeOfLife"] = "tree_of_life";
+    ConfigFilterItem["TreeOfLifeRecall"] = "tree_of_life_recall";
+    ConfigFilterItem["TreeOfLifePowerup"] = "tree_of_life_powerup";
+    ConfigFilterItem["HabitatTokens"] = "habitat_tokens";
+    ConfigFilterItem["MaxDragonLevels"] = "max_dragon_levels";
+    ConfigFilterItem["Collectibles"] = "collectibles";
+    ConfigFilterItem["PuzzleIsland"] = "puzzle_island";
+    ConfigFilterItem["VipPass"] = "vip_pass";
+    ConfigFilterItem["DragonSkins"] = "dragon_skins";
+    ConfigFilterItem["DragonWars"] = "dragon_wars";
+    ConfigFilterItem["FarmCrops"] = "farm_crops";
+    ConfigFilterItem["Breeding"] = "breeding";
+    ConfigFilterItem["LiveopsChallenges"] = "liveops_challenges";
+    ConfigFilterItem["AssetVersioning"] = "asset_versioning";
+    ConfigFilterItem["BattlePass"] = "battle_pass";
+    ConfigFilterItem["DragonMastery"] = "dragon_mastery";
+    ConfigFilterItem["RunnerIsland"] = "runner_island";
+    ConfigFilterItem["Perks"] = "perks";
+})(ConfigFilterItem || (exports.ConfigFilterItem = ConfigFilterItem = {}));

package/dist/enums/config-language.d.ts

@@ -0,0 +1,14 @@
+export declare enum ConfigLanguage {
+    Default = "en",
+    English = "en",
+    Portuguese = "pt",
+    BrazilianPortuguese = "br",
+    Spanish = "es",
+    French = "fr",
+    German = "de",
+    Italian = "it",
+    Japanese = "ja",
+    Russian = "ru",
+    Korean = "ko",
+    Turkish = "tr"
+}

package/dist/enums/config-language.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLanguage = void 0;
+var ConfigLanguage;
+(function (ConfigLanguage) {
+    ConfigLanguage["Default"] = "en";
+    ConfigLanguage["English"] = "en";
+    ConfigLanguage["Portuguese"] = "pt";
+    ConfigLanguage["BrazilianPortuguese"] = "br";
+    ConfigLanguage["Spanish"] = "es";
+    ConfigLanguage["French"] = "fr";
+    ConfigLanguage["German"] = "de";
+    ConfigLanguage["Italian"] = "it";
+    ConfigLanguage["Japanese"] = "ja";
+    ConfigLanguage["Russian"] = "ru";
+    ConfigLanguage["Korean"] = "ko";
+    ConfigLanguage["Turkish"] = "tr";
+})(ConfigLanguage || (exports.ConfigLanguage = ConfigLanguage = {}));

package/dist/enums/config-platform.d.ts

@@ -0,0 +1,7 @@
+export declare enum ConfigPlatform {
+    Default = "ios",
+    Android = "android",
+    Windows = "windows",
+    iOS = "ios",
+    Amazon = "amazon"
+}

package/dist/enums/config-platform.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigPlatform = void 0;
+var ConfigPlatform;
+(function (ConfigPlatform) {
+    ConfigPlatform["Default"] = "ios";
+    ConfigPlatform["Android"] = "android";
+    ConfigPlatform["Windows"] = "windows";
+    ConfigPlatform["iOS"] = "ios";
+    ConfigPlatform["Amazon"] = "amazon";
+})(ConfigPlatform || (exports.ConfigPlatform = ConfigPlatform = {}));

package/dist/enums/dragon-category.d.ts

@@ -0,0 +1,13 @@
+export declare enum DragonCategory {
+    Basic = 1,
+    ProBasic = 2,
+    PreAdvanced = 3,
+    Advanced = 4,
+    Elite = 5,
+    Amazing = 6,
+    Charming = 7,
+    Graceful = 8,
+    Champion = 9,
+    Mythical = 10,
+    Heroic = 11
+}

package/dist/enums/dragon-category.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonCategory = void 0;
+var DragonCategory;
+(function (DragonCategory) {
+    DragonCategory[DragonCategory["Basic"] = 1] = "Basic";
+    DragonCategory[DragonCategory["ProBasic"] = 2] = "ProBasic";
+    DragonCategory[DragonCategory["PreAdvanced"] = 3] = "PreAdvanced";
+    DragonCategory[DragonCategory["Advanced"] = 4] = "Advanced";
+    DragonCategory[DragonCategory["Elite"] = 5] = "Elite";
+    DragonCategory[DragonCategory["Amazing"] = 6] = "Amazing";
+    DragonCategory[DragonCategory["Charming"] = 7] = "Charming";
+    DragonCategory[DragonCategory["Graceful"] = 8] = "Graceful";
+    DragonCategory[DragonCategory["Champion"] = 9] = "Champion";
+    DragonCategory[DragonCategory["Mythical"] = 10] = "Mythical";
+    DragonCategory[DragonCategory["Heroic"] = 11] = "Heroic";
+})(DragonCategory || (exports.DragonCategory = DragonCategory = {}));

package/dist/enums/dragon-element.d.ts

@@ -0,0 +1,24 @@
+export declare enum DragonElement {
+    Terra = "terra",
+    Flame = "flame",
+    Sea = "sea",
+    Nature = "nature",
+    Electric = "electric",
+    Ice = "ice",
+    Metal = "metal",
+    Dark = "dark",
+    Light = "light",
+    War = "war",
+    Pure = "pure",
+    Legend = "legend",
+    Primal = "primal",
+    Wind = "wind",
+    Time = "time",
+    Happy = "happy",
+    Chaos = "chaos",
+    Magic = "magic",
+    Soul = "soul",
+    Beauty = "beauty",
+    Dream = "dream",
+    Physical = "physical"
+}

package/dist/enums/dragon-element.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonElement = void 0;
+var DragonElement;
+(function (DragonElement) {
+    DragonElement["Terra"] = "terra";
+    DragonElement["Flame"] = "flame";
+    DragonElement["Sea"] = "sea";
+    DragonElement["Nature"] = "nature";
+    DragonElement["Electric"] = "electric";
+    DragonElement["Ice"] = "ice";
+    DragonElement["Metal"] = "metal";
+    DragonElement["Dark"] = "dark";
+    DragonElement["Light"] = "light";
+    DragonElement["War"] = "war";
+    DragonElement["Pure"] = "pure";
+    DragonElement["Legend"] = "legend";
+    DragonElement["Primal"] = "primal";
+    DragonElement["Wind"] = "wind";
+    DragonElement["Time"] = "time";
+    DragonElement["Happy"] = "happy";
+    DragonElement["Chaos"] = "chaos";
+    DragonElement["Magic"] = "magic";
+    DragonElement["Soul"] = "soul";
+    DragonElement["Beauty"] = "beauty";
+    DragonElement["Dream"] = "dream";
+    DragonElement["Physical"] = "physical";
+})(DragonElement || (exports.DragonElement = DragonElement = {}));

package/dist/enums/dragon-phase.d.ts

@@ -0,0 +1,6 @@
+export declare enum DragonPhase {
+    Egg = 0,
+    Baby = 1,
+    Young = 2,
+    Adult = 3
+}

package/dist/enums/dragon-phase.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonPhase = void 0;
+var DragonPhase;
+(function (DragonPhase) {
+    DragonPhase[DragonPhase["Egg"] = 0] = "Egg";
+    DragonPhase[DragonPhase["Baby"] = 1] = "Baby";
+    DragonPhase[DragonPhase["Young"] = 2] = "Young";
+    DragonPhase[DragonPhase["Adult"] = 3] = "Adult";
+})(DragonPhase || (exports.DragonPhase = DragonPhase = {}));

package/dist/enums/dragon-rank.d.ts

@@ -0,0 +1,14 @@
+export declare enum DragonRank {
+    BronzeIII = 1,
+    BronzeII = 2,
+    BronzeI = 3,
+    SilverIII = 4,
+    SilverII = 5,
+    SilverI = 6,
+    GoldIII = 7,
+    GoldII = 8,
+    GoldI = 9,
+    PlatinumIII = 10,
+    PlatinumII = 11,
+    PlatinumI = 12
+}

package/dist/enums/dragon-rank.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonRank = void 0;
+var DragonRank;
+(function (DragonRank) {
+    DragonRank[DragonRank["BronzeIII"] = 1] = "BronzeIII";
+    DragonRank[DragonRank["BronzeII"] = 2] = "BronzeII";
+    DragonRank[DragonRank["BronzeI"] = 3] = "BronzeI";
+    DragonRank[DragonRank["SilverIII"] = 4] = "SilverIII";
+    DragonRank[DragonRank["SilverII"] = 5] = "SilverII";
+    DragonRank[DragonRank["SilverI"] = 6] = "SilverI";
+    DragonRank[DragonRank["GoldIII"] = 7] = "GoldIII";
+    DragonRank[DragonRank["GoldII"] = 8] = "GoldII";
+    DragonRank[DragonRank["GoldI"] = 9] = "GoldI";
+    DragonRank[DragonRank["PlatinumIII"] = 10] = "PlatinumIII";
+    DragonRank[DragonRank["PlatinumII"] = 11] = "PlatinumII";
+    DragonRank[DragonRank["PlatinumI"] = 12] = "PlatinumI";
+})(DragonRank || (exports.DragonRank = DragonRank = {}));

package/dist/enums/dragon-rarity.d.ts

@@ -0,0 +1,9 @@
+export declare enum DragonRarity {
+    Common = "C",
+    Rare = "R",
+    VeryRare = "V",
+    Epic = "E",
+    Legendary = "L",
+    Mythic = "M",
+    Heroic = "H"
+}

package/dist/enums/dragon-rarity.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonRarity = void 0;
+var DragonRarity;
+(function (DragonRarity) {
+    DragonRarity["Common"] = "C";
+    DragonRarity["Rare"] = "R";
+    DragonRarity["VeryRare"] = "V";
+    DragonRarity["Epic"] = "E";
+    DragonRarity["Legendary"] = "L";
+    DragonRarity["Mythic"] = "M";
+    DragonRarity["Heroic"] = "H";
+})(DragonRarity || (exports.DragonRarity = DragonRarity = {}));

package/dist/enums/dragon-sprite-quality.d.ts

@@ -0,0 +1,5 @@
+export declare enum DragonSpriteQuality {
+    Default = "",
+    Normal = "",
+    Large = "@2x"
+}

package/dist/enums/dragon-sprite-quality.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonSpriteQuality = void 0;
+var DragonSpriteQuality;
+(function (DragonSpriteQuality) {
+    DragonSpriteQuality["Default"] = "";
+    DragonSpriteQuality["Normal"] = "";
+    DragonSpriteQuality["Large"] = "@2x";
+})(DragonSpriteQuality || (exports.DragonSpriteQuality = DragonSpriteQuality = {}));

package/dist/enums/index.d.ts

@@ -0,0 +1,12 @@
+import { StaticFileUrlPlatformPrefix } from "./static-file-url-platform-prefix";
+import { TextureCompressionFormat } from "./texture-compression-format";
+import { DragonSpriteQuality } from "./dragon-sprite-quality";
+import { ConfigFilterItem } from "./config-filter-item";
+import { DragonCategory } from "./dragon-category";
+import { ConfigPlatform } from "./config-platform";
+import { ConfigLanguage } from "./config-language";
+import { DragonRarity } from "./dragon-rarity";
+import { DragonElement } from "./dragon-element";
+import { DragonPhase } from "./dragon-phase";
+import { DragonRank } from "./dragon-rank";
+export { StaticFileUrlPlatformPrefix, TextureCompressionFormat, DragonSpriteQuality, ConfigFilterItem, DragonCategory, ConfigPlatform, ConfigLanguage, DragonRarity, DragonElement, DragonPhase, DragonRank };

package/dist/enums/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonRank = exports.DragonPhase = exports.DragonElement = exports.DragonRarity = exports.ConfigLanguage = exports.ConfigPlatform = exports.DragonCategory = exports.ConfigFilterItem = exports.DragonSpriteQuality = exports.TextureCompressionFormat = exports.StaticFileUrlPlatformPrefix = void 0;
+const static_file_url_platform_prefix_1 = require("./static-file-url-platform-prefix");
+Object.defineProperty(exports, "StaticFileUrlPlatformPrefix", { enumerable: true, get: function () { return static_file_url_platform_prefix_1.StaticFileUrlPlatformPrefix; } });
+const texture_compression_format_1 = require("./texture-compression-format");
+Object.defineProperty(exports, "TextureCompressionFormat", { enumerable: true, get: function () { return texture_compression_format_1.TextureCompressionFormat; } });
+const dragon_sprite_quality_1 = require("./dragon-sprite-quality");
+Object.defineProperty(exports, "DragonSpriteQuality", { enumerable: true, get: function () { return dragon_sprite_quality_1.DragonSpriteQuality; } });
+const config_filter_item_1 = require("./config-filter-item");
+Object.defineProperty(exports, "ConfigFilterItem", { enumerable: true, get: function () { return config_filter_item_1.ConfigFilterItem; } });
+const dragon_category_1 = require("./dragon-category");
+Object.defineProperty(exports, "DragonCategory", { enumerable: true, get: function () { return dragon_category_1.DragonCategory; } });
+const config_platform_1 = require("./config-platform");
+Object.defineProperty(exports, "ConfigPlatform", { enumerable: true, get: function () { return config_platform_1.ConfigPlatform; } });
+const config_language_1 = require("./config-language");
+Object.defineProperty(exports, "ConfigLanguage", { enumerable: true, get: function () { return config_language_1.ConfigLanguage; } });
+const dragon_rarity_1 = require("./dragon-rarity");
+Object.defineProperty(exports, "DragonRarity", { enumerable: true, get: function () { return dragon_rarity_1.DragonRarity; } });
+const dragon_element_1 = require("./dragon-element");
+Object.defineProperty(exports, "DragonElement", { enumerable: true, get: function () { return dragon_element_1.DragonElement; } });
+const dragon_phase_1 = require("./dragon-phase");
+Object.defineProperty(exports, "DragonPhase", { enumerable: true, get: function () { return dragon_phase_1.DragonPhase; } });
+const dragon_rank_1 = require("./dragon-rank");
+Object.defineProperty(exports, "DragonRank", { enumerable: true, get: function () { return dragon_rank_1.DragonRank; } });

package/dist/enums/island-type.d.ts

@@ -0,0 +1,10 @@
+export declare enum IslandType {
+    FogIslands = "fog_islands",
+    GridIslands = "grid_islands",
+    MazeIslands = "maze_islands",
+    HeroicRaces = "heroic_races",
+    TowerIslands = "tower_islands",
+    PuzzleIslands = "puzzle_islands",
+    RunnerIslands = "runner_islands",
+    ProgressiveIslands = "progressive_islands"
+}

package/dist/enums/island-type.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IslandType = void 0;
+var IslandType;
+(function (IslandType) {
+    IslandType["FogIslands"] = "fog_islands";
+    IslandType["GridIslands"] = "grid_islands";
+    IslandType["MazeIslands"] = "maze_islands";
+    IslandType["HeroicRaces"] = "heroic_races";
+    IslandType["TowerIslands"] = "tower_islands";
+    IslandType["PuzzleIslands"] = "puzzle_islands";
+    IslandType["RunnerIslands"] = "runner_islands";
+    IslandType["ProgressiveIslands"] = "progressive_islands";
+})(IslandType || (exports.IslandType = IslandType = {}));

package/dist/enums/static-file-url-platform-prefix.d.ts

@@ -0,0 +1,7 @@
+export declare enum StaticFileUrlPlatformPrefix {
+    Default = "dci",
+    Android = "dca",
+    iOS = "dci",
+    Windows = "dcw",
+    Amazon = "dcaz"
+}