@medusajs/pricing 0.1.10 → 0.1.11

package/dist/models/price.js

@@ -0,0 +1,167 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const core_1 = require("@mikro-orm/core");
+const price_list_1 = __importDefault(require("./price-list"));
+const price_rule_1 = __importDefault(require("./price-rule"));
+const price_set_1 = __importDefault(require("./price-set"));
+const tableName = "price";
+const PriceDeletedAtIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: tableName,
+    columns: "deleted_at",
+    where: "deleted_at IS NOT NULL",
+});
+const PricePriceSetIdIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: tableName,
+    columns: "price_set_id",
+    where: "deleted_at IS NULL",
+});
+const PricePriceListIdIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: tableName,
+    columns: "price_list_id",
+    where: "deleted_at IS NULL",
+});
+const PriceCurrencyCodeIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: tableName,
+    columns: "currency_code",
+    where: "deleted_at IS NULL",
+});
+let Price = class Price {
+    constructor() {
+        this.title = null;
+        this.min_quantity = null;
+        this.max_quantity = null;
+        this.rules_count = 0;
+        this.price_rules = new core_1.Collection(this);
+        this.price_list_id = null;
+        this.price_list = null;
+        this.deleted_at = null;
+    }
+    onCreate() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "price");
+        this.price_set_id ?? (this.price_set_id = this.price_set?.id);
+        this.price_list_id ?? (this.price_list_id = this.price_list?.id);
+    }
+    onInit() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "price");
+        this.price_set_id ?? (this.price_set_id = this.price_set?.id);
+        this.price_list_id ?? (this.price_list_id = this.price_list?.id);
+    }
+};
+__decorate([
+    (0, core_1.PrimaryKey)({ columnType: "text" }),
+    __metadata("design:type", String)
+], Price.prototype, "id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], Price.prototype, "title", void 0);
+__decorate([
+    PriceCurrencyCodeIndex.MikroORMIndex(),
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], Price.prototype, "currency_code", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "numeric", serializer: Number }),
+    __metadata("design:type", Number)
+], Price.prototype, "amount", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "numeric", nullable: true }),
+    __metadata("design:type", Object)
+], Price.prototype, "min_quantity", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "numeric", nullable: true }),
+    __metadata("design:type", Object)
+], Price.prototype, "max_quantity", void 0);
+__decorate([
+    PricePriceSetIdIndex.MikroORMIndex(),
+    (0, core_1.ManyToOne)(() => price_set_1.default, {
+        columnType: "text",
+        mapToPk: true,
+        fieldName: "price_set_id",
+        onDelete: "cascade",
+    }),
+    __metadata("design:type", String)
+], Price.prototype, "price_set_id", void 0);
+__decorate([
+    (0, core_1.ManyToOne)(() => price_set_1.default, { persist: false }),
+    __metadata("design:type", price_set_1.default)
+], Price.prototype, "price_set", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "integer", default: 0 }),
+    __metadata("design:type", Number)
+], Price.prototype, "rules_count", void 0);
+__decorate([
+    (0, core_1.OneToMany)({
+        entity: () => price_rule_1.default,
+        mappedBy: (pr) => pr.price,
+        cascade: [core_1.Cascade.PERSIST, "soft-remove"],
+    }),
+    __metadata("design:type", Object)
+], Price.prototype, "price_rules", void 0);
+__decorate([
+    PricePriceListIdIndex.MikroORMIndex(),
+    (0, core_1.ManyToOne)(() => price_list_1.default, {
+        columnType: "text",
+        mapToPk: true,
+        nullable: true,
+        fieldName: "price_list_id",
+        onDelete: "cascade",
+    }),
+    __metadata("design:type", Object)
+], Price.prototype, "price_list_id", void 0);
+__decorate([
+    (0, core_1.ManyToOne)(() => price_list_1.default, { persist: false, nullable: true }),
+    __metadata("design:type", Object)
+], Price.prototype, "price_list", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], Price.prototype, "created_at", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        onUpdate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], Price.prototype, "updated_at", void 0);
+__decorate([
+    PriceDeletedAtIndex.MikroORMIndex(),
+    (0, core_1.Property)({ columnType: "timestamptz", nullable: true }),
+    __metadata("design:type", Object)
+], Price.prototype, "deleted_at", void 0);
+__decorate([
+    (0, core_1.BeforeCreate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Price.prototype, "onCreate", null);
+__decorate([
+    (0, core_1.OnInit)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Price.prototype, "onInit", null);
+Price = __decorate([
+    (0, core_1.Entity)({ tableName }),
+    (0, core_1.Filter)(utils_1.DALUtils.mikroOrmSoftDeletableFilterOptions)
+], Price);
+exports.default = Price;

package/dist/models/rule-type.d.ts

@@ -10,6 +10,7 @@ declare class RuleType {
     price_sets: Collection<PriceSet, object>;
     created_at: Date;
     updated_at: Date;
+    deleted_at: Date | null;
     onCreate(): void;
     onInit(): void;
 }

package/dist/models/rule-type.js

@@ -15,9 +15,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/utils");
 const core_1 = require("@mikro-orm/core");
 const price_set_1 = __importDefault(require("./price-set"));
+const tableName = "rule_type";
+const RuleTypeDeletedAtIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: tableName,
+    columns: "deleted_at",
+    where: "deleted_at IS NOT NULL",
+});
+const RuleTypeRuleAttributeIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: tableName,
+    columns: "rule_attribute",
+    where: "deleted_at IS NULL",
+});
 let RuleType = class RuleType {
     constructor() {
         this.price_sets = new core_1.Collection(this);
+        this.deleted_at = null;
     }
     onCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "rul-typ");
