@dchighs/dbgames 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 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/README.md

@@ -0,0 +1 @@
+# @dchighs/dbgames-scraper

package/dist/client.d.ts

@@ -0,0 +1,10 @@
+export declare const baseUrl = "https://dbgames.info/dragoncity";
+export type FetchOptions = {
+    path: string;
+    params?: Record<string, string | number | boolean | undefined>;
+};
+export declare class Client {
+    private readonly client;
+    constructor();
+    fetch({ path, params }: FetchOptions): Promise<import("@xcrap/extractor").HtmlParser>;
+}

package/dist/client.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = exports.baseUrl = void 0;
+const axios_client_1 = require("@xcrap/axios-client");
+exports.baseUrl = "https://dbgames.info/dragoncity";
+class Client {
+    constructor() {
+        this.client = new axios_client_1.AxiosClient({
+            rateLimit: {
+                maxRPS: 20,
+            },
+        });
+    }
+    async fetch({ path, params }) {
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(params !== null && params !== void 0 ? params : {})) {
+            if (value === undefined)
+                continue;
+            if (key === "p" && Number(value) < 2)
+                continue;
+            query.append(key, String(value));
+        }
+        const url = `${exports.baseUrl}${path}?${query.toString()}`;
+        console.log(url);
+        const response = await this.client.fetch({ url: url });
+        const parser = response.asHtmlParser();
+        return parser;
+    }
+}
+exports.Client = Client;

package/dist/dbgames.d.ts

@@ -0,0 +1,28 @@
+import { Localization } from "@dchighs/dc-localization";
+import { ValueOfEnum } from "./utils";
+import { Alphabet, DragonElement, DragonRarity, DragonstSortBy, OrderBy } from "./enums";
+import { FullDataDragon, DragonsList } from "./interfaces";
+import { Client } from "./client";
+export type DbgamesOptions = {
+    localization: Localization;
+};
+export type GetDragonsOptions = {
+    elements?: ValueOfEnum<DragonElement>[];
+    rarities?: ValueOfEnum<DragonRarity>[];
+    startsWith?: ValueOfEnum<Alphabet>;
+    sortBy?: ValueOfEnum<DragonstSortBy>;
+    orderBy?: ValueOfEnum<OrderBy>;
+    description?: string;
+    page?: number;
+    name?: string;
+};
+export type GetDragonOptions = {
+    slug: string;
+};
+export declare class Dbgames {
+    readonly client: Client;
+    readonly localization: Localization;
+    constructor({ localization }: DbgamesOptions);
+    getDragon({ slug }: GetDragonOptions): Promise<FullDataDragon<true>>;
+    getDragons({ elements, rarities, startsWith, sortBy, page, name, orderBy, description, }: GetDragonsOptions): Promise<DragonsList>;
+}

