@everymatrix/player-elevate-points-history-jojogroup 1.80.2

package/dist/collection/components/player-elevate-points-history-jojogroup/player-elevate-points-history-jojogroup.js

@@ -0,0 +1,479 @@
+import { h } from "@stencil/core";
+import { WalletType } from "../../utils/types";
+import { translation } from "../../utils/translation";
+import { getWallets } from "../../utils/business";
+import { renderWallets } from "../../renders/renderWallets";
+import { renderTopBar } from "../../renders/renderTopBar";
+import Decimal from "decimal.js";
+import "../../../../../general-styling-wrapper/dist/types/index";
+import "../../../../../player-elevate-card/dist/types/index";
+import "../../../../../bonus-pagination-limits/dist/types/index";
+import "../../../../../bonus-pagination-nav/dist/types/index";
+export class PlayerElevatePointsHistory {
+    constructor() {
+        this.playerAvatarUrl = undefined;
+        this.session = undefined;
+        this.endpoint = undefined;
+        this.limit = undefined;
+        this.secondaryArrowsActive = true;
+        this.displayPageNumbers = false;
+        this.pageLimitOptions = '10,25,50';
+        this.currencyPrecision = 2;
+        this.enableRakeback = true;
+        this.language = 'en';
+        this.mbSource = undefined;
+        this.clientStyling = '';
+        this.clientStylingUrl = '';
+        this.translationUrl = '';
+        this.locale = translation['en'];
+        this.type = WalletType.spendable;
+        this.pageSetting = undefined;
+        this.pointsWallets = {};
+        this.validWallets = [];
+    }
+    switchTab(type) {
+        var _a, _b;
+        this.type = type;
+        if (this.pointsWallets[type] || !((_a = this.pointsWallets[type]) === null || _a === void 0 ? void 0 : _a.isLoadFailed)) {
+            return;
+        }
+        this.paginationReset.emit({ limit: ((_b = this.pointsWallets[type]) === null || _b === void 0 ? void 0 : _b.pageSetting.limit) || this.limit, tableId: this.type });
+    }
+    getPageSettingByType(type) {
+        return this.pointsWallets[type] ? this.pointsWallets[type].pageSetting : {
+            limit: this.limit, total: 0, offset: 0, tableId: type,
+            secondaryArrowsActive: this.secondaryArrowsActive,
+            displayPageNumbers: this.displayPageNumbers,
+            pageLimitOptions: this.pageLimitOptions || undefined
+        };
+    }
+    loadWallets(renderer) {
+        if (!this.pointsWallets[this.type] || this.pointsWallets[this.type].isLoading) {
+            return h("div", { class: "Loading" }, this.locale.loading);
+        }
+        else {
+            if (this.pointsWallets[this.type].wallets.length === 0) {
+                return (h("div", { class: "NoContent" }, this.locale.noContent));
+            }
+            else {
+                return renderer();
+            }
+        }
+    }
+    componentWillRender() {
+        this.locale = Object.assign(Object.assign({}, translation['en']), translation[this.language]);
+    }
+    render() {
+        var _a, _b;
+        const pageSetting = this.getPageSettingByType(this.type);
+        return (h("main", { key: '6d07a23636d52d8cfd22fa49fd48dc57c2eba8fa' }, h("general-styling-wrapper", { key: 'b541bad336a3867e9d2c8f8d6867c9af53395496', clientStyling: this.clientStyling, clientStylingUrl: this.clientStylingUrl,
+            // @ts-ignore
+            targetTranslations: translation, translationUrl: this.translationUrl, mbSource: this.mbSource }), h("player-elevate-pointcard", { key: '048ec444b3cd9644b4c0850ec3e358fcee24eeea', playerAvatarUrl: this.playerAvatarUrl, endpoint: this.endpoint, session: this.session, language: this.language, clientStylingUrl: this.clientStylingUrl, clientStyling: this.clientStyling, translationUrl: this.translationUrl }), h("div", { key: 'cce18463a5accaaef56cfd2e4e8efed5347662b8', class: "PlayerElevatePointsDetaisContainer" }, [
+            renderTopBar(this.locale, this.type, pageSetting),
+            h("div", { key: 'd68123e5cbbf6a8925edb96d7598c621b102e6cc', class: "Tabs Row" }, (this.validWallets || []).map(key => (h("div", { class: "tab" }, h("div", { class: `TabText ${key === this.type ? 'active' : ''}`, onClick: this.switchTab.bind(this, key) }, this.locale.tabTitle[key]), h("div", { class: `TabBorderBottom ${key === this.type ? 'active' : ''}` }))))),
+            ((_a = this.pointsWallets[this.type]) === null || _a === void 0 ? void 0 : _a.isLoadFailed)
+                ? h("div", { class: "ReloadMsg" }, this.locale['reloadMsgWhenError'], h("a", { class: "Reload", onClick: this.updateWallets }, this.locale['reload']))
+                : this.loadWallets(renderWallets.bind(this, this.locale, ((_b = this.pointsWallets[this.type]) === null || _b === void 0 ? void 0 : _b.wallets) || [], pageSetting))
+        ])));
+    }
+    walletTypeChangedHandler() {
+        //do not reload when loaded tab switched back
+        if (this.pointsWallets[this.type]) {
+            return;
+        }
+        this.updateWallets();
+    }
+    async updateWallets() {
+        if (!this.endpoint || !this.session || this.session === 'undefined') {
+            return;
+        }
+        let pageSetting = this.pointsWallets[this.type]
+            ? this.pointsWallets[this.type].pageSetting
+            : this.getPageSettingByType(this.type);
+        try {
+            const walletsDetail = await getWallets(this.endpoint, this.language, this.type, this.session, pageSetting);
+            const wallets = walletsDetail.data || [];
+            if (walletsDetail.success) {
+                pageSetting.total = walletsDetail.total;
+                if (this.type === WalletType.rakeback) {
+                    this.formatRakebackWalletPoints(wallets);
+                }
+                this.pointsWallets[this.type] = Object.assign(Object.assign({}, this.pointsWallets[this.type]), { wallets,
+                    pageSetting });
+                this.pointsWallets = Object.assign({}, this.pointsWallets);
+            }
+            else {
+                console.error(walletsDetail);
+                this.pointsWallets[this.type].isLoadFailed = true;
+                //pageSetting.total = 0;
+            }
+        }
+        catch (e) {
+            console.error(e);
+            this.pointsWallets[this.type].isLoadFailed = true;
+        }
+    }
+    formatRakebackWalletPoints(wallets) {
+        wallets.forEach(wallet => {
+            const newValue = new Decimal(wallet.points || 0);
+            wallet.pointAsString = newValue.toFixed(this.currencyPrecision, newValue.greaterThan(0)
+                ? Decimal.ROUND_DOWN : Decimal.ROUND_CEIL);
+        });
+    }
+    reloadPageByTypeHandler(event) {
+        if (event.detail.tableId != this.type) {
+            return;
+        }
+        //reset all wallets when limit changed
+        //otherwise fetch new data with new offset when offset changed
+        if (this.limit != event.detail.limit) {
+            this.pointsWallets = {};
+            this.limit = event.detail.limit;
+        }
+        else {
+            let pageSetting = this.pointsWallets[this.type].pageSetting || this.getPageSettingByType(this.type);
+            pageSetting.offset = event.detail.offset;
+            this.pointsWallets[this.type].pageSetting = pageSetting;
+        }
+        this.updateWallets();
+    }
+    setLimit() {
+        try {
+            const pageLimits = this.pageLimitOptions.split(',').map((item) => {
+                return parseInt(item);
+            });
+            if (pageLimits.includes(this.limit)) {
+                //do nothing
+            }
+            else {
+                this.limit = pageLimits[0];
+            }
+        }
+        catch (e) {
+            console.error('Error when parse PageLimitOptions', e);
+            this.limit = 10;
+        }
+    }
+    async componentWillLoad() {
+        this.setLimit();
+        this.updateWallets();
+        // only show rakeback tab
+        this.validWallets = this.enableRakeback ? [WalletType.rakeback] : [];
+        this.type = WalletType.rakeback;
+    }
+    static get is() { return "player-elevate-points-history-jojogroup"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["player-elevate-points-history-jojogroup.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["player-elevate-points-history-jojogroup.css"]
+        };
+    }
+    static get assetsDirs() { return ["static"]; }
+    static get properties() {
+        return {
+            "playerAvatarUrl": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "player avatar url"
+                },
+                "attribute": "player-avatar-url",
+                "reflect": true
+            },
+            "session": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "User Session"
+                },
+                "attribute": "session",
+                "reflect": true
+            },
+            "endpoint": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Endpoint URL for the source of data"
+                },
+                "attribute": "endpoint",
+                "reflect": true
+            },
+            "limit": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "User Session"
+                },
+                "attribute": "limit",
+                "reflect": true
+            },
+            "secondaryArrowsActive": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Customize pagination: Activate pagination secondary arrows"
+                },
+                "attribute": "secondary-arrows-active",
+                "reflect": true,
+                "defaultValue": "true"
+            },
+            "displayPageNumbers": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Customize pagination: Activate pagination numbered navigation"
+                },
+                "attribute": "display-page-numbers",
+                "reflect": true,
+                "defaultValue": "false"
+            },
+            "pageLimitOptions": {
+                "type": "string",
+                "mutable": true,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Customize page list options, default: 10,25,50"
+                },
+                "attribute": "page-limit-options",
+                "reflect": true,
+                "defaultValue": "'10,25,50'"
+            },
+            "currencyPrecision": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Customize currency precision for rakeback, default: 2"
+                },
+                "attribute": "currency-precision",
+                "reflect": true,
+                "defaultValue": "2"
+            },
+            "enableRakeback": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Customize if show the rakeback tab"
+                },
+                "attribute": "enable-rakeback",
+                "reflect": true,
+                "defaultValue": "true"
+            },
+            "language": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Language of the widget"
+                },
+                "attribute": "language",
+                "reflect": true,
+                "defaultValue": "'en'"
+            },
+            "mbSource": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Client custom styling via streamStyling"
+                },
+                "attribute": "mb-source",
+                "reflect": true
+            },
+            "clientStyling": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Client custom styling via string"
+                },
+                "attribute": "client-styling",
+                "reflect": true,
+                "defaultValue": "''"
+            },
+            "clientStylingUrl": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Client custom styling via url"
+                },
+                "attribute": "client-styling-url",
+                "reflect": true,
+                "defaultValue": "''"
+            },
+            "translationUrl": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "translation via url"
+                },
+                "attribute": "translation-url",
+                "reflect": true,
+                "defaultValue": "''"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "locale": {},
+            "type": {},
+            "pageSetting": {},
+            "pointsWallets": {},
+            "validWallets": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "paginationReset",
+                "name": "paginationReset",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }];
+    }
+    static get watchers() {
+        return [{
+                "propName": "type",
+                "methodName": "walletTypeChangedHandler"
+            }, {
+                "propName": "endpoint",
+                "methodName": "updateWallets"
+            }, {
+                "propName": "language",
+                "methodName": "updateWallets"
+            }, {
+                "propName": "session",
+                "methodName": "updateWallets"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "reloadPageByType",
+                "method": "reloadPageByTypeHandler",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}

package/dist/collection/index.js

@@ -0,0 +1 @@
+export * from './components';

package/dist/collection/renders/renderTabs.js

@@ -0,0 +1,9 @@
+import { h } from "@stencil/core";
+import { WalletType } from "../utils/types";
+export const renderTabs = (locale, type, onChangeTab) => h("div", { class: "Tabs Row" }, Object.keys(WalletType).map(key => {
+    const isActive = key === type;
+    const cssActive = isActive ? 'active' : '';
+    return (h("div", null, h("div", { class: `TabText ${cssActive}`, onClick: () => {
+            onChangeTab(key);
+        } }, locale.tabTitle[key]), h("div", { class: `TabBorderBottom ${cssActive}` })));
+}));

package/dist/collection/renders/renderTopBar.js

@@ -0,0 +1,4 @@
+import { h } from "@stencil/core";
+import backSvg from "../static/back.svg";
+import menuSvg from "../static/menu.svg";
+export const renderTopBar = (locale, type, pageSetting) => h("div", { class: "TopBarContainer" }, h("div", { class: "BackImageContainer" }, h("span", { class: "BackImage", innerHTML: backSvg })), h("div", { class: "TitleContainer" }, h("div", { class: "Title", title: locale.barTitle[type] }, locale.barTitle[type]), h("div", { class: 'Limits' }, h("bonus-pagination-limits", { pageLimitOptions: pageSetting.pageLimitOptions, limit: pageSetting.limit }))), h("div", null, h("span", { class: "MenuImage", innerHTML: menuSvg })));

package/dist/collection/renders/renderWallets.js

@@ -0,0 +1,43 @@
+import { Fragment, h } from "@stencil/core";
+import { WalletType } from "../utils/types";
+export const WalletItem = ({ locale, wallet, walletType, isRakeback }) => {
+    if (walletType === WalletType.history) {
+        return h("div", { class: "RecordContainer" }, wallet.payload &&
+            h("div", { class: "Row" }, h("div", { class: "Title" }, wallet.payload.displayName), h("div", { class: `Amount ${getAmountConfig(wallet.points).class}` }, h("span", { class: "HistoryPoints" }, Math.abs(wallet.points), " ", locale.coins))), h("div", { class: "Row" }, h("div", { class: wallet.payload ? 'PointType' : 'Title' }, locale.pointType[wallet.pointType] || wallet.pointType), !wallet.payload &&
+            h("div", { class: `Amount ${getAmountConfig(wallet.points).class}` }, h("span", { class: "HistoryPoints" }, Math.abs(wallet.points), " ", locale.coins))), h("div", { class: "Row" }, h("div", { class: "DateTime" }, formatDate(new Date(wallet.modified)))));
+    }
+    else {
+        return (h("div", { class: "RecordContainer" }, h("div", { class: `Row ${wallet.pointType}` }, h("div", { class: "Title" }, (isRakeback ? locale.rakebackPointType[wallet.pointType] : locale.pointType[wallet.pointType]) || wallet.pointType), h("div", { class: `Amount ${getAmountConfig(wallet.points).class}` }, h("span", { class: "Points" }, getAmountConfig(wallet.points).symbol, " ", isRakeback ? wallet.pointAsString : wallet.points, " "), isRakeback && h("span", null, " ", wallet.currency))), h("div", { class: "Row" }, h("div", { class: "DateTime" }, formatDate(new Date(wallet.modified))))));
+    }
+};
+export const renderWallets = (locale, wallets, pageSetting) => wallets && (h(Fragment, null, h("div", { class: "Records" }, wallets.map(wallet => h(WalletItem, { locale: locale, wallet: wallet, walletType: pageSetting.tableId, isRakeback: pageSetting.tableId === WalletType.rakeback }))), h("div", { class: "PaginationContainer" }, h("bonus-pagination-nav", { offset: pageSetting.offset, limit: pageSetting.limit, displayPageNumbers: pageSetting.displayPageNumbers, tableId: pageSetting.tableId, secondaryArrowsActive: pageSetting.secondaryArrowsActive, total: pageSetting.total }))));
+const getAmountConfig = (amount) => {
+    if (amount > 0) {
+        return {
+            class: 'Positive',
+            symbol: '+'
+        };
+    }
+    else {
+        return {
+            class: 'Negative',
+            symbol: ''
+        };
+    }
+};
+const padTo2Digits = (num) => {
+    return num.toString().padStart(2, '0');
+};
+const formatDate = (date) => {
+    return ([
+        date.getFullYear(),
+        padTo2Digits(date.getMonth() + 1),
+        padTo2Digits(date.getDate()),
+    ].join('-') +
+        ' ' +
+        [
+            padTo2Digits(date.getHours()),
+            padTo2Digits(date.getMinutes()),
+            padTo2Digits(date.getSeconds()),
+        ].join(':'));
+};

package/dist/collection/static/back.svg

@@ -0,0 +1,3 @@
+<svg width="9" height="15" viewBox="0 0 9 15" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.75 1L1.25 7.5L7.75 14" stroke="#242424" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/dist/collection/static/menu.svg

@@ -0,0 +1,5 @@
+<svg width="30" height="8" viewBox="0 0 30 8" fill="none" xmlns="http://www.w3.org/2000/svg">
+<circle cx="4" cy="4" r="4" fill="black"/>
+<circle cx="15" cy="4" r="4" fill="black"/>
+<circle cx="26" cy="4" r="4" fill="black"/>
+</svg>

package/dist/collection/utils/business.js

@@ -0,0 +1,17 @@
+import { fetcher, getUrl } from "./fetch";
+import { WalletType } from "./types";
+export const getWallets = async (endpoint, language, type, session, pageSetting) => {
+    const params = {
+        type,
+        language,
+        pagination: `offset=${pageSetting.offset},limit=${pageSetting.limit}`
+    };
+    const url = getUrl(endpoint + getUriByWalletType(params.type), params);
+    const res = await fetcher(url, {
+        headers: {
+            'x-SessionId': session
+        }
+    });
+    return res;
+};
+const getUriByWalletType = (type) => `/v1/elevate/${type == WalletType.history ? 'redeemHistory' : 'pointsHistory'}`;

package/dist/collection/utils/fetch.js

@@ -0,0 +1,17 @@
+export const getUrl = (path, params = {}) => {
+    return path + '?' + Object.keys(params).map(key => `${key}=${params[key]}`).join('&');
+};
+export const fetcher = async (input, init = {}) => {
+    let res;
+    // @ts-ignore
+    res = await fetch(input, init);
+    res = await res.text();
+    try {
+        res = JSON.parse(res);
+    }
+    catch (e) {
+        console.error(e);
+        throw e;
+    }
+    return res;
+};

package/dist/collection/utils/translation.js

@@ -0,0 +1,62 @@
+export const translation = {
+    "en": {
+        "tabTitle": {
+            "spendable": "Coins",
+            "loyalty": "XP",
+            "history": "Shop Purchases",
+            "rakeback": "Rakeback"
+        },
+        "barTitle": {
+            "spendable": "Coins History",
+            "loyalty": "Experience Points History",
+            "history": "Shop Purchases",
+            "rakeback": "Rakebake History"
+        },
+        "bonus": "Bonus",
+        "coins": "Coins",
+        "noContent": "No Content",
+        "loading": "Loading",
+        "redeem": "Redeem",
+        "reload": "Reload",
+        "reloadMsgWhenError": "Network Problem, please ",
+        "rakebackPointType": {
+            "wageringByRealMoney": "Rakeback Casino Real Wager",
+            "bonus": "Rakeback Claim",
+            "vendor2User": "Rakeback Claim",
+            "cancelledWageringByRealMoney": "Cancelled Rakeback Casino Real Wager"
+        },
+        "pointType": {
+            "registration": "Registration",
+            "cancelledRegistration": "Cancelled Registration",
+            "expiredRegistration": "Expired Registration",
+            "manual": "Manual",
+            "cancelledManual": "Cancelled Manual",
+            "expiredManual": "Expired Manual",
+            "wageringByRealMoney": "Real Money Wager",
+            "wageringByBonusMoney": "Bonus Money Wager",
+            "cancelledWageringByRealMoney": "Cancelled Real Money Wager",
+            "cancelledWageringByBonusMoney": "Cancelled Bonus Money Wager",
+            "expiredWageringByRealMoney": "Expired Real Money Wager",
+            "expiredWageringByBonusMoney": "Expired Bonus Money Wager",
+            "levelExpired": "Level Expiration",
+            "bonus": "Bonus Redeem",
+            "manualByTournament": "Reward from Tournaments",
+            "manualByPrizeEngine": "Reward from PrizeEngine",
+            "manualByMission": "Reward from Mission",
+            "manualByChallenge": "Reward from Challenge",
+            "cancelledManualByTournament": "Cancelled Reward from Tournaments",
+            "cancelledManualByMission": "Cancelled Reward from Mission",
+            "cancelledManualByChallenge": "Cancelled Reward from Challenge",
+            "expiredManualByTournament": "Expired Reward from Tournaments",
+            "expiredManualByMission": "Expired Reward from Mission",
+            "expiredManualByChallenge": "Expired Reward from Challenge",
+            "cancelledManualByPrizeEngine": "Cancelled Reward from PrizeEngine",
+            "expiredManualByPrizeEngine": "Expired Reward from PrizeEngine",
+            "prizeEngine": "PrizeEngine Redeem",
+            "tournamentTicket": "Tournament Ticket Redeem",
+            "physicalItem": "Custom Reward Redeem",
+            "role": "Role Assignment Redeem"
+        },
+        "tr": {}
+    }
+};

package/dist/collection/utils/types.js

@@ -0,0 +1,7 @@
+export var WalletType;
+(function (WalletType) {
+    WalletType["spendable"] = "spendable";
+    WalletType["loyalty"] = "loyalty";
+    WalletType["history"] = "history";
+    WalletType["rakeback"] = "rakeback";
+})(WalletType || (WalletType = {}));