turf-common 1.0.16-beta.14 → 1.0.16-beta.16

package/build/enums/booking-details-status.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum BookingDetailsStatus {
+    BOOKED = "booked",
+    BLOCKED = "blocked"
+}

package/build/enums/booking-details-status.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BookingDetailsStatus = void 0;
+var BookingDetailsStatus;
+(function (BookingDetailsStatus) {
+    BookingDetailsStatus["BOOKED"] = "booked";
+    BookingDetailsStatus["BLOCKED"] = "blocked";
+})(BookingDetailsStatus || (exports.BookingDetailsStatus = BookingDetailsStatus = {}));

package/build/enums/booking-history-operation-type.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum BookingHistoryOperationType {
+    DELETE = "delete",
+    UPDATE = "update",
+    INSERT = "insert",
+    DELETE_INSERT = "delete_insert",
+    DELETE_SLOT = "delete_slot",
+    REFUND = "refund",
+    PAYMENT = "payment"
+}
+export declare const operationTypes: BookingHistoryOperationType[];

package/build/enums/booking-history-operation-type.enum.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationTypes = exports.BookingHistoryOperationType = void 0;
+var BookingHistoryOperationType;
+(function (BookingHistoryOperationType) {
+    BookingHistoryOperationType["DELETE"] = "delete";
+    BookingHistoryOperationType["UPDATE"] = "update";
+    BookingHistoryOperationType["INSERT"] = "insert";
+    BookingHistoryOperationType["DELETE_INSERT"] = "delete_insert";
+    BookingHistoryOperationType["DELETE_SLOT"] = "delete_slot";
+    BookingHistoryOperationType["REFUND"] = "refund";
+    BookingHistoryOperationType["PAYMENT"] = "payment";
+})(BookingHistoryOperationType || (exports.BookingHistoryOperationType = BookingHistoryOperationType = {}));
+exports.operationTypes = [
+    BookingHistoryOperationType.DELETE,
+    BookingHistoryOperationType.REFUND,
+    BookingHistoryOperationType.PAYMENT,
+];

package/build/enums/payment-mode.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum PaymentMode {
+    UPI = "upi",
+    CASH = "cash"
+}

package/build/enums/payment-mode.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentMode = void 0;
+var PaymentMode;
+(function (PaymentMode) {
+    PaymentMode["UPI"] = "upi";
+    PaymentMode["CASH"] = "cash";
+})(PaymentMode || (exports.PaymentMode = PaymentMode = {}));

package/build/enums/pricing-plan-status.enum copy.d.ts

@@ -0,0 +1,4 @@
+export declare enum PricingPlanStatus {
+    ACTIVE = "active",
+    DEACTIVE = "deactive"
+}

package/build/enums/pricing-plan-status.enum copy.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingPlanStatus = void 0;
+var PricingPlanStatus;
+(function (PricingPlanStatus) {
+    PricingPlanStatus["ACTIVE"] = "active";
+    PricingPlanStatus["DEACTIVE"] = "deactive";
+})(PricingPlanStatus || (exports.PricingPlanStatus = PricingPlanStatus = {}));

package/build/enums/pricing-plan-status.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum PricingPlanStatus {
+    ACTIVE = "active",
+    DEACTIVE = "deactive"
+}

package/build/enums/pricing-plan-status.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingPlanStatus = void 0;
+var PricingPlanStatus;
+(function (PricingPlanStatus) {
+    PricingPlanStatus["ACTIVE"] = "active";
+    PricingPlanStatus["DEACTIVE"] = "deactive";
+})(PricingPlanStatus || (exports.PricingPlanStatus = PricingPlanStatus = {}));

package/build/enums/registration-status-enum.d.ts

@@ -0,0 +1,12 @@
+export declare enum RegistrationStatus {
+    REGISTRATION = "registration",
+    REGISTRATION_INVALID = "registration_invalid",
+    REGISTRATION_APPROVED = "registration_approved",
+    SETUP_INVALID = "setup_invalid",
+    SETUP_DONE = "setup_done",
+    PAYMENT_INVALID = "payment_invalid",
+    PAYMENT_DONE = "payment_done",
+    ACCOUNT_ACTIVE = "account_active",
+    ACCOUNT_SUSPENDED = "account_suspended",
+    ACTIVE = "active"
+}

package/build/enums/registration-status-enum.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistrationStatus = void 0;
+var RegistrationStatus;
+(function (RegistrationStatus) {
+    RegistrationStatus["REGISTRATION"] = "registration";
+    RegistrationStatus["REGISTRATION_INVALID"] = "registration_invalid";
+    RegistrationStatus["REGISTRATION_APPROVED"] = "registration_approved";
+    RegistrationStatus["SETUP_INVALID"] = "setup_invalid";
+    RegistrationStatus["SETUP_DONE"] = "setup_done";
+    RegistrationStatus["PAYMENT_INVALID"] = "payment_invalid";
+    RegistrationStatus["PAYMENT_DONE"] = "payment_done";
+    RegistrationStatus["ACCOUNT_ACTIVE"] = "account_active";
+    RegistrationStatus["ACCOUNT_SUSPENDED"] = "account_suspended";
+    RegistrationStatus["ACTIVE"] = "active";
+})(RegistrationStatus || (exports.RegistrationStatus = RegistrationStatus = {}));

package/build/enums/user-status.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum UserStatus {
+    ACTIVE = "active",
+    DEACTIVE = "deactive",
+    SUSPENDED = "suspended",
+    REGISTRATION_APPROVED = "registration_approved",
+    SETUP_INVALID = "setup_invalid",
+    PAYMENT_INVALID = "payment_invalid",
+    ACCOUNT_SUSPENDED = "account_suspended",
+    SETUP_DONE = "setup_done",
+    PAYMENT_DONE = "payment_done"
+}