package/dist/dbgames.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dbgames = void 0;
+const transformer_1 = require("@xcrap/transformer");
+const extractor_1 = require("@xcrap/extractor");
+const utils_1 = require("./utils");
+const dragons_page_model_1 = require("./transforming-models/dragons-page.model");
+const dragon_page_model_1 = require("./transforming-models/dragon-page.model");
+const dragons_page_model_2 = require("./parsing-models/dragons-page.model");
+const dragon_page_model_2 = require("./parsing-models/dragon-page.model");
+const client_1 = require("./client");
+const previewDragonKeysInOrder = [
+    "id",
+    "name",
+    "name_key",
+    "group_type",
+    "hatching_time",
+    "breeding_time",
+    "description",
+    "description_key",
+    "xp",
+    "starting_coins",
+    "coins_added",
+    "dragon_rarity",
+    "attributes",
+    "img_name",
+];
+const fullDataDragonKeysInOrder = [
+    "id",
+    "name",
+    "name_key",
+    "group_type",
+    "hatching_time",
+    "breeding_time",
+    "description",
+    "description_key",
+    "xp",
+    "starting_coins",
+    "coins_added",
+    "dragon_rarity",
+    "attacks",
+    "attributes",
+    "trainable_attacks",
+    "img_name",
+];
+class Dbgames {
+    constructor({ localization }) {
+        this.client = new client_1.Client();
+        this.localization = localization;
+    }
+    async getDragon({ slug }) {
+        const parser = await this.client.fetch({
+            path: `/dragons/${slug}`,
+        });
+        const rawDragon = await parser.extractModel({ model: dragon_page_model_2.dragonPageExtractionModel });
+        const transformer = new transformer_1.Transformer(rawDragon);
+        const transformedDragonData = (await transformer.transform(dragon_page_model_1.dragonPageTransformingModel));
+        const transformedAggregated = {
+            data: {
+                ...transformedDragonData,
+                attacks: transformedDragonData.attacks.map((attack) => {
+                    const attackNameKey = this.localization.getKeyFromValue(attack.name);
+                    if (!attackNameKey) {
+                        throw new Error(`Not found attack name key from: ${attack.name}`);
+                    }
+                    return {
+                        id: (0, utils_1.extractAttackIdFromNameKey)(attackNameKey),
+                        name: attack.name,
+                        name_key: attackNameKey,
+                        type: attack.type,
+                        element: attack.element,
+                        training_time: attack.training_time,
+                        ui_damage: attack.ui_damage,
+                    };
+                }),
+                trainable_attacks: transformedDragonData.trainable_attacks.map((attack) => {
+                    const attackNameKey = this.localization.getKeyFromValue(attack.name);
+                    if (!attackNameKey) {
+                        throw new Error(`Not found attack name key from: ${attack.name}`);
+                    }
+                    return {
+                        id: (0, utils_1.extractAttackIdFromNameKey)(attackNameKey),
+                        name: attack.name,
+                        name_key: attackNameKey,
+                        type: attack.type,
+                        element: attack.element,
+                        training_time: attack.training_time,
+                        ui_damage: attack.ui_damage,
+                    };
+                }),
+            },
+            meta: {
+                pageUrl: `${client_1.baseUrl}/dragons/${slug}`,
+            },
+        };
+        return {
+            data: (0, utils_1.pickKeys)(transformedAggregated.data, fullDataDragonKeysInOrder),
+            meta: transformedAggregated.meta,
+        };
+    }
+    async getDragons({ elements, rarities, startsWith, sortBy, page, name, orderBy, description, }) {
+        var _a;
+        const parser = await this.client.fetch({
+            path: "/dragons",
+            params: {
+                name: name,
+                element: elements === null || elements === void 0 ? void 0 : elements.join(","),
+                rarity: rarities === null || rarities === void 0 ? void 0 : rarities.join(","),
+                startswith: startsWith,
+                sortby: sortBy,
+                sortorder: orderBy,
+                description: description,
+                p: page,
+            },
+        });
+        const rawDragons = await parser.extractModel({ model: dragons_page_model_2.dragonsPageExtractionModel });
+        const pageUrls = await parser.extractValues({
+            query: (0, extractor_1.css)(".result-data .subtitle:first-child a"),
+            extractor: (0, extractor_1.extract)("href"),
+        });
+        const nextPageUrl = await parser.extractValue({
+            query: (0, extractor_1.xpath)("//a[text()='Next >']"),
+            extractor: (0, extractor_1.extract)("href"),
+            default: null,
+        });
+        const lastPageUrl = await parser.extractValue({
+            query: (0, extractor_1.xpath)("//a[contains(text(), 'Last')]"),
+            extractor: (0, extractor_1.extract)("href"),
+            default: null,
+        });
+        const previousPageUrl = await parser.extractValue({
+            query: (0, extractor_1.xpath)("//a[contains(text(), '< Prev')]"),
+            extractor: (0, extractor_1.extract)("href"),
+            default: null,
+        });
+        const currentPageUrl = await parser.extractValue({
+            query: (0, extractor_1.css)("a.active"),
+            extractor: (0, extractor_1.extract)("href"),
+        });
+        const nextPageNumber = (0, utils_1.extractPageNumberFromUrl)(nextPageUrl);
+        const lastPageNumber = (0, utils_1.extractPageNumberFromUrl)(lastPageUrl);
+        const currentPageNumber = (_a = (0, utils_1.extractPageNumberFromUrl)(currentPageUrl)) !== null && _a !== void 0 ? _a : (page && !isNaN(Number(page)) ? Number(page) : 1);
+        const previousPageNumber = (0, utils_1.extractPageNumberFromUrl)(previousPageUrl);
+        const transformer = new transformer_1.Transformer(rawDragons);
+        const transformedDragons = (await transformer.transform(dragons_page_model_1.dragonsPageTransformingModel));
+        const lastPage = lastPageNumber !== null && lastPageNumber !== void 0 ? lastPageNumber : currentPageNumber;
+        const itemsPerPage = 10;
+        return {
+            data: transformedDragons.dragons.map((dragon, i) => ({
+                data: (0, utils_1.pickKeys)(dragon, previewDragonKeysInOrder),
+                meta: {
+                    pageUrl: transformer_1.StringTransformer.resolveUrl(client_1.baseUrl)(pageUrls[i]),
+                },
+            })),
+            meta: {
+                totalEstimated: itemsPerPage * lastPage,
+                lastPage: lastPage,
+                currentPage: currentPageNumber,
+                perPage: itemsPerPage,
+                prev: previousPageNumber,
+                next: nextPageNumber,
+            },
+            params: {
+                elements: elements,
+                rarities: rarities,
+                startsWith: startsWith,
+                sortBy: sortBy,
+                orderBy: orderBy,
+                description: description,
+                name: name,
+            },
+        };
+    }
+}
+exports.Dbgames = Dbgames;

