@armoury/fivem-roleplay-gamemode-common 0.0.0-stage → 1.0.11

package/dist/cjs/shared/models/items/weapons/weapon-item.js

@@ -0,0 +1,74 @@
+"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 __());
+    };
+})();
+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.WeaponItem = void 0;
+var item_model_1 = require("../item.model");
+var WeaponItem = /** @class */ (function (_super) {
+    __extends(WeaponItem, _super);
+    function WeaponItem() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(WeaponItem.prototype, "amount", {
+        get: function () {
+            return this.value.ammo;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WeaponItem.prototype, "weight", {
+        get: function () {
+            return this.amount * this.weightPerUnit;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WeaponItem.prototype.add = function (amount) {
+        this.value = __assign(__assign({}, this.value), { ammo: Math.max(0, this.value.ammo + amount) });
+        return this;
+    };
+    WeaponItem.prototype.consume = function (amount) {
+        return this.add(-amount);
+    };
+    WeaponItem.prototype.empty = function () {
+        return this.add(-this.value.ammo);
+    };
+    WeaponItem.prototype.serialize = function () {
+        var _a;
+        return (_a = {},
+            _a[this.identifier] = this.value,
+            _a);
+    };
+    WeaponItem.prototype.deserialize = function (serialized) {
+        var _a = Object.entries(serialized)[0], identifier = _a[0], value = _a[1];
+        this.identifier = identifier;
+        this.value = value;
+        return this;
+    };
+    return WeaponItem;
+}(item_model_1.Item));
+exports.WeaponItem = WeaponItem;

package/dist/esm/shared/index.js

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

package/dist/esm/shared/models/businesses/business.interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/models/businesses/business.model.js

@@ -0,0 +1,9 @@
+var Business = /** @class */ (function () {
+    function Business(data) {
+        if (data) {
+            Object.assign(this, data);
+        }
+    }
+    return Business;
+}());
+export { Business };

package/dist/esm/shared/models/businesses/index.js

@@ -0,0 +1,2 @@
+export * from './business.model';
+export * from './business.interfaces';

package/dist/esm/shared/models/index.js

@@ -0,0 +1,2 @@
+export * from './businesses';
+export * from './items';

package/dist/esm/shared/models/items/clothing/clothing-item.js

@@ -0,0 +1,57 @@
+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 __());
+    };
+})();
+import { Item } from "../item.model";
+var Clothing = /** @class */ (function (_super) {
+    __extends(Clothing, _super);
+    function Clothing(_name, _value) {
+        if (_value === void 0) { _value = null; }
+        var _this = _super.call(this, _name, 1, true, _value) || this;
+        _this.amount = 1;
+        return _this;
+    }
+    Object.defineProperty(Clothing.prototype, "weight", {
+        get: function () {
+            return this.weightPerUnit;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Clothing.prototype.add = function (_amount) {
+        this.amount = 1;
+        return this;
+    };
+    Clothing.prototype.consume = function (_amount) {
+        this.amount = 0;
+        return this;
+    };
+    Clothing.prototype.empty = function () {
+        return this.consume(this.weightPerUnit);
+    };
+    Clothing.prototype.serialize = function () {
+        var _a;
+        return (_a = {},
+            _a[this.identifier] = this.value,
+            _a);
+    };
+    Clothing.prototype.deserialize = function (serialized) {
+        var _a = Object.entries(serialized)[0], identifier = _a[0], value = _a[1];
+        this.identifier = identifier;
+        this.value = value;
+        return this;
+    };
+    return Clothing;
+}(Item));
+export { Clothing };

package/dist/esm/shared/models/items/clothing/index.js

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

package/dist/esm/shared/models/items/errors/index.js

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

package/dist/esm/shared/models/items/errors/item-error-base.js

@@ -0,0 +1,26 @@
+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 __());
+    };
+})();
+var ItemError = /** @class */ (function (_super) {
+    __extends(ItemError, _super);
+    function ItemError(msg) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, msg) || this;
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return ItemError;
+}(Error));
+export { ItemError };

package/dist/esm/shared/models/items/errors/item-errors.js