@@ -35,7 +47,8 @@ __decorate([
     __metadata("design:type", String)
 ], RuleType.prototype, "name", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "text", index: "IDX_rule_type_rule_attribute" }),
+    RuleTypeRuleAttributeIndex.MikroORMIndex(),
+    (0, core_1.Property)({ columnType: "text" }),
     __metadata("design:type", String)
 ], RuleType.prototype, "rule_attribute", void 0);
 __decorate([
@@ -63,6 +76,11 @@ __decorate([
     }),
     __metadata("design:type", Date)
 ], RuleType.prototype, "updated_at", void 0);
+__decorate([
+    RuleTypeDeletedAtIndex.MikroORMIndex(),
+    (0, core_1.Property)({ columnType: "timestamptz", nullable: true }),
+    __metadata("design:type", Object)
+], RuleType.prototype, "deleted_at", void 0);
 __decorate([
     (0, core_1.BeforeCreate)(),
     __metadata("design:type", Function),
@@ -76,6 +94,7 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], RuleType.prototype, "onInit", null);
 RuleType = __decorate([
-    (0, core_1.Entity)()
+    (0, core_1.Entity)({ tableName }),
+    (0, core_1.Filter)(utils_1.DALUtils.mikroOrmSoftDeletableFilterOptions)
 ], RuleType);
 exports.default = RuleType;

package/dist/repositories/pricing.js