package/dist/enums/alphabet.enum.d.ts

@@ -0,0 +1,28 @@
+export declare enum Alphabet {
+    A = "a",
+    B = "b",
+    C = "c",
+    D = "d",
+    E = "e",
+    F = "f",
+    G = "g",
+    H = "h",
+    I = "i",
+    J = "j",
+    K = "k",
+    L = "l",
+    M = "m",
+    N = "n",
+    O = "o",
+    P = "p",
+    Q = "q",
+    R = "r",
+    S = "s",
+    T = "t",
+    U = "u",
+    V = "v",
+    W = "w",
+    X = "x",
+    Y = "y",
+    Z = "z"
+}

package/dist/enums/alphabet.enum.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alphabet = void 0;
+var Alphabet;
+(function (Alphabet) {
+    Alphabet["A"] = "a";
+    Alphabet["B"] = "b";
+    Alphabet["C"] = "c";
+    Alphabet["D"] = "d";
+    Alphabet["E"] = "e";
+    Alphabet["F"] = "f";
+    Alphabet["G"] = "g";
+    Alphabet["H"] = "h";
+    Alphabet["I"] = "i";
+    Alphabet["J"] = "j";
+    Alphabet["K"] = "k";
+    Alphabet["L"] = "l";
+    Alphabet["M"] = "m";
+    Alphabet["N"] = "n";
+    Alphabet["O"] = "o";
+    Alphabet["P"] = "p";
+    Alphabet["Q"] = "q";
+    Alphabet["R"] = "r";
+    Alphabet["S"] = "s";
+    Alphabet["T"] = "t";
+    Alphabet["U"] = "u";
+    Alphabet["V"] = "v";
+    Alphabet["W"] = "w";
+    Alphabet["X"] = "x";
+    Alphabet["Y"] = "y";
+    Alphabet["Z"] = "z";
+})(Alphabet || (exports.Alphabet = Alphabet = {}));

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

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

package/dist/enums/dragon-element.enum.js

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

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

@@ -0,0 +1,8 @@
+export declare enum DragonRarity {
+    Common = "common",
+    Rare = "rare",
+    VeryRare = "very rare",
+    Epic = "epic",
+    Legendary = "legendary",
+    Heroic = "heroic"
+}

package/dist/enums/dragon-rarity.enum.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonRarity = void 0;
+var DragonRarity;
+(function (DragonRarity) {
+    DragonRarity["Common"] = "common";
+    DragonRarity["Rare"] = "rare";
+    DragonRarity["VeryRare"] = "very rare";
+    DragonRarity["Epic"] = "epic";
+    DragonRarity["Legendary"] = "legendary";
+    DragonRarity["Heroic"] = "heroic";
+})(DragonRarity || (exports.DragonRarity = DragonRarity = {}));

package/dist/enums/dragons-sort-by.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum DragonstSortBy {
+    Name = "name",
+    Id = "id",
+    BreedingTime = "breedingtime",
+    HatchingTime = "hatchingtime",
+    GoldIncome = "earnings",
+    GoldIncomeIncrement = "increase",
+    HatchingExperience = "exp",
+    Rarity = "rarity"
+}

package/dist/enums/dragons-sort-by.enum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonstSortBy = void 0;
+var DragonstSortBy;
+(function (DragonstSortBy) {
+    DragonstSortBy["Name"] = "name";
+    DragonstSortBy["Id"] = "id";
+    DragonstSortBy["BreedingTime"] = "breedingtime";
+    DragonstSortBy["HatchingTime"] = "hatchingtime";
+    DragonstSortBy["GoldIncome"] = "earnings";
+    DragonstSortBy["GoldIncomeIncrement"] = "increase";
+    DragonstSortBy["HatchingExperience"] = "exp";
+    DragonstSortBy["Rarity"] = "rarity";
+})(DragonstSortBy || (exports.DragonstSortBy = DragonstSortBy = {}));

package/dist/enums/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./dragon-rarity.enum";
+export * from "./dragon-element.enum";
+export * from "./alphabet.enum";
+export * from "./dragons-sort-by.enum";
+export * from "./order-by.enum";

package/dist/enums/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dragon-rarity.enum"), exports);
+__exportStar(require("./dragon-element.enum"), exports);
+__exportStar(require("./alphabet.enum"), exports);
+__exportStar(require("./dragons-sort-by.enum"), exports);
+__exportStar(require("./order-by.enum"), exports);

package/dist/enums/order-by.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum OrderBy {
+    Ascending = "asc",
+    Descending = "desc"
+}