package/build/enums/user-status.enum.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStatus = void 0;
+var UserStatus;
+(function (UserStatus) {
+    UserStatus["ACTIVE"] = "active";
+    UserStatus["DEACTIVE"] = "deactive";
+    UserStatus["SUSPENDED"] = "suspended";
+    UserStatus["REGISTRATION_APPROVED"] = "registration_approved";
+    UserStatus["SETUP_INVALID"] = "setup_invalid";
+    UserStatus["PAYMENT_INVALID"] = "payment_invalid";
+    UserStatus["ACCOUNT_SUSPENDED"] = "account_suspended";
+    UserStatus["SETUP_DONE"] = "setup_done";
+    UserStatus["PAYMENT_DONE"] = "payment_done";
+})(UserStatus || (exports.UserStatus = UserStatus = {}));

package/build/enums/valid-type.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum UserType {
+    STAFF = "staff",
+    OWNER = "owner",
+    SUPERADMIN = "superadmin",
+    BOT_USER = "bot_user"
+}

package/build/enums/valid-type.enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserType = void 0;
+var UserType;
+(function (UserType) {
+    UserType["STAFF"] = "staff";
+    UserType["OWNER"] = "owner";
+    UserType["SUPERADMIN"] = "superadmin";
+    UserType["BOT_USER"] = "bot_user";
+})(UserType || (exports.UserType = UserType = {}));

package/build/interface/billing-cycle.interface.d.ts

@@ -0,0 +1,7 @@
+export interface IBillingCycle {
+    from: number;
+    to: number;
+    discount: string;
+    name: string;
+    key: string;
+}

package/build/interface/billing-cycle.interface.js

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

package/build/interface/get-pricing-plan-by-date-response.interface copy.d.ts

@@ -0,0 +1,23 @@
+export interface GetPricingPlanByDateResponse {
+    id: number;
+    effective_from_date: number;
+    effective_to_date: number;
+    base_price: number;
+    unit: string;
+    pitch_slab: {
+        [key: string]: {
+            from: number;
+            to: number;
+            discount: string;
+        };
+    };
+    billing_cycle: {
+        [key: string]: {
+            from: number;
+            to: number;
+            discount: string;
+            name: string;
+            key: string;
+        };
+    };
+}

package/build/interface/get-pricing-plan-by-date-response.interface copy.js

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

package/build/interface/get-pricing-plan-by-date-response.interface.d.ts

@@ -0,0 +1,23 @@
+export interface GetPricingPlanByDateResponse {
+    id: number;
+    effective_from_date: number;
+    effective_to_date: number;
+    base_price: number;
+    unit: string;
+    pitch_slab: {
+        [key: string]: {
+            from: number;
+            to: number;
+            discount: string;
+        };
+    };
+    billing_cycle: {
+        [key: string]: {
+            from: number;
+            to: number;
+            discount: string;
+            name: string;
+            key: string;
+        };
+    };
+}

package/build/interface/get-pricing-plan-by-date-response.interface.js

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

package/build/interface/pitch-slab.interface copy.d.ts

@@ -0,0 +1,5 @@
+export interface IPitchSlab {
+    from: number;
+    to: number;
+    discount: string;
+}

package/build/interface/pitch-slab.interface copy.js

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

package/build/interface/pitch-slab.interface.d.ts

@@ -0,0 +1,5 @@
+export interface IPitchSlab {
+    from: number;
+    to: number;
+    discount: string;
+}

package/build/interface/pitch-slab.interface.js

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

package/build/interface/pricing-plan-model.interface.d.ts

@@ -0,0 +1,15 @@
+import { IBillingCycle } from "./billing-cycle.interface";
+import { IPitchSlab } from "./pitch-slab.interface";
+export interface IPringPlanModel {
+    id: number;
+    effective_from_date: number;
+    effective_to_date: number;
+    base_price: number;
+    unit: string;
+    pitch_slab: {
+        [key: string]: IPitchSlab;
+    };
+    billing_cycle: {
+        [key: string]: IBillingCycle;
+    };
+}

package/build/interface/pricing-plan-model.interface.js

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

package/build/models/pitch-slab-model.d.ts

@@ -0,0 +1,85 @@
+export interface PricingPlan {
+    id: number;
+    effective_from_date: number;
+    effective_to_date: number;
+    base_price: number;
+    unit: string;
+    pitch_slab: {
+        [key: string]: PitchSlab;
+    };
+    billing_cycle: {
+        [key: string]: BillingCycle;
+    };
+}
+export interface BillingCycle {
+    from: number;
+    to: number;
+    discount: string;
+    name: string;
+    key: string;
+}
+export interface PitchSlab {
+    from: number;
+    to: number;
+    discount: string;
+}
+export declare class PricingPlanModel implements PricingPlan {
+    id: number;
+    effective_from_date: number;
+    effective_to_date: number;
+    base_price: number;
+    unit: string;
+    pitch_slab: {
+        [key: string]: PitchSlabModel;
+    };
+    billing_cycle: {
+        [key: string]: BillingCycleModel;
+    };
+    constructor(data: PricingPlan);
+    getPitchSlab(pitchCount: number): PitchSlabModel;
+    getBillingCycle(billingCycleKey: string): BillingCycleModel;
+    getMonth(billingCycleKey: string): number;
+    getNoOfSubscriptionDays(billingCycleKey: string): number;
+    getBillingCycleKeys(): string[];
+    validateBillingCycleKey(billingCycleKey: string): void;
+    getBillingCycleByDay(numberOfDay: number): BillingCycleModel | undefined;
+}
+export declare class SubscribedPricingPlanModel extends PricingPlanModel {
+    pitchCount: number;
+    billingCycle: string;
+    selectedPitchSlab: PitchSlabModel;
+    selectedBillingCycle: BillingCycleModel;
+    selectedPitchSlabBasePrice: number;
+    hourInMonth: number;
+    months: number | undefined;
+    constructor(data: PricingPlan, pitchCount: number, billingCycle: string);
+    getMonths(): number;
+    getBasePrice(): number;
+    getGrossAmount(): number;
+    getNetAmount(): number;
+    getBillingDiscount(): number;
+    getMonthDifference(that: SubscribedPricingPlanModel): number;
+    getGrossAmountByMonth(month: number): number;
+    getNetAmountByMonth(month: number): number;
+    getGrossAmountByPitchDays(pitchCount: number, days: number): number;
+    getNetAmountByPitchDays(pitchCount: number, days: number): number;
+    getGrossAmountByPitchDaysBasePrice(basePrice: number, pitchCount: number, days: number): number;
+    getNetAmountByPitchDaysBasePrice(basePrice: number, pitchCount: number, days: number): number;
+}
+export declare class BillingCycleModel implements BillingCycle {
+    from: number;
+    to: number;
+    discount: string;
+    name: string;
+    key: string;
+    constructor(data: BillingCycle);
+    getDiscount(): number;
+}
+export declare class PitchSlabModel implements PitchSlab {
+    from: number;
+    to: number;
+    discount: string;
+    constructor(data: PitchSlab);
+    getDiscount(): number;
+    getBasePrice(basePrice: number): number;
+}