@@ -0,0 +1,32 @@
+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 __());
+    };
+})();
+import { ItemStashError } from "./item-stash-error-base";
+var ItemStashSlotsInsuficientError = /** @class */ (function (_super) {
+    __extends(ItemStashSlotsInsuficientError, _super);
+    function ItemStashSlotsInsuficientError(msg) {
+        return _super.call(this, msg !== null && msg !== void 0 ? msg : 'There were insuficient slots to add to the stash.') || this;
+    }
+    return ItemStashSlotsInsuficientError;
+}(ItemStashError));
+export { ItemStashSlotsInsuficientError };
+var ItemStashGenericError = /** @class */ (function (_super) {
+    __extends(ItemStashGenericError, _super);
+    function ItemStashGenericError(msg) {
+        return _super.call(this, msg !== null && msg !== void 0 ? msg : 'An unexpected runtime error occured.') || this;
+    }
+    return ItemStashGenericError;
+}(ItemStashError));
+export { ItemStashGenericError };

package/dist/esm/shared/models/items/errors/item-stash-error-base.js

@@ -0,0 +1,26 @@
+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 __());
+    };
+})();
+var ItemStashError = /** @class */ (function (_super) {
+    __extends(ItemStashError, _super);
+    function ItemStashError(msg) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, msg) || this;
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return ItemStashError;
+}(Error));
+export { ItemStashError };

package/dist/esm/shared/models/items/index.js

@@ -0,0 +1,8 @@
+export * from './item-stash.model';
+export * from './item.model';
+export * from './item-transfer.model';
+export * from './items-base';
+export * from './stashes-base';
+export * from './errors';
+export * from './clothing';
+export * from './weapons';

package/dist/esm/shared/models/items/item-stash.model.js