@@ -33,22 +33,25 @@ class PricingRepository extends utils_1.MikroOrmBase {
         const date = new Date().toISOString();
         // Gets all the price set money amounts where rules match for each of the contexts
         // that the price set is configured for
-        const psmaSubQueryKnex = knex({
-            psma: "price_set_money_amount",
+        const priceSubQueryKnex = knex({
+            price: "price",
         })
             .select({
-            id: "psma1.id",
-            price_set_id: "psma1.price_set_id",
-            money_amount_id: "psma1.money_amount_id",
-            rules_count: "psma1.rules_count",
-            price_list_id: "psma1.price_list_id",
+            id: "price1.id",
+            amount: "price1.amount",
+            min_quantity: "price1.min_quantity",
+            max_quantity: "price1.max_quantity",
+            currency_code: "price1.currency_code",
+            price_set_id: "price1.price_set_id",
+            rules_count: "price1.rules_count",
+            price_list_id: "price1.price_list_id",
             pl_rules_count: "pl.rules_count",
             pl_type: "pl.type",
-            has_price_list: knex.raw("case when psma1.price_list_id IS NULL then False else True end"),
+            has_price_list: knex.raw("case when price1.price_list_id IS NULL then False else True end"),
         })
-            .leftJoin("price_set_money_amount as psma1", "psma1.id", "psma1.id")
-            .leftJoin("price_rule as pr", "pr.price_set_money_amount_id", "psma1.id")
-            .leftJoin("price_list as pl", "pl.id", "psma1.price_list_id")
+            .leftJoin("price as price1", "price1.id", "price1.id")
+            .leftJoin("price_rule as pr", "pr.price_id", "price1.id")
+            .leftJoin("price_list as pl", "pl.id", "price1.price_list_id")
             .leftJoin("price_list_rule as plr", "plr.price_list_id", "pl.id")
             .leftJoin("price_list_rule_value as plrv", "plrv.price_list_rule_id", "plr.id")
             .leftJoin("rule_type as plrt", "plrt.id", "plr.rule_type_id")
@@ -57,21 +60,21 @@ class PricingRepository extends utils_1.MikroOrmBase {
             { column: "rules_count", order: "desc" },
             { column: "pl.rules_count", order: "desc" },
         ])
-            .groupBy("psma1.id", "pl.id")
-            .having(knex.raw("count(DISTINCT rt.rule_attribute) = psma1.rules_count AND psma1.price_list_id IS NULL"))
-            .orHaving(knex.raw("count(DISTINCT plrt.rule_attribute) = pl.rules_count AND psma1.price_list_id IS NOT NULL"));
-        psmaSubQueryKnex.orWhere((q) => {
+            .groupBy("price1.id", "pl.id")
+            .having(knex.raw("count(DISTINCT rt.rule_attribute) = price1.rules_count AND price1.price_list_id IS NULL"))
+            .orHaving(knex.raw("count(DISTINCT plrt.rule_attribute) = pl.rules_count AND price1.price_list_id IS NOT NULL"));
+        priceSubQueryKnex.orWhere((q) => {
             for (const [key, value] of Object.entries(context)) {
                 q.orWhere({
                     "rt.rule_attribute": key,
                     "pr.value": value,
                 });
             }
-            q.orWhere("psma1.rules_count", "=", 0);
-            q.whereNull("psma1.price_list_id");
+            q.orWhere("price1.rules_count", "=", 0);
+            q.whereNull("price1.price_list_id");
         });
-        psmaSubQueryKnex.orWhere((q) => {
-            q.whereNotNull("psma1.price_list_id")
+        priceSubQueryKnex.orWhere((q) => {
+            q.whereNotNull("price1.price_list_id")
                 .andWhere(function () {
                 this.whereNull("pl.starts_at").orWhere("pl.starts_at", "<=", date);
             })
@@ -96,9 +99,9 @@ class PricingRepository extends utils_1.MikroOrmBase {
                                 "pr.value": value,
                             });
                         }
-                        this.andWhere("psma1.rules_count", ">", 0);
+                        this.andWhere("price1.rules_count", ">", 0);
                     });
-                    this.orWhere("psma1.rules_count", "=", 0);
+                    this.orWhere("price1.rules_count", "=", 0);
                 });
             });
         });