package/build/models/pitch-slab-model.js

@@ -0,0 +1,184 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PitchSlabModel = exports.BillingCycleModel = exports.SubscribedPricingPlanModel = exports.PricingPlanModel = void 0;
+var common_1 = require("@nestjs/common");
+var PricingPlanModel = /** @class */ (function () {
+    function PricingPlanModel(data) {
+        var _this = this;
+        this.id = data.id;
+        this.effective_from_date = data.effective_from_date;
+        this.effective_to_date = data.effective_to_date;
+        this.base_price = data.base_price;
+        this.unit = data.unit;
+        this.pitch_slab = {};
+        this.billing_cycle = {};
+        Object.keys(data.pitch_slab).forEach(function (key) {
+            _this.pitch_slab[key] = new PitchSlabModel(data.pitch_slab[key]);
+        });
+        Object.keys(data.billing_cycle).forEach(function (key) {
+            _this.billing_cycle[key] = new BillingCycleModel(data.billing_cycle[key]);
+        });
+    }
+    PricingPlanModel.prototype.getPitchSlab = function (pitchCount) {
+        var pitchRangesMap = this.pitch_slab;
+        var pitchRanges = Object.values(pitchRangesMap);
+        var selectedPitchSlab = pitchRanges.filter(function (pitchRange) {
+            return pitchRange.from <= pitchCount && pitchCount <= pitchRange.to;
+        })[0];
+        return selectedPitchSlab;
+    };
+    PricingPlanModel.prototype.getBillingCycle = function (billingCycleKey) {
+        var billingCycleMap = this.billing_cycle;
+        var billingCycles = Object.values(billingCycleMap);
+        var selectedBillingCycle = billingCycles.filter(function (_a) {
+            var key = _a.key;
+            return key === billingCycleKey;
+        })[0];
+        return selectedBillingCycle;
+    };
+    PricingPlanModel.prototype.getMonth = function (billingCycleKey) {
+        return this.getBillingCycle(billingCycleKey).to;
+    };
+    PricingPlanModel.prototype.getNoOfSubscriptionDays = function (billingCycleKey) {
+        return this.getBillingCycle(billingCycleKey).to * 30 - 1;
+    };
+    PricingPlanModel.prototype.getBillingCycleKeys = function () {
+        return Object.values(this.billing_cycle).map(function (obj) { return obj.key; });
+    };
+    PricingPlanModel.prototype.validateBillingCycleKey = function (billingCycleKey) {
+        if (!this.getBillingCycleKeys().includes(billingCycleKey)) {
+            throw new common_1.BadRequestException({
+                key: "type",
+                message: ["pricing plan type:'".concat(billingCycleKey, "' is not found")],
+            });
+        }
+    };
+    PricingPlanModel.prototype.getBillingCycleByDay = function (numberOfDay) {
+        return Object.values(this.billing_cycle).find(function (obj) {
+            if (numberOfDay <= obj.to * 30) {
+                return obj;
+            }
+        });
+    };
+    return PricingPlanModel;
+}());
+exports.PricingPlanModel = PricingPlanModel;
+var SubscribedPricingPlanModel = /** @class */ (function (_super) {
+    __extends(SubscribedPricingPlanModel, _super);
+    function SubscribedPricingPlanModel(data, pitchCount, billingCycle) {
+        var _this = _super.call(this, data) || this;
+        _this.hourInMonth = 24 * 30;
+        _this.pitchCount = pitchCount;
+        _this.billingCycle = billingCycle;
+        _this.selectedPitchSlab = _this.getPitchSlab(_this.pitchCount);
+        _this.selectedBillingCycle = _this.getBillingCycle(_this.billingCycle);
+        _this.selectedPitchSlabBasePrice = _this.selectedPitchSlab.getBasePrice(_this.base_price);
+        return _this;
+    }
+    SubscribedPricingPlanModel.prototype.getMonths = function () {
+        return this.selectedBillingCycle.to;
+    };
+    SubscribedPricingPlanModel.prototype.getBasePrice = function () {
+        return this.selectedPitchSlabBasePrice;
+    };
+    SubscribedPricingPlanModel.prototype.getGrossAmount = function () {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            this.pitchCount *
+            this.hourInMonth *
+            this.selectedBillingCycle.to);
+    };
+    SubscribedPricingPlanModel.prototype.getNetAmount = function () {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            (1 - this.getBillingDiscount() / 100) *
+            this.pitchCount *
+            this.hourInMonth *
+            this.selectedBillingCycle.to);
+    };
+    SubscribedPricingPlanModel.prototype.getBillingDiscount = function () {
+        return this.selectedBillingCycle.getDiscount();
+    };
+    SubscribedPricingPlanModel.prototype.getMonthDifference = function (that) {
+        return that.getMonths() - this.getMonths();
+    };
+    SubscribedPricingPlanModel.prototype.getGrossAmountByMonth = function (month) {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            this.pitchCount *
+            this.hourInMonth *
+            month);
+    };
+    SubscribedPricingPlanModel.prototype.getNetAmountByMonth = function (month) {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            (1 - this.getBillingDiscount() / 100) *
+            this.pitchCount *
+            this.hourInMonth *
+            month);
+    };
+    SubscribedPricingPlanModel.prototype.getGrossAmountByPitchDays = function (pitchCount, days) {
+        return Math.round(this.selectedPitchSlabBasePrice * pitchCount * days * 24);
+    };
+    SubscribedPricingPlanModel.prototype.getNetAmountByPitchDays = function (pitchCount, days) {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            (1 - this.getBillingDiscount() / 100) *
+            pitchCount *
+            days *
+            24);
+    };
+    SubscribedPricingPlanModel.prototype.getGrossAmountByPitchDaysBasePrice = function (basePrice, pitchCount, days) {
+        return Math.round(basePrice * pitchCount * days * 24);
+    };
+    SubscribedPricingPlanModel.prototype.getNetAmountByPitchDaysBasePrice = function (basePrice, pitchCount, days) {
+        return Math.round(basePrice * (1 - this.getBillingDiscount() / 100) * pitchCount * days * 24);
+    };
+    return SubscribedPricingPlanModel;
+}(PricingPlanModel));
+exports.SubscribedPricingPlanModel = SubscribedPricingPlanModel;
+var BillingCycleModel = /** @class */ (function () {
+    function BillingCycleModel(data) {
+        this.from = data.from;
+        this.to = data.to;
+        this.discount = data.discount;
+        this.name = data.name;
+        this.key = data.key;
+    }
+    BillingCycleModel.prototype.getDiscount = function () {
+        if (this.discount.indexOf("P") > -1) {
+            return parseFloat(this.discount.replace("P", ""));
+        }
+        return 0;
+    };
+    return BillingCycleModel;
+}());
+exports.BillingCycleModel = BillingCycleModel;
+var PitchSlabModel = /** @class */ (function () {
+    function PitchSlabModel(data) {
+        this.from = data.from;
+        this.to = data.to;
+        this.discount = data.discount;
+    }
+    PitchSlabModel.prototype.getDiscount = function () {
+        if (this.discount.indexOf("P") > -1) {
+            return parseFloat(this.discount.replace("P", ""));
+        }
+        return 0;
+    };
+    PitchSlabModel.prototype.getBasePrice = function (basePrice) {
+        return basePrice * (1 - this.getDiscount() / 100);
+    };
+    return PitchSlabModel;
+}());
+exports.PitchSlabModel = PitchSlabModel;