@@ -0,0 +1,141 @@
+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);
+};
+import { ItemStashGenericError, ItemStashSlotsInsuficientError } from "./errors";
+var ItemStash = /** @class */ (function () {
+    function ItemStash(name, slots, weightPerSlot) {
+        this.name = name;
+        this.slots = slots;
+        this.weightPerSlot = weightPerSlot;
+        this._items = new Map();
+    }
+    Object.defineProperty(ItemStash.prototype, "items", {
+        get: function () {
+            return Array.from(this._items.values());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ;
+    ItemStash.prototype.add = function (item, slot) {
+        var _this = this;
+        var clone = ItemStash.clone(this); // Creates a clone to operate onto, instead of altering the original map
+        var consumedWeight = 0;
+        var weightToConsume = item.weight;
+        if (!item.fullyOccupiesSlot) {
+            // If there are existing slots with this item, fill them
+            Array.from(clone._items.entries()).forEach(function (_a) {
+                var existingSlot = _a[0], existingItem = _a[1];
+                if (consumedWeight < weightToConsume && existingItem.identifier === item.identifier) {
+                    consumedWeight += ItemStash.addToSlot(clone, item.empty().add(Math.round((weightToConsume - consumedWeight) / item.weightPerUnit)), existingSlot);
+                }
+            });
+        }
+        // If the added item is not yet fully transferred, find a new slot to put the remaining amount into
+        var attempts = 0;
+        while (consumedWeight < weightToConsume) {
+            if (consumedWeight < weightToConsume && clone._items.size >= clone.slots) {
+                throw new ItemStashSlotsInsuficientError();
+            }
+            attempts++;
+            if (attempts >= this.slots) {
+                throw new ItemStashGenericError();
+            }
+            consumedWeight += ItemStash.addToSlot(clone, item.empty().add(Math.round((weightToConsume - consumedWeight) / item.weightPerUnit)), clone._items.size);
+        }
+        // If everything went well, propagate the modification into the original map
+        Array.from(clone._items.entries()).forEach(function (_a) {
+            var slot = _a[0], item = _a[1];
+            _this._items.set(slot, item);
+        });
+        return true;
+    };
+    ItemStash.prototype.consume = function (item, amount) {
+        var _this = this;
+        var consumedAmount = 0;
+        if (amount >= item.amount) {
+            var slot = Array.from(this._items.entries()).find(function (_a) {
+                var existingItem = _a[1];
+                return existingItem.identifier === item.identifier;
+            })[0];
+            if (slot != null) {
+                this._items.delete(slot);
+            }
+        }
+        else {
+            Array.from(this._items.entries()).reverse().forEach(function (_a) {
+                var existingSlot = _a[0], existingItem = _a[1];
+                if (consumedAmount < amount && item.identifier === existingItem.identifier) {
+                    var amountRemoved = ItemStash.removeFromSlot(_this, existingSlot, amount - consumedAmount);
+                    consumedAmount += amountRemoved;
+                }
+            });
+        }
+    };
+    ItemStash.prototype.has = function (itemIdentifier) {
+        return Array.from(this._items.values()).some(function (item) { return item.identifier === itemIdentifier; });
+    };
+    ItemStash.prototype.serialize = function () {
+        return this.items.reduce(function (prev, curr) { return (__assign(__assign({}, prev), curr.serialize())); }, {});
+    };
+    ItemStash.prototype.toUI = function () {
+        return ({
+            title: this.name,
+            items: Array.from(this._items.entries())
+                .map(function (_a) {
+                var slot = _a[0], item = _a[1];
+                return item.toUI(slot);
+            })
+        });
+    };
+    /**
+     * Adds an item to a stash.
+     * @param stash Stash to add the item to
+     * @param item Item to add to the stash
+     * @param slot The slot where the item should be placed into
+     * @returns Weight added to the stash
+     */
+    ItemStash.addToSlot = function (stash, item, slot) {
+        var _a;
+        var existingWeightOfThisItem = ((_a = stash._items.get(slot)) === null || _a === void 0 ? void 0 : _a.weight) || 0;
+        var availableWeightInThisSlot = stash.weightPerSlot - existingWeightOfThisItem;
+        var weightToBeAdded = Math.max(1, Math.min(availableWeightInThisSlot, item.weight));
+        stash._items.set(slot, item.empty().add(Math.round((existingWeightOfThisItem + weightToBeAdded) / item.weightPerUnit)));
+        return weightToBeAdded;
+    };
+    /**
+     * Removes an X amount of whichever item lies in the specified slot
+     * @param stash Stash to remove the amount of the item from
+     * @param slot Slot of the stash which will have this amount of the item removed
+     * @param amount The amount of the item to be removed
+     * @returns The amount that has been removed (the amount in the slot can be lower than the provided amount-to-be-removed)
+     */
+    ItemStash.removeFromSlot = function (stash, slot, amount) {
+        var _a;
+        var existingAmountOfThisItem = ((_a = stash._items.get(slot)) === null || _a === void 0 ? void 0 : _a.amount) || 0;
+        if (!existingAmountOfThisItem || !stash._items.get(slot)) {
+            return 0;
+        }
+        var amountToBeConsumed = Math.min(existingAmountOfThisItem, amount);
+        stash._items.set(slot, stash._items.get(slot).consume(amountToBeConsumed));
+        return amountToBeConsumed;
+    };
+    ItemStash.clone = function (stash) {
+        var clone = new ItemStash(stash.name, stash.slots, stash.weightPerSlot);
+        Array.from(stash._items.entries()).forEach(function (_a) {
+            var slot = _a[0], item = _a[1];
+            clone._items.set(slot, item);
+        });
+        return clone;
+    };
+    return ItemStash;
+}());
+export { ItemStash };

package/dist/esm/shared/models/items/item-transfer.model.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/models/items/item.model.js

@@ -0,0 +1,23 @@
+var Item = /** @class */ (function () {
+    function Item(identifier, weightPerUnit, fullyOccupiesSlot, value) {
+        this.identifier = identifier;
+        this.weightPerUnit = weightPerUnit;
+        this.fullyOccupiesSlot = fullyOccupiesSlot;
+        this.value = value;
+        this.fullyOccupiesSlot = fullyOccupiesSlot !== null && fullyOccupiesSlot !== void 0 ? fullyOccupiesSlot : false;
+    }
+    Item.prototype.toUI = function (slot) {
+        return ({
+            image: this.identifier,
+            type: 'item',
+            description: 'Just an inventory item.',
+            topLeft: '',
+            bottomRight: JSON.stringify(this.value),
+            _piKey: '', // TODO: Can we remove this?
+            outline: '#878b9f',
+            width: 65,
+        });
+    };
+    return Item;
+}());
+export { Item };

package/dist/esm/shared/models/items/items-base/index.js

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

package/dist/esm/shared/models/items/items-base/number-item.js

@@ -0,0 +1,61 @@
+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 __());
+    };
+})();
+import { Item } from "../item.model";
+var NumberItem = /** @class */ (function (_super) {
+    __extends(NumberItem, _super);
+    function NumberItem() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(NumberItem.prototype, "amount", {
+        get: function () {
+            return this.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NumberItem.prototype, "weight", {
+        get: function () {
+            return this.value * this.weightPerUnit;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    NumberItem.prototype.add = function (amount) {
+        this.value = Math.max(0, this.value + amount);
+        return this;
+    };
+    NumberItem.prototype.consume = function (amount) {
+        return this.add(-amount);
+    };
+    NumberItem.prototype.empty = function () {
+        this.value = 0;
+        return this;
+    };
+    NumberItem.prototype.serialize = function () {
+        var _a;
+        return (_a = {},
+            _a[this.identifier] = this.value,
+            _a);
+    };
+    NumberItem.prototype.deserialize = function (serialized) {
+        var _a = Object.entries(serialized)[0], identifier = _a[0], value = _a[1];
+        this.identifier = identifier;
+        this.value = value;
+        return this;
+    };
+    return NumberItem;
+}(Item));
+export { NumberItem };

package/dist/esm/shared/models/items/stashes-base/generic-stash.js

@@ -0,0 +1,27 @@
+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 __());
+    };
+})();
+import { ItemStash } from "../item-stash.model";
+var GenericStash = /** @class */ (function (_super) {
+    __extends(GenericStash, _super); /* implements IItemStash<IItemBase>*/
+    function GenericStash() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GenericStash.prototype.deserialize = function (serialized) {
+        throw new Error("Method not implemented.");
+    };
+    return GenericStash;
+}(ItemStash));
+export { GenericStash };

package/dist/esm/shared/models/items/stashes-base/index.js

@@ -0,0 +1,2 @@
+export * from './generic-stash';
+export * from './infinite-stash';

package/dist/esm/shared/models/items/stashes-base/infinite-stash.js

@@ -0,0 +1,34 @@
+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 __());
+    };
+})();
+import { ItemStash } from "../item-stash.model";
+var InfiniteStash = /** @class */ (function (_super) {
+    __extends(InfiniteStash, _super); /* implements IItemStash<IItemBase>*/
+    function InfiniteStash() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    InfiniteStash.prototype.add = function (_item, slot) {
+        return true;
+    };
+    InfiniteStash.prototype.consume = function (_item, _amount) { };
+    InfiniteStash.prototype.has = function (_itemIdentifier) {
+        return true;
+    };
+    InfiniteStash.prototype.deserialize = function (serialized) {
+        throw new Error("Method not implemented.");
+    };
+    return InfiniteStash;
+}(ItemStash));
+export { InfiniteStash };

