meemup-library 1.0.12 → 1.0.13

package/lib/controllers/ProductModalController.js

@@ -0,0 +1,440 @@
+import EnumOrderType from "../enums/EnumOrderType";
+import EnumSortMode from "../enums/EnumSortMode";
+import EnumPizzaSide from "../enums/EnumPizzaSide";
+import MoneyController from "./MoneyController";
+export default new class ProductModalController {
+    constructor() {
+        this.singleSelectExtraItemPrice = (extra, base, item) => {
+            var _a, _b, _c;
+            let p = item.price;
+            if (extra.numberOfFreeItems > 0)
+                return 0;
+            if (base[1] && ((_a = base[1]) === null || _a === void 0 ? void 0 : _a.increasingOtherExtraItemsPrice)) {
+                // @ts-ignore
+                if (+((_b = base[0]) === null || _b === void 0 ? void 0 : _b.extraId) === +extra.id)
+                    return item.price;
+                // @ts-ignore
+                const { increasingPriceType, increasingAmount, increasingPercentage } = (_c = base[0]) === null || _c === void 0 ? void 0 : _c.selected[0];
+                switch (increasingPriceType) {
+                    case 1:
+                        p += (item.price * increasingPercentage) / 100;
+                        break;
+                    case 2:
+                        p += increasingAmount;
+                        if (p < 0)
+                            p = 0;
+                        break;
+                    default:
+                        break;
+                }
+            }
+            return p;
+        };
+        this.multiSelectExtraPrice = (extra, base, item, selectedList = []) => {
+            var _a, _b, _c;
+            let _item = selectedList.find(i => i.id === item.id);
+            if (_item !== undefined) {
+                let p = +item.price;
+                if (base[1] && ((_a = base[1]) === null || _a === void 0 ? void 0 : _a.increasingOtherExtraItemsPrice)) {
+                    // @ts-ignore
+                    if (+((_b = base[0]) === null || _b === void 0 ? void 0 : _b.extraId) === +extra.id)
+                        return p;
+                    // @ts-ignore
+                    const { increasingPriceType, increasingAmount, increasingPercentage } = (_c = base[0]) === null || _c === void 0 ? void 0 : _c.selected[0];
+                    switch (increasingPriceType) {
+                        case 1:
+                            p += (item.price * increasingPercentage) / 100;
+                            break;
+                        case 2:
+                            p += increasingAmount;
+                            if (p < 0)
+                                p = 0;
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                if (extra.choosablePizzaToppingsSides) {
+                    if (this.scaleSum(selectedList) <= extra.numberOfFreeItems)
+                        return 0;
+                    let index = selectedList.findIndex((element) => +element.id === +item.id);
+                    if (index === -1)
+                        return p;
+                    let sliceArray = selectedList.slice(0, index + 1);
+                    if (this.scaleSum(sliceArray) <= extra.numberOfFreeItems)
+                        return 0;
+                }
+                p = (+p) * _item.quantity;
+                if (_item.pizzaSide === EnumPizzaSide.left || _item.pizzaSide === EnumPizzaSide.right)
+                    return MoneyController.round(p / 2);
+                return p;
+            }
+            return 0;
+        };
+        this.extraItemsSortAction = (a, b) => {
+            if (a.priority == b.priority)
+                return 0;
+            else if (a.priority > b.priority)
+                return 1;
+            else
+                return -1;
+        };
+    }
+    getExtraSelectedItems(list, extraId) {
+        let item = list.find(i => +i.extraId === extraId);
+        if (item)
+            return item.selected;
+        return [];
+    }
+    canAddToBasket(product, selected, extras) {
+        let flag = true;
+        product.extras.forEach((item) => {
+            let extra = extras.find(i => i.id === item.extraId);
+            if (extra && extra.required && (item.secondExtraId === null || selected.find(i => i.extraId === item.secondExtraId))) {
+                if (item.secondExtraId === null ||
+                    selected.find((i) => i.extraId === item.secondExtraId &&
+                        i.selected.find((j) => j.id === item.secondExtraItemId))) {
+                    if (selected.find((i) => i.extraId === item.extraId) === undefined) {
+                        flag = false;
+                    }
+                }
+            }
+        });
+        return flag;
+    }
+    productModalToBasketItem(product, selectedExtraList, extras, count, price, note) {
+        let list = this.sortByKey(selectedExtraList, "priority", product.chosenExtraItemsMode === EnumSortMode.BASED_ON_EXTRA_ITEMS_LIST)
+            .map((item) => {
+            if (product.chosenExtraItemsMode === EnumSortMode.BASED_ON_EXTRA_ITEMS_LIST)
+                item.selected = this.sortByKey(item.selected, "priority");
+            return item;
+        });
+        let extraItemList = [];
+        let itemIndex = 0;
+        list.forEach((extra) => {
+            extra.selected.forEach((extraItem) => {
+                var _a;
+                extraItemList.push({
+                    id: itemIndex++,
+                    extraId: extra.extraId,
+                    extraItemId: extraItem.id,
+                    totalAmount: extraItem.quantity * extraItem.price,
+                    quantity: extraItem.quantity,
+                    price: extraItem.price,
+                    pizzaSide: extraItem.pizzaSide,
+                    text: `${extraItem.quantity}x ${extraItem.title}`,
+                    cartItemId: -1,
+                    extraItemTitle: extraItem.title,
+                    extraTitle: ((_a = extras.find(i => i.id === extra.extraId)) === null || _a === void 0 ? void 0 : _a.title) + ""
+                });
+            });
+        });
+        return {
+            id: -1,
+            productId: product.id,
+            title: this.productName(product),
+            imageUrl: this.productImage(product),
+            price: MoneyController.round(price),
+            extras: extraItemList,
+            quantity: count,
+            totalAmount: MoneyController.round(count * price),
+            note: note,
+            maxOrderQuantity: product.maxOrderQuantity,
+            minOrderQuantity: product.minOrderQuantity,
+            extrasNames: extraItemList.map(i => i.text).join(", "),
+            promotionId: -1,
+            promotionItem: false,
+            relatedItemId: null,
+            relatedProductId: null,
+            additionalText: "",
+            stampCardBonusItem: false
+        };
+    }
+    productName(product) {
+        return product.posName === "" ? product.name : product.posName;
+    }
+    productImage(product) {
+        return product.imageName === null ? "" : product.imageName;
+    }
+    productPrice(product, orderType) {
+        switch (orderType) {
+            case EnumOrderType.delivery:
+                return product.deliveryPrice;
+            case EnumOrderType.pickup:
+                return product.pickupPrice;
+            case EnumOrderType.dining:
+                return product.diningPrice;
+            default:
+                return 0;
+        }
+    }
+    baseItem(list, extraList) {
+        let idList = list.map(i => i.extraId);
+        let productExtraList = extraList.filter(i => idList.includes(i.id) && i.increasingOtherExtraItemsPrice);
+        if (productExtraList.length > 0)
+            return [list.find(i => { var _a; return i.extraId === ((_a = productExtraList[0]) === null || _a === void 0 ? void 0 : _a.id); }), productExtraList[0]];
+        return [undefined, undefined];
+    }
+    defaultExtraOfProductToSelectedExtras(product, extras) {
+        let list = [];
+        let productDefaultExtraModel = product.defaultExtraItems;
+        let productExtraModelList = product.extras;
+        productDefaultExtraModel.forEach((value) => {
+            let item = productExtraModelList.find(i => i.extraId === value.extraId);
+            if (item) {
+                let extraModel = extras.find(i => i.id === (item === null || item === void 0 ? void 0 : item.extraId));
+                let selectedList = [];
+                if (extraModel !== undefined) {
+                    value.items.forEach(it => {
+                        let extraItemModel = extraModel.items.find((i) => i.id === it.extraItemId);
+                        if (extraItemModel !== undefined) {
+                            selectedList.push({
+                                priority: it.priority,
+                                quantity: it.quantity,
+                                pizzaSide: it.side,
+                                id: it.extraItemId,
+                                min: extraItemModel.min,
+                                increasingPriceType: extraItemModel.increasingPriceType,
+                                scale: extraItemModel.scale,
+                                isDefaultSelected: extraItemModel.isDefaultSelected,
+                                title: extraItemModel.title,
+                                max: extraItemModel.max,
+                                calories: extraItemModel.calories,
+                                price: extraItemModel.price,
+                                available: extraItemModel.available,
+                                receiptTitle: extraItemModel.receiptTitle,
+                                increasingAmount: extraItemModel.increasingAmount,
+                                increasingPercentage: extraItemModel.increasingPercentage
+                            });
+                        }
+                    });
+                }
+                let newItem = {
+                    extraId: item.extraId,
+                    selected: selectedList,
+                    showTypeText: item.showTypeText,
+                    secondExtraId: item.secondExtraId,
+                    priority: item.priority,
+                    showType: item.showType,
+                    availableTypeText: item.availableTypeText,
+                    secondExtraItemId: item.secondExtraItemId,
+                    availableType: item.availableType
+                };
+                list.push(newItem);
+            }
+        });
+        return list;
+    }
+    defaultExtraOfProductToBasketItem(product, extras, orderType) {
+        let list = this.defaultExtraOfProductToSelectedExtras(product, extras);
+        let base = [undefined, undefined];
+        let count = product.minOrderQuantity;
+        let price = this.calculatePrice(orderType, product, list, base, extras);
+        return this.productModalToBasketItem(product, list, extras, count, price, "");
+    }
+    multiSelectExtraItemOptions(item, max, selectedList) {
+        let currentCount = this.quantitySum(selectedList.filter(i => i.id !== item.id));
+        let remind = max - currentCount;
+        let maxOption = remind < item.max ? remind : item.max;
+        let list = [];
+        for (let index = item.min; index <= maxOption; index++) {
+            list.push({
+                text: index + "X",
+                value: index
+            });
+        }
+        return list;
+    }
+    // pizzaSelectExtraPrice = (extra: IDExtra, base: TBaseExtra, item: IDExtraItem, selectedList: ISelectedExtraItem[] = []) => {
+    //
+    //   let _item: ISelectedExtraItem | undefined = selectedList.find(i => i.id === item.id);
+    //
+    //   if (_item !== undefined) {
+    //
+    //     let p: number = +item.price;
+    //
+    //     if (base[1] && base[1]?.increasingOtherExtraItemsPrice) {
+    //       // @ts-ignore
+    //       if (+base[0]?.extraId === +extra.id) return p;
+    //
+    //       // @ts-ignore
+    //       const { increasingPriceType, increasingAmount, increasingPercentage } = base[0]?.selected[0];
+    //
+    //       switch (increasingPriceType) {
+    //         case 1:
+    //           p += (item.price * increasingPercentage) / 100;
+    //           break;
+    //         case 2:
+    //           p += increasingAmount;
+    //           if (p < 0) p = 0;
+    //           break;
+    //         default:
+    //           break;
+    //       }
+    //     }
+    //
+    //     if (extra.choosablePizzaToppingsSides) {
+    //       if (this.scaleSum(selectedList) <= extra.numberOfFreeItems)
+    //         return 0;
+    //
+    //       let index = selectedList.findIndex((element) => +element.id === +item.id);
+    //
+    //       if (index === -1)
+    //         return p;
+    //
+    //       let sliceArray = selectedList.slice(0, index + 1);
+    //
+    //       if (this.scaleSum(sliceArray) <= extra.numberOfFreeItems)
+    //         return 0;
+    //
+    //     }
+    //
+    //     return +p;
+    //   }
+    //   return 0;
+    // };
+    // scalePizzaSum(array: ISelectedExtraItem[] = []) {
+    //   let s = 0;
+    //   array.forEach((item) => {
+    //     s += item["quantity"] * item["scale"];
+    //     if (item.pizzaSide === EnumPizzaSide.right || item.pizzaSide === EnumPizzaSide.left)
+    //       s = parseInt((s / 2) + "");
+    //
+    //   });
+    //   return s;
+    // }
+    scaleSum(array = []) {
+        let s = 0;
+        array.forEach((item) => {
+            let weight = item["quantity"] * item["scale"];
+            if (item.pizzaSide === EnumPizzaSide.right || item.pizzaSide === EnumPizzaSide.left)
+                weight = parseInt((weight / 2) + "");
+            s += weight;
+        });
+        return s;
+    }
+    calculatePrice(orderType, product, list, base, extraList) {
+        var _a, _b;
+        let p = 0;
+        for (let i = 0; i < list.length; i++) {
+            const { selected, extraId } = list[i];
+            let _extra = extraList.find(i => i.id === extraId);
+            let free = 0;
+            for (let j = 0; j < selected.length; j++) {
+                const { price, quantity, scale, pizzaSide } = selected[j];
+                let pep = 0;
+                for (let k = 0; k < quantity; k++) {
+                    // @ts-ignore
+                    if (free < (_extra === null || _extra === void 0 ? void 0 : _extra.numberOfFreeItems)) {
+                        free += scale;
+                    }
+                    else {
+                        let ep = 0;
+                        switch (pizzaSide) {
+                            case EnumPizzaSide.left:
+                                //left
+                                ep = price / 2;
+                                break;
+                            case EnumPizzaSide.right:
+                                //right
+                                ep = price / 2;
+                                break;
+                            case EnumPizzaSide.all:
+                                //all
+                                ep = price;
+                                break;
+                            default:
+                                //unknown
+                                ep = price;
+                                break;
+                        }
+                        if (base[0] && +((_a = base[0]) === null || _a === void 0 ? void 0 : _a.extraId) !== +extraId) {
+                            const { increasingPriceType, increasingAmount, increasingPercentage } = (_b = base[0]) === null || _b === void 0 ? void 0 : _b.selected[0];
+                            switch (increasingPriceType) {
+                                case 1:
+                                    ep += ep * (increasingPercentage / 100);
+                                    break;
+                                case 2:
+                                    ep += increasingAmount;
+                                    if (ep < 0)
+                                        ep = 0;
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                        pep += ep;
+                    }
+                }
+                p += MoneyController.round(pep);
+                // console.log(selected[j].title, " : ", pep, " ==> ", MoneyController.round(pep));
+            }
+        }
+        return MoneyController.round(p + this.productPrice(product, +orderType));
+    }
+    plusString(first, second) {
+        return `${first} ${second}`;
+    }
+    getValidateExtras(extras, extraSelected) {
+        let result = [];
+        extras.forEach(item => {
+            if (item.secondExtraId === null ||
+                (extraSelected.filter((i) => i.extraId === item.secondExtraId).length === 1 &&
+                    extraSelected
+                        .filter((i) => i.extraId === item.secondExtraId)[0]
+                        .selected.filter((i) => i.id === item.secondExtraItemId).length === 1)) {
+                result.push(item);
+            }
+        });
+        return result;
+    }
+    getProductExtras(pExtras, sExtras, extras) {
+        let se = this.sortByKey(sExtras, "priority", true);
+        let pe = this.sortByKey(pExtras, "priority", true);
+        let itemsIdList = this.getValidateExtras(pe, se).map(i => i.extraId);
+        // let list: IDExtra[] = extras.filter(i => itemsIdList.includes(+i.id));
+        let result = [];
+        itemsIdList.forEach((id) => {
+            let ext = extras.find(i => i.id === id);
+            if (ext)
+                result.push(ext);
+        });
+        return result;
+    }
+    quantitySum(array = []) {
+        let s = 0;
+        array.forEach((item) => {
+            s += item.quantity;
+        });
+        return s;
+    }
+    // createSubtitle(items: ISelectedExtraItem[] = []): string {
+    //   if (items.length === 1) {
+    //     let { title, quantity } = items[0];
+    //     return (quantity > 1 ? quantity + "x " : "") + title;
+    //   } else if (items.length > 1) {
+    //     return this.quantitySum(items) + " Item selected";
+    //   } else {
+    //     return "";
+    //   }
+    // };
+    productMinAndMaxOptions(product) {
+        let list = [];
+        for (let index = product.minOrderQuantity; index <= product.maxOrderQuantity; index++) {
+            list.push({
+                text: index + "X",
+                value: index
+            });
+        }
+        return list;
+    }
+    sortByKey(array, key, conditionForSort = true) {
+        if (conditionForSort && Array.isArray(array))
+            return array.sort((a, b) => {
+                let x = a[key];
+                let y = b[key];
+                return ((x < y) ? -1 : ((x > y) ? 1 : 0));
+            });
+        return array;
+    }
+}();

package/lib/controllers/ToolController.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    createOption(start: number, length: number, step?: number): number[];
+    convert_10_to_2(source: number): string;
+    find_number_to_2(source: number, value: number): boolean;
+};
+export default _default;

package/lib/controllers/ToolController.js

@@ -0,0 +1,22 @@
+export default new class ToolController {
+    createOption(start, length, step = 1) {
+        let list = [];
+        for (let index = start; index < start + length; index += step)
+            list.push(index);
+        return list;
+    }
+    convert_10_to_2(source) {
+        let result = "";
+        if (source > 1)
+            result += this.convert_10_to_2(parseInt((source / 2) + ""));
+        result += parseInt((source % 2) + "") + "";
+        return result;
+    }
+    ;
+    find_number_to_2(source, value) {
+        let list = this.convert_10_to_2(source).split("").reverse(); //[1,0,0,1,0,1,0,1]
+        let result = list.findIndex((i, index) => i === "1" && Math.pow(2, index) === value);
+        // console.log(`source : ${source} \t value : ${value} \t result : ${result} \t mabna : ${list}`);
+        return result !== -1;
+    }
+}();

package/lib/controllers/ZoneController.d.ts

@@ -0,0 +1,13 @@
+import ILocation from "../interfaces/ILocation";
+declare const _default: {
+    /**
+     * Performs the even-odd-rule Algorithm (a raycasting algorithm) to find out whether a point is in a given polygon.
+     * This runs in O(n) where n is the number of edges of the polygon.
+     *
+     * @param {Array} polygon an array representation of the polygon where polygon[i][0] is the x Value of the i-th point and polygon[i][1] is the y Value.
+     * @param {Array} point   an array representation of the point where point[0] is its x Value and point[1] is its y Value
+     * @return {boolean} whether the point is in the polygon (not on the edge, just turn < into <= and > into >= for that)
+     */
+    pointInPolygon(polygon: ILocation[], point: ILocation): boolean;
+};
+export default _default;

package/lib/controllers/ZoneController.js

@@ -0,0 +1,22 @@
+export default new class ZoneController {
+    /**
+     * Performs the even-odd-rule Algorithm (a raycasting algorithm) to find out whether a point is in a given polygon.
+     * This runs in O(n) where n is the number of edges of the polygon.
+     *
+     * @param {Array} polygon an array representation of the polygon where polygon[i][0] is the x Value of the i-th point and polygon[i][1] is the y Value.
+     * @param {Array} point   an array representation of the point where point[0] is its x Value and point[1] is its y Value
+     * @return {boolean} whether the point is in the polygon (not on the edge, just turn < into <= and > into >= for that)
+     */
+    pointInPolygon(polygon, point) {
+        let odd = false;
+        for (let i = 0, j = polygon.length - 1; i < polygon.length; i++) {
+            if ((((+polygon[i].longitude) > point.longitude) !== ((+polygon[j].longitude) > point.longitude))
+                && (point.latitude < (((+polygon[j].latitude) - (+polygon[i].latitude)) * (point.longitude - (+polygon[i].longitude)) / ((+polygon[j].longitude) - (+polygon[i].longitude)) + (+polygon[i].latitude)))) {
+                odd = !odd;
+            }
+            j = i;
+        }
+        return odd;
+    }
+    ;
+}();

package/lib/enums/EnumBasketStep.d.ts

@@ -0,0 +1,5 @@
+declare enum EnumBasketStep {
+    item = 0,
+    config = 1
+}
+export default EnumBasketStep;

package/lib/enums/EnumBasketStep.js

@@ -0,0 +1,6 @@
+var EnumBasketStep;
+(function (EnumBasketStep) {
+    EnumBasketStep[EnumBasketStep["item"] = 0] = "item";
+    EnumBasketStep[EnumBasketStep["config"] = 1] = "config";
+})(EnumBasketStep || (EnumBasketStep = {}));
+export default EnumBasketStep;

package/lib/enums/EnumCategoryAvailableIn.d.ts

@@ -0,0 +1,7 @@
+declare enum EnumCategoryAvailableIn {
+    EVERY_WHERE = 1,
+    SHOP_APP_ONLY = 2,
+    POS_ONLY = 3,
+    GOOGLE_ORDERING = 4
+}
+export default EnumCategoryAvailableIn;

package/lib/enums/EnumCategoryAvailableIn.js

@@ -0,0 +1,8 @@
+var EnumCategoryAvailableIn;
+(function (EnumCategoryAvailableIn) {
+    EnumCategoryAvailableIn[EnumCategoryAvailableIn["EVERY_WHERE"] = 1] = "EVERY_WHERE";
+    EnumCategoryAvailableIn[EnumCategoryAvailableIn["SHOP_APP_ONLY"] = 2] = "SHOP_APP_ONLY";
+    EnumCategoryAvailableIn[EnumCategoryAvailableIn["POS_ONLY"] = 3] = "POS_ONLY";
+    EnumCategoryAvailableIn[EnumCategoryAvailableIn["GOOGLE_ORDERING"] = 4] = "GOOGLE_ORDERING";
+})(EnumCategoryAvailableIn || (EnumCategoryAvailableIn = {}));
+export default EnumCategoryAvailableIn;

package/lib/enums/EnumChannels.d.ts

@@ -0,0 +1,9 @@
+declare enum EnumChannels {
+    None = 0,
+    WebShop = 1,
+    App = 2,
+    DigitalMenu = 4,
+    POS = 8,
+    GoogleOrdering = 16
+}
+export default EnumChannels;

package/lib/enums/EnumChannels.js

@@ -0,0 +1,10 @@
+var EnumChannels;
+(function (EnumChannels) {
+    EnumChannels[EnumChannels["None"] = 0] = "None";
+    EnumChannels[EnumChannels["WebShop"] = 1] = "WebShop";
+    EnumChannels[EnumChannels["App"] = 2] = "App";
+    EnumChannels[EnumChannels["DigitalMenu"] = 4] = "DigitalMenu";
+    EnumChannels[EnumChannels["POS"] = 8] = "POS";
+    EnumChannels[EnumChannels["GoogleOrdering"] = 16] = "GoogleOrdering";
+})(EnumChannels || (EnumChannels = {}));
+export default EnumChannels;

package/lib/enums/EnumDashboardSort.d.ts

@@ -0,0 +1,7 @@
+declare enum EnumDashboardSort {
+    date = 0,
+    amount = 1,
+    discount = 2,
+    tip = 3
+}
+export default EnumDashboardSort;

package/lib/enums/EnumDashboardSort.js

@@ -0,0 +1,8 @@
+var EnumDashboardSort;
+(function (EnumDashboardSort) {
+    EnumDashboardSort[EnumDashboardSort["date"] = 0] = "date";
+    EnumDashboardSort[EnumDashboardSort["amount"] = 1] = "amount";
+    EnumDashboardSort[EnumDashboardSort["discount"] = 2] = "discount";
+    EnumDashboardSort[EnumDashboardSort["tip"] = 3] = "tip";
+})(EnumDashboardSort || (EnumDashboardSort = {}));
+export default EnumDashboardSort;

package/lib/enums/EnumDiscountType.d.ts

@@ -0,0 +1,6 @@
+declare enum EnumDiscountType {
+    none = 0,
+    percent = 1,
+    amount = 2
+}
+export default EnumDiscountType;

package/lib/enums/EnumDiscountType.js

@@ -0,0 +1,7 @@
+var EnumDiscountType;
+(function (EnumDiscountType) {
+    EnumDiscountType[EnumDiscountType["none"] = 0] = "none";
+    EnumDiscountType[EnumDiscountType["percent"] = 1] = "percent";
+    EnumDiscountType[EnumDiscountType["amount"] = 2] = "amount";
+})(EnumDiscountType || (EnumDiscountType = {}));
+export default EnumDiscountType;

package/lib/enums/EnumFeeCalculationMode.d.ts

@@ -0,0 +1,7 @@
+declare enum EnumFeeCalculationMode {
+    NONE = 0,
+    FIXED = 1,
+    MIXED = 2,
+    BOTH = 3
+}
+export default EnumFeeCalculationMode;

package/lib/enums/EnumFeeCalculationMode.js

@@ -0,0 +1,8 @@
+var EnumFeeCalculationMode;
+(function (EnumFeeCalculationMode) {
+    EnumFeeCalculationMode[EnumFeeCalculationMode["NONE"] = 0] = "NONE";
+    EnumFeeCalculationMode[EnumFeeCalculationMode["FIXED"] = 1] = "FIXED";
+    EnumFeeCalculationMode[EnumFeeCalculationMode["MIXED"] = 2] = "MIXED";
+    EnumFeeCalculationMode[EnumFeeCalculationMode["BOTH"] = 3] = "BOTH";
+})(EnumFeeCalculationMode || (EnumFeeCalculationMode = {}));
+export default EnumFeeCalculationMode;

package/lib/enums/EnumFeeType.d.ts

@@ -0,0 +1,5 @@
+declare enum EnumFeeType {
+    SERVICE = 1,
+    COMPANY = 2
+}
+export default EnumFeeType;

package/lib/enums/EnumFeeType.js

@@ -0,0 +1,6 @@
+var EnumFeeType;
+(function (EnumFeeType) {
+    EnumFeeType[EnumFeeType["SERVICE"] = 1] = "SERVICE";
+    EnumFeeType[EnumFeeType["COMPANY"] = 2] = "COMPANY";
+})(EnumFeeType || (EnumFeeType = {}));
+export default EnumFeeType;

package/lib/enums/EnumGender.d.ts

@@ -0,0 +1,6 @@
+declare enum EnumGender {
+    all = 0,
+    female = 1,
+    male = 2
+}
+export default EnumGender;

package/lib/enums/EnumGender.js

@@ -0,0 +1,7 @@
+var EnumGender;
+(function (EnumGender) {
+    EnumGender[EnumGender["all"] = 0] = "all";
+    EnumGender[EnumGender["female"] = 1] = "female";
+    EnumGender[EnumGender["male"] = 2] = "male";
+})(EnumGender || (EnumGender = {}));
+export default EnumGender;

package/lib/enums/EnumLogType.d.ts

@@ -0,0 +1,7 @@
+declare enum EnumLogType {
+    all = 0,
+    info = 1,
+    error = 2,
+    description = 3
+}
+export default EnumLogType;

package/lib/enums/EnumLogType.js

@@ -0,0 +1,8 @@
+var EnumLogType;
+(function (EnumLogType) {
+    EnumLogType[EnumLogType["all"] = 0] = "all";
+    EnumLogType[EnumLogType["info"] = 1] = "info";
+    EnumLogType[EnumLogType["error"] = 2] = "error";
+    EnumLogType[EnumLogType["description"] = 3] = "description";
+})(EnumLogType || (EnumLogType = {}));
+export default EnumLogType;