package/build/types/bookingdetails-with-booking.type.d.ts

@@ -0,0 +1,34 @@
+import { BookingDetailsStatus } from '../enums/booking-details-status.enum';
+export type IBookingDetailsWithBooking = {
+    [bookingDetailsId: string]: {
+        createdOn: Date;
+        updatedOn: Date;
+        createdBy: number;
+        updatedBy: number;
+        id: number;
+        turfId: number;
+        pitchId: number;
+        customerName: string;
+        contact: string;
+        paymentMode: string;
+        couponCode: string;
+        totalCost: number;
+        discountedCost: number;
+        amountPaid: number;
+        email: string;
+        status: BookingDetailsStatus;
+        sport: string;
+        remarks: string;
+        initialBookingGrossAmount: number;
+        additionalBookingGrossAmount: number;
+        discountAmount: number;
+        cancelledBookingGrossAmount: number;
+        totalCancellationCharges: number;
+        netTotal: number;
+        amountPayable: number;
+        refundPayable: number;
+        bookings: {
+            [code: string]: string;
+        };
+    };
+};

package/build/types/bookingdetails-with-booking.type.js

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

package/build/types/entity/booking-cancellation-entity.type.d.ts

@@ -0,0 +1,32 @@
+import { IEntityAuditColumn } from "./entity-audit-column.type";
+import { BookingHistoryOperationType } from "../../enums/booking-history-operation-type.enum";
+import { PaymentMode } from "../../enums/payment-mode.enum";
+export interface IBookingCancellationEntity extends IEntityAuditColumn {
+    id: number;
+    bookingDetailsId: number;
+    turfId: number;
+    pitchId: number;
+    customerName: string;
+    contact: string;
+    paymentMode: string;
+    couponCode: string;
+    totalCost: number;
+    discountedCost: number;
+    amountPaid: number;
+    operationType: BookingHistoryOperationType;
+    email: string;
+    bookingCodes: string;
+    cancellationAmount: number;
+    refundAmount: number;
+    refundMode: PaymentMode | null;
+    startDateCode: number;
+    endDateCode: number;
+    initialBookingGrossAmount: number;
+    additionalBookingGrossAmount: number;
+    discountAmount: number;
+    cancelledBookingGrossAmount: number;
+    totalCancellationCharges: number;
+    netTotal: number;
+    amountPayable: number;
+    refundPayable: number;
+}

package/build/types/entity/booking-cancellation-entity.type.js

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

package/build/types/entity/booking-customer-entity.type.d.ts

@@ -0,0 +1,8 @@
+import { IEntityAuditColumn } from "./entity-audit-column.type";
+export interface IBookingCustomerEntity extends IEntityAuditColumn {
+    contactNo: string;
+    turfId: number;
+    name: string;
+    email: string;
+    pitchNo: number;
+}

package/build/types/entity/booking-customer-entity.type.js

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

package/build/types/entity/booking-details-entity.type.d.ts

@@ -0,0 +1,66 @@
+import { ChargesModel } from "../../models/charge-model";
+import { IEntityAuditColumn } from "./entity-audit-column.type";
+import { BookingDetailsStatus } from "../../enums/booking-details-status.enum";
+import { IBookingsEntity } from "./bookings-entity.type";
+import { IBookingDetailsWithBooking } from "../bookingdetails-with-booking.type";
+export interface IBookingDetailsEntity extends IEntityAuditColumn {
+    id: number;
+    turfId: number;
+    pitchId: number;
+    customerName: string;
+    contact: string;
+    paymentMode: string;
+    couponCode: string;
+    totalCost: number;
+    discountedCost: number;
+    amountPaid: number;
+    email: string;
+    status: BookingDetailsStatus;
+    sport: string;
+    remarks: string;
+    initialBookingGrossAmount: number;
+    additionalBookingGrossAmount: number;
+    discountAmount: number;
+    cancelledBookingGrossAmount: number;
+    totalCancellationCharges: number;
+    netTotal: number;
+    amountPayable: number;
+    refundPayable: number;
+    totalRefundedAmount: number;
+}
+export interface IBookingDetailsModel extends IBookingDetailsEntity {
+    assignCharges(chargeModel: ChargesModel): void;
+}
+export declare class BookingDetailsModel implements IBookingDetailsModel {
+    id: number;
+    turfId: number;
+    pitchId: number;
+    customerName: string;
+    contact: string;
+    paymentMode: string;
+    couponCode: string;
+    totalCost: number;
+    discountedCost: number;
+    amountPaid: number;
+    email: string;
+    status: BookingDetailsStatus;
+    sport: string;
+    remarks: string;
+    initialBookingGrossAmount: number;
+    additionalBookingGrossAmount: number;
+    discountAmount: number;
+    cancelledBookingGrossAmount: number;
+    totalCancellationCharges: number;
+    netTotal: number;
+    amountPayable: number;
+    refundPayable: number;
+    totalRefundedAmount: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(data: IBookingDetailsEntity);
+    static getIdAndCreatedBy(bookingDetailsEntities: IBookingDetailsEntity[]): number[][];
+    assignCharges(chargeModel: ChargesModel): void;
+    static toMap(bookingDetailsEntities: IBookingDetailsEntity[], bookingsEntities: IBookingsEntity[]): IBookingDetailsWithBooking;
+}

package/build/types/entity/booking-details-entity.type.js

@@ -0,0 +1,69 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BookingDetailsModel = void 0;
+var bookings_entity_type_1 = require("./bookings-entity.type");
+var BookingDetailsModel = /** @class */ (function () {
+    function BookingDetailsModel(data) {
+        Object.assign(this, data);
+    }
+    BookingDetailsModel.getIdAndCreatedBy = function (bookingDetailsEntities) {
+        var bookingDetailsIds = [];
+        var userIds = [];
+        bookingDetailsEntities.forEach(function (_a) {
+            var bookingDetailId = _a.id, createdBy = _a.createdBy;
+            bookingDetailsIds.push(bookingDetailId), userIds.push(createdBy);
+        });
+        return [bookingDetailsIds, userIds];
+    };
+    //   static toMap(
+    //     bookingDetailsEntities: IBookingDetailsEntity[],
+    //     bookingsEntities: BookingsEntity[],
+    //   ): IBookingDetailsWithBooking {
+    //     const response: IBookingDetailsWithBooking = {};
+    //     bookingDetailsEntities.forEach((bookingsDetailsEntity) => {
+    //       const bookingDetailsId = bookingsDetailsEntity.id;
+    //       if (!response[bookingDetailsId]) {
+    //         response[bookingDetailsId] = {
+    //           ...bookingsDetailsEntity,
+    //           bookings: {},
+    //         };
+    //       }
+    //       const filterBookingEntities = bookingsEntities.filter(
+    //         (bookingEntity) => bookingEntity.bookingDetailsId === bookingDetailsId,
+    //       );
+    //       response[bookingDetailsId].bookings = BookingsEntity.toMap(
+    //         filterBookingEntities,
+    //       );
+    //     });
+    //     return response;
+    //   }
+    BookingDetailsModel.prototype.assignCharges = function (chargeModel) {
+        this.discountAmount = chargeModel.getDiscountAmount();
+        Object.assign(this, chargeModel);
+    };
+    BookingDetailsModel.toMap = function (bookingDetailsEntities, bookingsEntities) {
+        var response = {};
+        bookingDetailsEntities.forEach(function (bookingsDetailsEntity) {
+            var bookingDetailsId = bookingsDetailsEntity.id;
+            if (!response[bookingDetailsId]) {
+                response[bookingDetailsId] = __assign(__assign({}, bookingsDetailsEntity), { bookings: {} });
+            }
+            var filterBookingEntities = bookingsEntities.filter(function (bookingEntity) { return bookingEntity.bookingDetailsId === bookingDetailsId; });
+            response[bookingDetailsId].bookings = bookings_entity_type_1.BookingEntityModel.toMap(filterBookingEntities);
+        });
+        return response;
+    };
+    return BookingDetailsModel;
+}());
+exports.BookingDetailsModel = BookingDetailsModel;

package/build/types/entity/bookings-entity.type.d.ts

@@ -0,0 +1,31 @@
+import { BookingCode } from "../../models/booking-code-model";
+import { IEntityAuditColumn } from "./entity-audit-column.type";
+export interface IBookingsEntity extends IEntityAuditColumn {
+    bookingDetailsId: number;
+    code: string;
+    cost: string;
+}
+export interface IBookingsEntityModel extends IBookingsEntity {
+    getTotalCost(): number;
+    getBookingTimeInMinutes(): number;
+    isTimeExtended(newBookingEntities: IBookingsEntity[]): boolean;
+    getBookingCode(): BookingCode;
+}
+export declare class BookingEntityModel implements IBookingsEntityModel {
+    bookingDetailsId: number;
+    code: string;
+    cost: string;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(data: IBookingsEntity);
+    getTotalCost(): number;
+    getBookingTimeInMinutes(): number;
+    isTimeExtended(newBookingEntities: IBookingsEntity[]): boolean;
+    getBookingCode(): BookingCode;
+    static toMap(bookingEntities: IBookingsEntity[]): {
+        [key: string]: string;
+    };
+    static findByCodeAndTurfId(bookingEntities: IBookingsEntity[], turfId: number, bookingCode: string): IBookingsEntity | undefined;
+}

package/build/types/entity/bookings-entity.type.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BookingEntityModel = void 0;
+var booking_code_model_1 = require("../../models/booking-code-model");
+var BookingEntityModel = /** @class */ (function () {
+    function BookingEntityModel(data) {
+        Object.assign(this, data);
+    }
+    BookingEntityModel.prototype.getTotalCost = function () {
+        return this.cost
+            .split(",")
+            .map(Number)
+            .reduce(function (accumulator, currentValue) { return accumulator + currentValue; }, 0);
+    };
+    BookingEntityModel.prototype.getBookingTimeInMinutes = function () {
+        var bookingCode = new booking_code_model_1.BookingCode(this.code);
+        return bookingCode.getBookingTimeInMinutes();
+    };
+    BookingEntityModel.prototype.isTimeExtended = function (newBookingEntities) {
+        var newTimeInMinutes = newBookingEntities
+            .map(function (bookingEntity) {
+            return new BookingEntityModel(bookingEntity).getBookingTimeInMinutes();
+        })
+            .reduce(function (accumulator, currentValue) { return accumulator + currentValue; }, 0);
+        return (newTimeInMinutes > new BookingEntityModel(this).getBookingTimeInMinutes());
+    };
+    BookingEntityModel.prototype.getBookingCode = function () {
+        return new booking_code_model_1.BookingCode(this.code, this.cost);
+    };
+    BookingEntityModel.toMap = function (bookingEntities) {
+        var response = {};
+        bookingEntities.forEach(function (bookingEntity) {
+            response[bookingEntity.code] =
+                response[bookingEntity.code] === undefined
+                    ? bookingEntity.cost
+                    : response[bookingEntity.code];
+        });
+        return response;
+    };
+    BookingEntityModel.findByCodeAndTurfId = function (bookingEntities, turfId, bookingCode) {
+        return bookingEntities.find(function (bookingEntity) {
+            return bookingEntity.code === booking_code_model_1.BookingCode.getInstance(turfId, bookingCode).code;
+        });
+    };
+    return BookingEntityModel;
+}());
+exports.BookingEntityModel = BookingEntityModel;

package/build/types/entity/cancellation-policy-entity.type.d.ts

@@ -0,0 +1,27 @@
+import { IEntityAuditColumn } from "./entity-audit-column.type";
+export interface ICancellationPolicyEntity extends IEntityAuditColumn {
+    id: number;
+    turfId: number;
+    from: number;
+    to: number;
+    charges: string;
+}
+export interface ICancellationPolicyModel extends ICancellationPolicyEntity {
+    unitOfCharges(): string;
+}
+export declare class CancellationPolicyModel implements ICancellationPolicyModel {
+    id: number;
+    turfId: number;
+    from: number;
+    to: number;
+    charges: string;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(data: ICancellationPolicyEntity);
+    unitOfCharges(): string;
+    chargesWithoutUnit(): string;
+    isInEffect(hours: number): boolean;
+    getCancellationCharges(cost: number): number;
+}

package/build/types/entity/cancellation-policy-entity.type.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancellationPolicyModel = void 0;
+var CancellationPolicyModel = /** @class */ (function () {
+    function CancellationPolicyModel(data) {
+        Object.assign(this, data);
+    }
+    CancellationPolicyModel.prototype.unitOfCharges = function () {
+        return this.charges.slice(-1);
+    };
+    CancellationPolicyModel.prototype.chargesWithoutUnit = function () {
+        return this.charges.slice(0, -1);
+    };
+    CancellationPolicyModel.prototype.isInEffect = function (hours) {
+        return this.from <= hours && hours <= this.to;
+    };
+    CancellationPolicyModel.prototype.getCancellationCharges = function (cost) {
+        var cancellationCharges = 0;
+        var cancellationChargesModel = new CancellationPolicyModel(this);
+        if (cancellationChargesModel.unitOfCharges() === "P") {
+            var percentageValue = cancellationChargesModel.chargesWithoutUnit();
+            cancellationCharges = (cost * Number(percentageValue)) / 100;
+        }
+        else if (cancellationChargesModel.unitOfCharges() === "U") {
+            var unit = cancellationChargesModel.chargesWithoutUnit();
+            cancellationCharges = Number(unit);
+        }
+        return cancellationCharges;
+    };
+    return CancellationPolicyModel;
+}());
+exports.CancellationPolicyModel = CancellationPolicyModel;

package/build/types/entity/price-entity.type.d.ts

@@ -0,0 +1,16 @@
+import { IEntityAuditColumn } from "./entity-audit-column.type";
+export interface IPriceEntity extends IEntityAuditColumn {
+    id: string;
+    price: number;
+}
+export interface IPriceModel extends IPriceEntity {
+}
+export declare class PriceModel implements IPriceModel {
+    id: string;
+    price: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    static sortByCode(priceEntities: IPriceEntity[]): IPriceEntity[];
+}

package/build/types/entity/price-entity.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceModel = void 0;
+var PriceModel = /** @class */ (function () {
+    function PriceModel() {
+    }
+    PriceModel.sortByCode = function (priceEntities) {
+        priceEntities = priceEntities.sort(function (a, b) {
+            return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+        });
+        return priceEntities;
+    };
+    return PriceModel;
+}());
+exports.PriceModel = PriceModel;

package/build/types/entity/pricing-plan-entity.d.ts

@@ -0,0 +1,66 @@
+import { IEntityAuditColumn } from "./entity-audit-column.type";
+import { PricingPlanStatus } from "../../enums/pricing-plan-status.enum";
+import { PitchSlab, PricingPlanModel, BillingCycle, BillingCycleModel } from "../../models/pitch-slab-model";
+import { GetPricingPlanByDateResponse } from "../../interface/get-pricing-plan-by-date-response.interface";
+export interface IPricingPlanEntity extends IEntityAuditColumn {
+    id: number;
+    effectiveFrom: Date;
+    effectiveTo: Date;
+    costCode: string;
+    status: PricingPlanStatus;
+    createdBy: number;
+    createdOn: Date;
+    updatedBy: number;
+    updatedOn: Date;
+    basePrice: number;
+    billingCycle: string;
+    unit: string;
+}
+export interface IPricingPlanEntityModel extends IPricingPlanEntity {
+    getBillingCycleKeys(): string[];
+    toModel(): PricingPlanModel;
+    arrayToIndexedObject<T>(arr: T[]): {
+        [key: string]: T;
+    };
+    toObject(): GetPricingPlanByDateResponse;
+    toPitchSlabs(): PitchSlab[];
+}
+export declare class PricingPlanEntityModel implements IPricingPlanEntityModel {
+    id: number;
+    effectiveFrom: Date;
+    effectiveTo: Date;
+    costCode: string;
+    status: PricingPlanStatus;
+    createdBy: number;
+    createdOn: Date;
+    updatedBy: number;
+    updatedOn: Date;
+    basePrice: number;
+    billingCycle: string;
+    unit: string;
+    constructor(data: IPricingPlanEntity);
+    getBillingCycleKeys(): string[];
+    toModel(): PricingPlanModel;
+    arrayToIndexedObject<T>(arr: T[]): {
+        [key: string]: T;
+    };
+    toObject(): GetPricingPlanByDateResponse;
+    toPitchSlabs(): PitchSlab[];
+    toBillingCycles(): BillingCycle[];
+}
+export declare class PitchSlabParser {
+    code: string;
+    constructor(code: string);
+    parseToModel(): PitchSlab;
+}
+export declare class BillingCycleCodeParser {
+    code: string;
+    from: number;
+    to: number;
+    discount: string;
+    name: string;
+    constructor(code: string);
+    parse(): BillingCycleCodeParser;
+    parseToModel(): BillingCycleModel;
+    getKey(): string;
+}