package/dist/esm/shared/models/items/weapons/index.js

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

package/dist/esm/shared/models/items/weapons/weapon-item.js

@@ -0,0 +1,71 @@
+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 __());
+    };
+})();
+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);
+};
+import { Item } from "../item.model";
+var WeaponItem = /** @class */ (function (_super) {
+    __extends(WeaponItem, _super);
+    function WeaponItem() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(WeaponItem.prototype, "amount", {
+        get: function () {
+            return this.value.ammo;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WeaponItem.prototype, "weight", {
+        get: function () {
+            return this.amount * this.weightPerUnit;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WeaponItem.prototype.add = function (amount) {
+        this.value = __assign(__assign({}, this.value), { ammo: Math.max(0, this.value.ammo + amount) });
+        return this;
+    };
+    WeaponItem.prototype.consume = function (amount) {
+        return this.add(-amount);
+    };
+    WeaponItem.prototype.empty = function () {
+        return this.add(-this.value.ammo);
+    };
+    WeaponItem.prototype.serialize = function () {
+        var _a;
+        return (_a = {},
+            _a[this.identifier] = this.value,
+            _a);
+    };
+    WeaponItem.prototype.deserialize = function (serialized) {
+        var _a = Object.entries(serialized)[0], identifier = _a[0], value = _a[1];
+        this.identifier = identifier;
+        this.value = value;
+        return this;
+    };
+    return WeaponItem;
+}(Item));
+export { WeaponItem };

package/dist/types/shared/index.d.ts

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

package/dist/types/shared/models/businesses/business.interfaces.d.ts

@@ -0,0 +1,5 @@
+import { Business } from "./business.model";
+export interface IBusinessInteractRequest {
+    by: number;
+    business: Business;
+}