@@ -106,37 +109,36 @@ class PricingRepository extends utils_1.MikroOrmBase {
             ps: "price_set",
         })
             .select({
-            id: "ma.id",
+            id: "price.id",
             price_set_id: "ps.id",
-            amount: "ma.amount",
-            min_quantity: "ma.min_quantity",
-            max_quantity: "ma.max_quantity",
-            currency_code: "ma.currency_code",
+            amount: "price.amount",
+            min_quantity: "price.min_quantity",
+            max_quantity: "price.max_quantity",
+            currency_code: "price.currency_code",
             default_priority: "rt.default_priority",
-            rules_count: "psma.rules_count",
-            pl_rules_count: "psma.pl_rules_count",
-            price_list_type: "psma.pl_type",
-            price_list_id: "psma.price_list_id",
+            rules_count: "price.rules_count",
+            pl_rules_count: "price.pl_rules_count",
+            price_list_type: "price.pl_type",
+            price_list_id: "price.price_list_id",
         })
-            .join(psmaSubQueryKnex.as("psma"), "psma.price_set_id", "ps.id")
-            .join("money_amount as ma", "ma.id", "psma.money_amount_id")
-            .leftJoin("price_rule as pr", "pr.price_set_money_amount_id", "psma.id")
+            .join(priceSubQueryKnex.as("price"), "price.price_set_id", "ps.id")
+            .leftJoin("price_rule as pr", "pr.price_id", "price.id")
             .leftJoin("rule_type as rt", "rt.id", "pr.rule_type_id")
             .whereIn("ps.id", pricingFilters.id)
-            .andWhere("ma.currency_code", "=", currencyCode)
+            .andWhere("price.currency_code", "=", currencyCode)
             .orderBy([
-            { column: "psma.has_price_list", order: "asc" },
+            { column: "price.has_price_list", order: "asc" },
             { column: "amount", order: "asc" },
             { column: "rules_count", order: "desc" },
             { column: "default_priority", order: "desc" },
         ]);
         if (quantity) {
-            priceSetQueryKnex.where("ma.min_quantity", "<=", quantity);
-            priceSetQueryKnex.andWhere("ma.max_quantity", ">=", quantity);
+            priceSetQueryKnex.where("price.min_quantity", "<=", quantity);
+            priceSetQueryKnex.andWhere("price.max_quantity", ">=", quantity);
         }
         else {
             priceSetQueryKnex.andWhere(function () {
-                this.andWhere("ma.min_quantity", "<=", "1").orWhereNull("ma.min_quantity");
+                this.andWhere("price.min_quantity", "<=", "1").orWhereNull("price.min_quantity");
             });
         }
         return await priceSetQueryKnex;

package/dist/scripts/seed.js

@@ -31,8 +31,8 @@ const path_1 = require("path");
 async function run({ options, logger, path, }) {
     logger ?? (logger = console);
     logger.info(`Loading seed data from ${path}...`);
-    const { moneyAmountsData, priceSetsData, priceSetMoneyAmountsData } = await Promise.resolve(`${(0, path_1.resolve)(process.cwd(), path)}`).then(s => __importStar(require(s))).catch((e) => {
-        logger?.error(`Failed to load seed data from ${path}. Please, provide a relative path and check that you export the following: priceSetsData, moneyAmountsData and priceSetMoneyAmountsData.${os_1.EOL}${e}`);
+    const { priceSetsData, pricesData } = await Promise.resolve(`${(0, path_1.resolve)(process.cwd(), path)}`).then(s => __importStar(require(s))).catch((e) => {
+        logger?.error(`Failed to load seed data from ${path}. Please, provide a relative path and check that you export the following: priceSetsData and pricesData.${os_1.EOL}${e}`);
         throw e;
     });
     const dbData = utils_1.ModulesSdkUtils.loadDatabaseConfig("pricing", options);
@@ -41,10 +41,9 @@ async function run({ options, logger, path, }) {
     const orm = await utils_1.DALUtils.mikroOrmCreateConnection(dbData, entities, pathToMigrations);
     const manager = orm.em.fork();
     try {
-        logger.info("Inserting price_sets & money_amounts");
-        await createMoneyAmounts(manager, moneyAmountsData);
+        logger.info("Inserting price_sets & prices");
         await createPriceSets(manager, priceSetsData);
-        await createPriceSetMoneyAmounts(manager, priceSetMoneyAmountsData);
+        await createPrices(manager, pricesData);
     }
     catch (e) {
         logger.error(`Failed to insert the seed data in the PostgreSQL database ${dbData.clientUrl}.${os_1.EOL}${e}`);
@@ -52,13 +51,6 @@ async function run({ options, logger, path, }) {
     await orm.close(true);
 }
 exports.run = run;
-async function createMoneyAmounts(manager, data) {
-    const moneyAmounts = data.map((moneyAmountData) => {
-        return manager.create(PricingModels.MoneyAmount, moneyAmountData);
-    });
-    await manager.persistAndFlush(moneyAmounts);
-    return moneyAmounts;
-}
 async function createPriceSets(manager, data) {
     const priceSets = data.map((priceSetData) => {
         return manager.create(PricingModels.PriceSet, priceSetData);
@@ -66,10 +58,10 @@ async function createPriceSets(manager, data) {
     await manager.persistAndFlush(priceSets);
     return priceSets;
 }
-async function createPriceSetMoneyAmounts(manager, data) {
-    const priceSetMoneyAmounts = data.map((priceSetMoneyAmountData) => {
-        return manager.create(PricingModels.PriceSetMoneyAmount, priceSetMoneyAmountData);
+async function createPrices(manager, data) {
+    const prices = data.map((priceData) => {
+        return manager.create(PricingModels.Price, priceData);
     });
-    await manager.persistAndFlush(priceSetMoneyAmounts);
-    return priceSetMoneyAmounts;
+    await manager.persistAndFlush(prices);
+    return prices;
 }

package/dist/services/index.d.ts

@@ -1,6 +1,3 @@
 export { default as PriceListService } from "./price-list";
-export { default as PriceListRuleService } from "./price-list-rule";
-export { default as PriceListRuleValueService } from "./price-list-rule-value";
-export { default as PriceRuleService } from "./price-rule";
 export { default as PricingModuleService } from "./pricing-module";
 export { default as RuleTypeService } from "./rule-type";

package/dist/services/index.js

@@ -3,15 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuleTypeService = exports.PricingModuleService = exports.PriceRuleService = exports.PriceListRuleValueService = exports.PriceListRuleService = exports.PriceListService = void 0;
+exports.RuleTypeService = exports.PricingModuleService = exports.PriceListService = void 0;
 var price_list_1 = require("./price-list");
 Object.defineProperty(exports, "PriceListService", { enumerable: true, get: function () { return __importDefault(price_list_1).default; } });
-var price_list_rule_1 = require("./price-list-rule");
-Object.defineProperty(exports, "PriceListRuleService", { enumerable: true, get: function () { return __importDefault(price_list_rule_1).default; } });
-var price_list_rule_value_1 = require("./price-list-rule-value");
-Object.defineProperty(exports, "PriceListRuleValueService", { enumerable: true, get: function () { return __importDefault(price_list_rule_value_1).default; } });
-var price_rule_1 = require("./price-rule");
-Object.defineProperty(exports, "PriceRuleService", { enumerable: true, get: function () { return __importDefault(price_rule_1).default; } });
 var pricing_module_1 = require("./pricing-module");
 Object.defineProperty(exports, "PricingModuleService", { enumerable: true, get: function () { return __importDefault(pricing_module_1).default; } });
 var rule_type_1 = require("./rule-type");

package/dist/services/pricing-module.d.ts

@@ -1,36 +1,32 @@
 import { AddPricesDTO, Context, DAL, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, RuleTypeDTO } from "@medusajs/types";
 import { ModulesSdkUtils } from "@medusajs/utils";
-import { MoneyAmount, PriceList, PriceListRule, PriceListRuleValue, PriceRule, PriceSet, PriceSetMoneyAmount, PriceSetMoneyAmountRules, PriceSetRuleType, RuleType } from "../models";
-import { PriceListRuleService, PriceListRuleValueService, PriceListService, PriceRuleService, RuleTypeService } from ".";
+import { Price, PriceList, PriceListRule, PriceListRuleValue, PriceRule, PriceSet, PriceSetRuleType, RuleType } from "../models";
+import { PriceListService, RuleTypeService } from ".";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     pricingRepository: PricingRepositoryService;
-    moneyAmountService: ModulesSdkTypes.InternalModuleService<any>;
     priceSetService: ModulesSdkTypes.InternalModuleService<any>;
-    priceSetMoneyAmountRulesService: ModulesSdkTypes.InternalModuleService<any>;
     ruleTypeService: RuleTypeService<any>;
-    priceRuleService: PriceRuleService<any>;
+    priceRuleService: ModulesSdkTypes.InternalModuleService<any>;
     priceSetRuleTypeService: ModulesSdkTypes.InternalModuleService<any>;
-    priceSetMoneyAmountService: ModulesSdkTypes.InternalModuleService<any>;
+    priceService: ModulesSdkTypes.InternalModuleService<any>;
     priceListService: PriceListService<any>;
-    priceListRuleService: PriceListRuleService<any>;
-    priceListRuleValueService: PriceListRuleValueService<any>;
+    priceListRuleService: ModulesSdkTypes.InternalModuleService<any>;
+    priceListRuleValueService: ModulesSdkTypes.InternalModuleService<any>;
 };
 declare const PricingModuleService_base: new (container: InjectedDependencies) => ModulesSdkUtils.AbstractModuleService<InjectedDependencies, PriceSetDTO, {
-    MoneyAmount: {
-        dto: PricingTypes.MoneyAmountDTO;
-    };
-    PriceSetMoneyAmount: {
-        dto: PricingTypes.PriceSetMoneyAmountDTO;
-    };
-    PriceSetMoneyAmountRules: {
-        dto: PricingTypes.PriceSetMoneyAmountRulesDTO;
+    Price: {
+        dto: PricingTypes.PriceDTO;
     };
     PriceRule: {
         dto: PricingTypes.PriceRuleDTO;
+        create: PricingTypes.CreatePriceRuleDTO;
+        update: PricingTypes.UpdatePriceRuleDTO;
     };
     RuleType: {
         dto: PricingTypes.RuleTypeDTO;
+        create: PricingTypes.CreateRuleTypeDTO;
+        update: PricingTypes.UpdateRuleTypeDTO;
     };
     PriceList: {
         dto: PricingTypes.PriceListDTO;
@@ -39,21 +35,19 @@ declare const PricingModuleService_base: new (container: InjectedDependencies) =
         dto: PricingTypes.PriceListRuleDTO;
     };
 }>;
-export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet, TMoneyAmount extends MoneyAmount = MoneyAmount, TRuleType extends RuleType = RuleType, TPriceSetMoneyAmountRules extends PriceSetMoneyAmountRules = PriceSetMoneyAmountRules, TPriceRule extends PriceRule = PriceRule, TPriceSetRuleType extends PriceSetRuleType = PriceSetRuleType, TPriceSetMoneyAmount extends PriceSetMoneyAmount = PriceSetMoneyAmount, TPriceList extends PriceList = PriceList, TPriceListRule extends PriceListRule = PriceListRule, TPriceListRuleValue extends PriceListRuleValue = PriceListRuleValue> extends PricingModuleService_base implements PricingTypes.IPricingModuleService {
+export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet, TRuleType extends RuleType = RuleType, TPriceRule extends PriceRule = PriceRule, TPriceSetRuleType extends PriceSetRuleType = PriceSetRuleType, TPrice extends Price = Price, TPriceList extends PriceList = PriceList, TPriceListRule extends PriceListRule = PriceListRule, TPriceListRuleValue extends PriceListRuleValue = PriceListRuleValue> extends PricingModuleService_base implements PricingTypes.IPricingModuleService {
     protected readonly moduleDeclaration: InternalModuleDeclaration;
     protected baseRepository_: DAL.RepositoryService;
     protected readonly pricingRepository_: PricingRepositoryService;
-    protected readonly moneyAmountService_: ModulesSdkTypes.InternalModuleService<TMoneyAmount>;
     protected readonly ruleTypeService_: RuleTypeService<TRuleType>;
     protected readonly priceSetService_: ModulesSdkTypes.InternalModuleService<TPriceSet>;
-    protected readonly priceSetMoneyAmountRulesService_: ModulesSdkTypes.InternalModuleService<TPriceSetMoneyAmountRules>;
-    protected readonly priceRuleService_: PriceRuleService<TPriceRule>;
+    protected readonly priceRuleService_: ModulesSdkTypes.InternalModuleService<TPriceRule>;
     protected readonly priceSetRuleTypeService_: ModulesSdkTypes.InternalModuleService<TPriceSetRuleType>;
-    protected readonly priceSetMoneyAmountService_: ModulesSdkTypes.InternalModuleService<TPriceSetMoneyAmount>;
+    protected readonly priceService_: ModulesSdkTypes.InternalModuleService<TPrice>;
     protected readonly priceListService_: PriceListService<TPriceList>;
-    protected readonly priceListRuleService_: PriceListRuleService<TPriceListRule>;
-    protected readonly priceListRuleValueService_: PriceListRuleValueService<TPriceListRuleValue>;
-    constructor({ baseRepository, pricingRepository, moneyAmountService, ruleTypeService, priceSetService, priceSetMoneyAmountRulesService, priceRuleService, priceSetRuleTypeService, priceSetMoneyAmountService, priceListService, priceListRuleService, priceListRuleValueService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    protected readonly priceListRuleService_: ModulesSdkTypes.InternalModuleService<TPriceListRule>;
+    protected readonly priceListRuleValueService_: ModulesSdkTypes.InternalModuleService<TPriceListRuleValue>;
+    constructor({ baseRepository, pricingRepository, ruleTypeService, priceSetService, priceRuleService, priceSetRuleTypeService, priceService, priceListService, priceListRuleService, priceListRuleValueService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
     __joinerConfig(): ModuleJoinerConfig;
     calculatePrices(pricingFilters: PricingFilters, pricingContext?: PricingContext, sharedContext?: Context): Promise<PricingTypes.CalculatedPriceSet[]>;
     create(data: PricingTypes.CreatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
@@ -67,16 +61,8 @@ export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet,
     protected addPrices_(input: AddPricesDTO[], sharedContext?: Context): Promise<void>;
     removeRules(data: PricingTypes.RemovePriceSetRulesDTO[], sharedContext?: Context): Promise<void>;
     update(data: PricingTypes.UpdatePriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
-    createMoneyAmounts(data: PricingTypes.CreateMoneyAmountDTO[], sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
-    updateMoneyAmounts(data: PricingTypes.UpdateMoneyAmountDTO[], sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
-    createRuleTypes(data: PricingTypes.CreateRuleTypeDTO[], sharedContext?: Context): Promise<PricingTypes.RuleTypeDTO[]>;
-    updateRuleTypes(data: PricingTypes.UpdateRuleTypeDTO[], sharedContext?: Context): Promise<PricingTypes.RuleTypeDTO[]>;
-    createPriceSetMoneyAmountRules(data: PricingTypes.CreatePriceSetMoneyAmountRulesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO[]>;
-    updatePriceSetMoneyAmountRules(data: PricingTypes.UpdatePriceSetMoneyAmountRulesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO[]>;
-    createPriceRules(data: PricingTypes.CreatePriceRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO[]>;
-    updatePriceRules(data: PricingTypes.UpdatePriceRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO[]>;
     createPriceLists(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
-    protected createPriceLists_(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
+    protected createPriceLists_(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<TPriceList[]>;
     updatePriceLists(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     protected updatePriceLists_(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     createPriceListRules(data: PricingTypes.CreatePriceListRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListRuleDTO[]>;