package/build/types/entity/pricing-plan-entity.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingCycleCodeParser = exports.PitchSlabParser = exports.PricingPlanEntityModel = void 0;
+var booking_code_model_1 = require("../../models/booking-code-model");
+var pitch_slab_model_1 = require("../../models/pitch-slab-model");
+var PricingPlanEntityModel = /** @class */ (function () {
+    function PricingPlanEntityModel(data) {
+        Object.assign(this, data);
+    }
+    PricingPlanEntityModel.prototype.getBillingCycleKeys = function () {
+        return this.toBillingCycles().map(function (billingCycle) { return billingCycle.key; });
+    };
+    PricingPlanEntityModel.prototype.toModel = function () {
+        return new pitch_slab_model_1.PricingPlanModel({
+            id: this.id,
+            base_price: this.basePrice,
+            effective_from_date: parseInt(booking_code_model_1.BookingCode.getDateCode(this.effectiveFrom)),
+            effective_to_date: parseInt(booking_code_model_1.BookingCode.getDateCode(this.effectiveTo)),
+            unit: this.unit,
+            billing_cycle: this.arrayToIndexedObject(this.toBillingCycles()),
+            pitch_slab: this.arrayToIndexedObject(this.toPitchSlabs()),
+        });
+    };
+    PricingPlanEntityModel.prototype.arrayToIndexedObject = function (arr) {
+        return arr.reduce(function (result, item, index) {
+            result[index.toString()] = item; //a, b, c
+            return result;
+        }, {});
+    };
+    PricingPlanEntityModel.prototype.toObject = function () {
+        var responseObj = {
+            id: this.id,
+            effective_from_date: 0,
+            effective_to_date: 0,
+            base_price: 0,
+            unit: "per_hour_per_pitch",
+            pitch_slab: {},
+            billing_cycle: {},
+        };
+        var billingCycle = this.billingCycle.split(",");
+        billingCycle.forEach(function (billing, index) {
+            var billingArray = billing.split("_");
+            responseObj.billing_cycle[index] = {
+                from: Number(billingArray[0].slice(0, 3)),
+                to: Number(billingArray[0].slice(3, 6)),
+                discount: billingArray[1],
+                name: billingArray.slice(2).join("_"),
+                key: billingArray.slice(2).join("-").toLowerCase().replace(/ /g, "-"),
+            };
+        });
+        this.costCode.split(",").forEach(function (code, index) {
+            var costCode = code.split("_");
+            responseObj.pitch_slab[index] = {
+                from: Number(costCode[0].slice(0, 3)),
+                to: Number(costCode[0].slice(3, 6)),
+                discount: costCode[1],
+            };
+        });
+        responseObj.effective_from_date = Number(booking_code_model_1.BookingCode.getDateCode(this.effectiveFrom));
+        responseObj.effective_to_date = Number(booking_code_model_1.BookingCode.getDateCode(this.effectiveTo));
+        responseObj.unit = this.unit;
+        responseObj.base_price = this.basePrice;
+        return responseObj;
+    };
+    PricingPlanEntityModel.prototype.toPitchSlabs = function () {
+        return this.costCode
+            .split(",")
+            .map(function (cost_code) { return new PitchSlabParser(cost_code).parseToModel(); });
+    };
+    PricingPlanEntityModel.prototype.toBillingCycles = function () {
+        return this.billingCycle
+            .split(",")
+            .map(function (billingCode) {
+            return new BillingCycleCodeParser(billingCode).parseToModel();
+        });
+    };
+    return PricingPlanEntityModel;
+}());
+exports.PricingPlanEntityModel = PricingPlanEntityModel;
+var PitchSlabParser = /** @class */ (function () {
+    function PitchSlabParser(code) {
+        this.code = code;
+    }
+    PitchSlabParser.prototype.parseToModel = function () {
+        var costCodeComponents = this.code.split("_");
+        return new pitch_slab_model_1.PitchSlabModel({
+            discount: costCodeComponents[1],
+            from: parseInt(costCodeComponents[0].slice(0, 3)),
+            to: parseInt(costCodeComponents[0].slice(3)),
+        });
+    };
+    return PitchSlabParser;
+}());
+exports.PitchSlabParser = PitchSlabParser;
+var BillingCycleCodeParser = /** @class */ (function () {
+    function BillingCycleCodeParser(code) {
+        this.code = code;
+    }
+    BillingCycleCodeParser.prototype.parse = function () {
+        var billingCycleComponents = this.code.split("_");
+        this.from = parseInt(billingCycleComponents[0].slice(0, 3));
+        this.to = parseInt(billingCycleComponents[0].slice(3, 6));
+        this.discount = billingCycleComponents[1];
+        this.name = billingCycleComponents[2];
+        return this;
+    };
+    BillingCycleCodeParser.prototype.parseToModel = function () {
+        var billingCycleComponents = this.code.split("_");
+        this.from = parseInt(billingCycleComponents[0].slice(0, 3));
+        this.to = parseInt(billingCycleComponents[0].slice(3, 6));
+        this.discount = billingCycleComponents[1];
+        this.name = billingCycleComponents[2];
+        return new pitch_slab_model_1.BillingCycleModel({
+            discount: this.discount,
+            from: this.from,
+            to: this.to,
+            name: this.name,
+            key: this.getKey(),
+        });
+    };
+    BillingCycleCodeParser.prototype.getKey = function () {
+        return this.name.toLowerCase().replace(" ", "-");
+    };
+    return BillingCycleCodeParser;
+}());
+exports.BillingCycleCodeParser = BillingCycleCodeParser;

package/build/types/entity/registration-entity.type.d.ts

@@ -0,0 +1,12 @@
+import { RegistrationStatus } from "../../enums/registration-status-enum";
+import { IEntityAuditColumn } from "./entity-audit-column.type";
+export interface IRegistrationEntity extends IEntityAuditColumn {
+    id: number;
+    name: string;
+    contact: string;
+    email: string;
+    pitchPlan: string;
+    status: RegistrationStatus;
+    comments: string;
+    token: string;
+}

package/build/types/entity/registration-entity.type.js

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

package/build/types/entity/user-entity.type.d.ts

@@ -0,0 +1,52 @@
+import { IEntityAuditColumn } from "./entity-audit-column.type";
+import { UserStatus } from "../../enums/user-status.enum";
+import { UserType } from "../../enums/valid-type.enum";
+import { ITurfEntity } from "./turf-entity.type";
+export interface IUserEntity extends IEntityAuditColumn {
+    id: number;
+    firstname: string;
+    lastname: string;
+    phone: string;
+    password: string;
+    email: string;
+    status: UserStatus;
+    is_email_verified: boolean;
+    is_mobile_verified: boolean;
+    is_account_verified: boolean;
+    require_new_password: boolean;
+    organization_id: number;
+    type: UserType;
+    registrationId: number;
+    comments: string;
+}
+export interface IUserEntityRel {
+    turf: ITurfEntity[];
+}
+export interface IUserModel extends IUserEntity, IUserEntityRel {
+}
+export declare class UserModel implements IUserModel {
+    id: number;
+    firstname: string;
+    lastname: string;
+    phone: string;
+    password: string;
+    email: string;
+    status: UserStatus;
+    is_email_verified: boolean;
+    is_mobile_verified: boolean;
+    is_account_verified: boolean;
+    require_new_password: boolean;
+    organization_id: number;
+    type: UserType;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    registrationId: number;
+    comments: string;
+    turf: ITurfEntity[];
+    constructor(data: IUserModel);
+    static toMap(userEntities: IUserEntity[]): {
+        [key: number]: IUserEntity;
+    };
+}

package/build/types/entity/user-entity.type.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModel = void 0;
+var UserModel = /** @class */ (function () {
+    function UserModel(data) {
+        Object.assign(this, data);
+    }
+    UserModel.toMap = function (userEntities) {
+        var response = {};
+        userEntities.forEach(function (userEntity) {
+            if (!response[userEntity.id]) {
+                response[userEntity.id] = userEntity;
+            }
+        });
+        return response;
+    };
+    return UserModel;
+}());
+exports.UserModel = UserModel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turf-common",
-  "version": "1.0.16-beta.14",
+  "version": "1.0.16-beta.16",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",