package/dist/enums/order-by.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderBy = void 0;
+var OrderBy;
+(function (OrderBy) {
+    OrderBy["Ascending"] = "asc";
+    OrderBy["Descending"] = "desc";
+})(OrderBy || (exports.OrderBy = OrderBy = {}));

package/dist/helpers/regex.helper.d.ts

@@ -0,0 +1,7 @@
+export declare const regexHelper: {
+    dragonId: RegExp;
+    dragonName: RegExp;
+    dragonStartingCoins: RegExp;
+    dragonCoinsIncome: RegExp;
+    dragonAttackId: RegExp;
+};

package/dist/helpers/regex.helper.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regexHelper = void 0;
+exports.regexHelper = {
+    dragonId: /\[(\d+)\]/,
+    dragonName: /^\s*(.+?)\s*\[(\d+)\]\s*$/,
+    dragonStartingCoins: /^(\d+)/,
+    dragonCoinsIncome: /\((\d+)\s*x/,
+    dragonAttackId: /^tid_attack_name_(?<id>\d+)$/,
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./dbgames";
+export * from "./enums";
+export * from "./interfaces";
+export { extractAttackIdFromNameKey, extractDragonPageSlug } from "./utils";

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDragonPageSlug = exports.extractAttackIdFromNameKey = void 0;
+__exportStar(require("./dbgames"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./interfaces"), exports);
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "extractAttackIdFromNameKey", { enumerable: true, get: function () { return utils_1.extractAttackIdFromNameKey; } });
+Object.defineProperty(exports, "extractDragonPageSlug", { enumerable: true, get: function () { return utils_1.extractDragonPageSlug; } });

package/dist/interfaces/dragons-list.interface.d.ts

@@ -0,0 +1,24 @@
+import { Alphabet, DragonElement, DragonRarity, DragonstSortBy, OrderBy } from "../enums";
+import { PreviewDragon } from "./preview-dragon.interface";
+import { ValueOfEnum } from "../utils/value-of-enum.util";
+import { GetDragonsOptions } from "../dbgames";
+export interface DragonsListMeta {
+    elements?: ValueOfEnum<DragonElement>[];
+    rarities?: ValueOfEnum<DragonRarity>[];
+    startsWith?: ValueOfEnum<Alphabet>;
+    sortBy?: ValueOfEnum<DragonstSortBy>;
+    orderBy?: ValueOfEnum<OrderBy>;
+    description?: string;
+    name?: string;
+    totalEstimated: number;
+    lastPage: number;
+    currentPage: number;
+    perPage: number;
+    prev: number | null;
+    next: number | null;
+}
+export interface DragonsList {
+    data: PreviewDragon[];
+    meta: DragonsListMeta;
+    params: GetDragonsOptions;
+}

package/dist/interfaces/dragons-list.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/full-data-dragon.interface.d.ts

@@ -0,0 +1,34 @@
+type Attack<Aggregate extends boolean> = {
+    name: string;
+    type: string;
+    element: string;
+    ui_damage: number;
+    training_time: number;
+} & (Aggregate extends true ? {
+    id: number | null;
+    name_key: string;
+} : {});
+export interface FullDataDragon<Aggregate extends boolean> {
+    data: {
+        id: number;
+        name: string;
+        name_key: string;
+        group_type: string;
+        hatching_time: number;
+        breeding_time: number;
+        description: string;
+        description_key: string;
+        xp: number;
+        starting_coins: number;
+        coins_added: number;
+        dragon_rarity: string;
+        attributes: Array<string>;
+        img_name: string;
+        attacks: Attack<Aggregate>[];
+        trainable_attacks: Attack<Aggregate>[];
+    };
+    meta: {
+        pageUrl: string;
+    };
+}
+export {};

package/dist/interfaces/full-data-dragon.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./preview-dragon.interface";
+export * from "./full-data-dragon.interface";
+export * from "./dragons-list.interface";

package/dist/interfaces/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./preview-dragon.interface"), exports);
+__exportStar(require("./full-data-dragon.interface"), exports);
+__exportStar(require("./dragons-list.interface"), exports);

package/dist/interfaces/preview-dragon.interface.d.ts

@@ -0,0 +1,21 @@
+export interface PreviewDragon {
+    data: {
+        id: number;
+        name: string;
+        name_key: string;
+        group_type: string;
+        hatching_time: number;
+        breeding_time: number;
+        description: string;
+        description_key: string;
+        xp: number;
+        starting_coins: number;
+        coins_added: number;
+        dragon_rarity: string;
+        attributes: Array<string>;
+        img_name: string;
+    };
+    meta: {
+        pageUrl: string;
+    };
+}

package/dist/interfaces/preview-dragon.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });