@medusajs/pricing 0.1.13-snapshot-20240718073308 → 0.1.13

package/dist/repositories/pricing.js

@@ -37,39 +37,44 @@ class PricingRepository extends utils_1.MikroOrmBase {
             price: "price",
         })
             .select({
-            id: "price.id",
-            amount: "price.amount",
-            raw_amount: "price.raw_amount",
-            min_quantity: "price.min_quantity",
-            max_quantity: "price.max_quantity",
-            currency_code: "price.currency_code",
-            price_set_id: "price.price_set_id",
-            rules_count: "price.rules_count",
-            price_list_id: "price.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 price.price_list_id IS NULL then False else True end"),
-        })
-            .leftJoin("price_rule as pr", "pr.price_id", "price.id")
-            .leftJoin("price_list as pl", function () {
-            this.on("pl.id", "price.price_list_id").andOn("pl.status", knex.raw("?", [utils_1.PriceListStatus.ACTIVE]));
+            has_price_list: knex.raw("case when price1.price_list_id IS NULL then False else True end"),
         })
+            .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")
-            .groupBy("price.id", "pl.id")
-            .having(knex.raw("count(DISTINCT pr.attribute) = price.rules_count AND price.price_list_id IS NULL"))
-            .orHaving(knex.raw("count(DISTINCT plr.attribute) = pl.rules_count AND price.price_list_id IS NOT NULL"));
+            .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")
+            .leftJoin("rule_type as rt", "rt.id", "pr.rule_type_id")
+            .orderBy([
+            { column: "rules_count", order: "desc" },
+            { column: "pl.rules_count", order: "desc" },
+        ])
+            .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({
-                    "pr.attribute": key,
+                    "rt.rule_attribute": key,
                     "pr.value": value,
                 });
             }
-            q.orWhere("price.rules_count", "=", 0);
-            q.whereNull("price.price_list_id");
+            q.orWhere("price1.rules_count", "=", 0);
+            q.whereNull("price1.price_list_id");
         });
         priceSubQueryKnex.orWhere((q) => {
-            q.whereNotNull("price.price_list_id")
+            q.whereNotNull("price1.price_list_id")
                 .andWhere(function () {
                 this.whereNull("pl.starts_at").orWhere("pl.starts_at", "<=", date);
             })
@@ -80,9 +85,9 @@ class PricingRepository extends utils_1.MikroOrmBase {
                 this.andWhere(function () {
                     for (const [key, value] of Object.entries(context)) {
                         this.orWhere({
-                            "plr.attribute": key,
+                            "plrt.rule_attribute": key,
                         });
-                        this.where("plr.value", "@>", JSON.stringify(Array.isArray(value) ? value : [value]));
+                        this.whereIn("plrv.value", [value]);
                     }
                     this.orWhere("pl.rules_count", "=", 0);
                 });
@@ -90,13 +95,13 @@ class PricingRepository extends utils_1.MikroOrmBase {
                     this.andWhere(function () {
                         for (const [key, value] of Object.entries(context)) {
                             this.orWhere({
-                                "pr.attribute": key,
+                                "rt.rule_attribute": key,
                                 "pr.value": value,
                             });
                         }
-                        this.andWhere("price.rules_count", ">", 0);
+                        this.andWhere("price1.rules_count", ">", 0);
                     });
-                    this.orWhere("price.rules_count", "=", 0);
+                    this.orWhere("price1.rules_count", "=", 0);
                 });
             });
         });
@@ -107,23 +112,25 @@ class PricingRepository extends utils_1.MikroOrmBase {
             id: "price.id",
             price_set_id: "ps.id",
             amount: "price.amount",
-            raw_amount: "price.raw_amount",
             min_quantity: "price.min_quantity",
             max_quantity: "price.max_quantity",
             currency_code: "price.currency_code",
+            default_priority: "rt.default_priority",
             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",
-            all_rules_count: knex.raw("COALESCE(price.rules_count, 0) + COALESCE(price.pl_rules_count, 0)"),
         })
             .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("price.currency_code", "=", currencyCode)
             .orderBy([
             { column: "price.has_price_list", order: "asc" },
-            { column: "all_rules_count", order: "desc" },
             { column: "amount", order: "asc" },
+            { column: "rules_count", order: "desc" },
+            { column: "default_priority", order: "desc" },
         ]);
         if (quantity) {
             priceSetQueryKnex.where("price.min_quantity", "<=", quantity);

package/dist/schema/index.d.ts

@@ -1,3 +1,2 @@
 export declare const schema = "\ntype PriceSet {\n  id: String!\n  money_amounts: [MoneyAmount]\n}\n\ntype MoneyAmount {\n  id: String!\n  currency_code: String\n  amount: Float\n  min_quantity: Float\n  max_quantity: Float\n}\n";
 export default schema;
-//# sourceMappingURL=index.d.ts.map

package/dist/scripts/bin/run-seed.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+declare const _default: Promise<void>;
+export default _default;

package/dist/scripts/bin/run-seed.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = require("os");
+const seed_1 = require("../seed");
+const args = process.argv;
+const path = args.pop();
+exports.default = (async () => {
+    const { config } = await Promise.resolve().then(() => __importStar(require("dotenv")));
+    config();
+    if (!path) {
+        throw new Error(`filePath is required.${os_1.EOL}Example: medusa-pricing-seed <filePath>`);
+    }
+    await (0, seed_1.run)({ path });
+})();

package/dist/scripts/seed.d.ts

@@ -0,0 +1,4 @@
+import { LoaderOptions, ModulesSdkTypes } from "@medusajs/types";
+export declare function run({ options, logger, path, }: Partial<Pick<LoaderOptions<ModulesSdkTypes.ModuleServiceInitializeOptions>, "options" | "logger">> & {
+    path: string;
+}): Promise<void>;

package/dist/scripts/seed.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const utils_1 = require("@medusajs/utils");
+const PricingModels = __importStar(require("../models"));
+const os_1 = require("os");
+const path_1 = require("path");
+async function run({ options, logger, path, }) {
+    logger ?? (logger = console);
+    logger.info(`Loading seed data from ${path}...`);
+    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);
+    const entities = Object.values(PricingModels);
+    const pathToMigrations = __dirname + "/../migrations";
+    const orm = await utils_1.DALUtils.mikroOrmCreateConnection(dbData, entities, pathToMigrations);
+    const manager = orm.em.fork();
+    try {
+        logger.info("Inserting price_sets & prices");
+        await createPriceSets(manager, priceSetsData);
+        await createPrices(manager, pricesData);
+    }
+    catch (e) {
+        logger.error(`Failed to insert the seed data in the PostgreSQL database ${dbData.clientUrl}.${os_1.EOL}${e}`);
+    }
+    await orm.close(true);
+}
+exports.run = run;
+async function createPriceSets(manager, data) {
+    const priceSets = data.map((priceSetData) => {
+        return manager.create(PricingModels.PriceSet, priceSetData);
+    });
+    await manager.persistAndFlush(priceSets);
+    return priceSets;
+}
+async function createPrices(manager, data) {
+    const prices = data.map((priceData) => {
+        return manager.create(PricingModels.Price, priceData);
+    });
+    await manager.persistAndFlush(prices);
+    return prices;
+}

package/dist/services/index.d.ts

@@ -1,2 +1,3 @@
+export { default as PriceListService } from "./price-list";
 export { default as PricingModuleService } from "./pricing-module";
-//# sourceMappingURL=index.d.ts.map
+export { default as RuleTypeService } from "./rule-type";

package/dist/services/index.js

@@ -3,6 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PricingModuleService = 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 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");
+Object.defineProperty(exports, "RuleTypeService", { enumerable: true, get: function () { return __importDefault(rule_type_1).default; } });

package/dist/services/price-list.d.ts

@@ -0,0 +1,16 @@
+import { Context, DAL } from "@medusajs/types";
+import { PriceList } from "../models";
+import { ServiceTypes } from "../types";
+type InjectedDependencies = {
+    priceListRepository: DAL.RepositoryService;
+};
+declare const PriceListService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => import("@medusajs/types").InternalModuleService<TEntity_1, InjectedDependencies>;
+export default class PriceListService<TEntity extends PriceList = PriceList> extends PriceListService_base<TEntity> {
+    constructor(container: InjectedDependencies);
+    create(data: ServiceTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<TEntity[]>;
+    create(data: ServiceTypes.CreatePriceListDTO, sharedContext?: Context): Promise<TEntity>;
+    update(data: any[], sharedContext?: Context): Promise<TEntity[]>;
+    update(data: any, sharedContext?: Context): Promise<TEntity>;
+    protected normalizePriceListDate(data: (ServiceTypes.UpdatePriceListDTO | ServiceTypes.CreatePriceListDTO)[]): any[];
+}
+export {};

package/dist/services/price-list.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const _models_1 = require("../models");
+class PriceListService extends utils_1.ModulesSdkUtils.internalModuleServiceFactory(_models_1.PriceList) {
+    constructor(container) {
+        // @ts-ignore
+        super(...arguments);
+    }
+    async create(data, sharedContext) {
+        const data_ = Array.isArray(data) ? data : [data];
+        const priceLists = this.normalizePriceListDate(data_);
+        return await super.create(priceLists, sharedContext);
+    }
+    // TODO: Add support for selector? and then rm ts ignore
+    // @ts-ignore
+    async update(data, sharedContext) {
+        const data_ = Array.isArray(data) ? data : [data];
+        const priceLists = this.normalizePriceListDate(data_);
+        return await super.update(priceLists, sharedContext);
+    }
+    normalizePriceListDate(data) {
+        return data.map((priceListData) => {
+            if (!!priceListData.starts_at) {
+                priceListData.starts_at = (0, utils_1.GetIsoStringFromDate)(priceListData.starts_at);
+            }
+            if (!!priceListData.ends_at) {
+                priceListData.ends_at = (0, utils_1.GetIsoStringFromDate)(priceListData.ends_at);
+            }
+            return priceListData;
+        });
+    }
+}
+exports.default = PriceListService;

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

@@ -1,21 +1,21 @@
-import { AddPricesDTO, Context, CreatePriceRuleDTO, DAL, FindConfig, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, PricePreferenceDTO, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, UpsertPricePreferenceDTO, UpsertPriceSetDTO } from "@medusajs/types";
-import { Price, PriceList, PriceListRule, PricePreference, PriceRule, PriceSet } from "../models";
-import { ServiceTypes } from "../types";
-import { CreatePriceListDTO } from "src/types/services";
+import { AddPricesDTO, Context, CreatePriceRuleDTO, DAL, FindConfig, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, RuleTypeDTO, UpsertPriceSetDTO } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
+import { Price, PriceList, PriceListRule, PriceListRuleValue, PriceRule, PriceSet, PriceSetRuleType, RuleType } from "../models";
+import { PriceListService, RuleTypeService } from ".";
+import { UpdatePriceSetInput } from "src/types/services";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     pricingRepository: PricingRepositoryService;
-    priceSetService: ModulesSdkTypes.IMedusaInternalService<any>;
-    priceRuleService: ModulesSdkTypes.IMedusaInternalService<any>;
-    priceService: ModulesSdkTypes.IMedusaInternalService<any>;
-    priceListService: ModulesSdkTypes.IMedusaInternalService<any>;
-    pricePreferenceService: ModulesSdkTypes.IMedusaInternalService<any>;
-    priceListRuleService: ModulesSdkTypes.IMedusaInternalService<any>;
+    priceSetService: ModulesSdkTypes.InternalModuleService<any>;
+    ruleTypeService: RuleTypeService<any>;
+    priceRuleService: ModulesSdkTypes.InternalModuleService<any>;
+    priceSetRuleTypeService: ModulesSdkTypes.InternalModuleService<any>;
+    priceService: ModulesSdkTypes.InternalModuleService<any>;
+    priceListService: PriceListService<any>;
+    priceListRuleService: ModulesSdkTypes.InternalModuleService<any>;
+    priceListRuleValueService: ModulesSdkTypes.InternalModuleService<any>;
 };
-declare const PricingModuleService_base: import("@medusajs/utils/dist/modules-sdk/types/medusa-service").MedusaServiceReturnType<{
-    PriceSet: {
-        dto: PricingTypes.PriceSetDTO;
-    };
+declare const PricingModuleService_base: new (container: InjectedDependencies) => ModulesSdkUtils.AbstractModuleService<InjectedDependencies, PriceSetDTO, {
     Price: {
         dto: PricingTypes.PriceDTO;
     };
@@ -24,81 +24,68 @@ declare const PricingModuleService_base: import("@medusajs/utils/dist/modules-sd
         create: PricingTypes.CreatePriceRuleDTO;
         update: PricingTypes.UpdatePriceRuleDTO;
     };
+    RuleType: {
+        dto: PricingTypes.RuleTypeDTO;
+        create: PricingTypes.CreateRuleTypeDTO;
+        update: PricingTypes.UpdateRuleTypeDTO;
+    };
     PriceList: {
         dto: PricingTypes.PriceListDTO;
     };
     PriceListRule: {
         dto: PricingTypes.PriceListRuleDTO;
     };
-    PricePreference: {
-        dto: any;
-    };
 }>;
-export default class PricingModuleService 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 priceSetService_: ModulesSdkTypes.IMedusaInternalService<PriceSet>;
-    protected readonly priceRuleService_: ModulesSdkTypes.IMedusaInternalService<PriceRule>;
-    protected readonly priceService_: ModulesSdkTypes.IMedusaInternalService<Price>;
-    protected readonly priceListService_: ModulesSdkTypes.IMedusaInternalService<PriceList>;
-    protected readonly priceListRuleService_: ModulesSdkTypes.IMedusaInternalService<PriceListRule>;
-    protected readonly pricePreferenceService_: ModulesSdkTypes.IMedusaInternalService<PricePreference>;
-    constructor({ baseRepository, pricingRepository, priceSetService, priceRuleService, priceService, pricePreferenceService, priceListService, priceListRuleService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    protected readonly ruleTypeService_: RuleTypeService<TRuleType>;
+    protected readonly priceSetService_: ModulesSdkTypes.InternalModuleService<TPriceSet>;
+    protected readonly priceRuleService_: ModulesSdkTypes.InternalModuleService<TPriceRule>;
+    protected readonly priceSetRuleTypeService_: ModulesSdkTypes.InternalModuleService<TPriceSetRuleType>;
+    protected readonly priceService_: ModulesSdkTypes.InternalModuleService<TPrice>;
+    protected readonly priceListService_: PriceListService<TPriceList>;
+    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;
     private setupCalculatedPriceConfig_;
-    retrievePriceSet(id: string, config?: FindConfig<PriceSetDTO> | undefined, sharedContext?: Context | undefined): Promise<PriceSetDTO>;
-    listPriceSets(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PriceSetDTO[]>;
-    listAndCountPriceSets(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<[PriceSetDTO[], number]>;
+    list(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PriceSetDTO[]>;
+    listAndCount(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<[PriceSetDTO[], number]>;
     calculatePrices(pricingFilters: PricingFilters, pricingContext?: PricingContext, sharedContext?: Context): Promise<PricingTypes.CalculatedPriceSet[]>;
-    createPriceSets(data: PricingTypes.CreatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
-    createPriceSets(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
-    upsertPriceSets(data: UpsertPriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
-    upsertPriceSets(data: UpsertPriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
-    updatePriceSets(id: string, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
-    updatePriceSets(selector: PricingTypes.FilterablePriceSetProps, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO[]>;
-    protected updatePriceSets_(data: ServiceTypes.UpdatePriceSetInput[], sharedContext?: Context): Promise<PriceSet[]>;
+    create(data: PricingTypes.CreatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
+    create(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
+    upsert(data: UpsertPriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
+    upsert(data: UpsertPriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
+    update(id: string, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
+    update(selector: PricingTypes.FilterablePriceSetProps, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO[]>;
     private normalizeUpdateData;
-    private normalizePrices;
+    protected update_(data: UpdatePriceSetInput[], sharedContext?: Context): Promise<PriceSet[]>;
+    addRules(data: PricingTypes.AddRulesDTO, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO>;
+    addRules(data: PricingTypes.AddRulesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
     addPrices(data: AddPricesDTO, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO>;
     addPrices(data: AddPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
+    removeRules(data: PricingTypes.RemovePriceSetRulesDTO[], sharedContext?: Context): Promise<void>;
     createPriceLists(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     updatePriceLists(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
+    createPriceListRules(data: PricingTypes.CreatePriceListRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListRuleDTO[]>;
+    createPriceListRules_(data: PricingTypes.CreatePriceListRuleDTO[], sharedContext?: Context): Promise<TPriceListRule[]>;
+    updatePriceListRules(data: PricingTypes.UpdatePriceListRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListRuleDTO[]>;
     updatePriceListPrices(data: PricingTypes.UpdatePriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceDTO[]>;
     removePrices(ids: string[], sharedContext?: Context): Promise<void>;
     addPriceListPrices(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceDTO[]>;
     setPriceListRules(data: PricingTypes.SetPriceListRulesDTO, sharedContext?: Context): Promise<PricingTypes.PriceListDTO>;
     removePriceListRules(data: PricingTypes.RemovePriceListRulesDTO, sharedContext?: Context): Promise<PricingTypes.PriceListDTO>;
-    createPricePreferences(data: PricingTypes.CreatePricePreferenceDTO, sharedContext?: Context): Promise<PricePreferenceDTO>;
-    createPricePreferences(data: PricingTypes.CreatePricePreferenceDTO[], sharedContext?: Context): Promise<PricePreferenceDTO[]>;
-    upsertPricePreferences(data: UpsertPricePreferenceDTO[], sharedContext?: Context): Promise<PricePreferenceDTO[]>;
-    upsertPricePreferences(data: UpsertPricePreferenceDTO, sharedContext?: Context): Promise<PricePreferenceDTO>;
-    updatePricePreferences(id: string, data: PricingTypes.UpdatePricePreferenceDTO, sharedContext?: Context): Promise<PricePreferenceDTO>;
-    updatePricePreferences(selector: PricingTypes.FilterablePricePreferenceProps, data: PricingTypes.UpdatePricePreferenceDTO, sharedContext?: Context): Promise<PricePreferenceDTO[]>;
-    protected createPricePreferences_(data: PricingTypes.CreatePricePreferenceDTO[], sharedContext?: Context): Promise<PricePreference[]>;
-    protected updatePricePreferences_(data: PricingTypes.UpdatePricePreferenceDTO[], sharedContext?: Context): Promise<PricePreference[]>;
-    protected createPriceSets_(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<PriceSet[]>;
-    protected addPrices_(input: AddPricesDTO[], sharedContext?: Context): Promise<Price[]>;
-    protected createPriceLists_(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<PriceList[]>;
-    protected updatePriceLists_(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PriceList[]>;
-    protected updatePriceListPrices_(data: PricingTypes.UpdatePriceListPricesDTO[], sharedContext?: Context): Promise<Price[]>;
+    protected create_(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<TPriceSet[]>;
+    protected addRules_(inputs: PricingTypes.AddRulesDTO[], sharedContext?: Context): Promise<TPriceSet[]>;
+    protected addPrices_(input: AddPricesDTO[], sharedContext?: Context): Promise<void>;
+    protected createPriceLists_(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<TPriceList[]>;
+    protected updatePriceLists_(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
+    protected updatePriceListPrices_(data: PricingTypes.UpdatePriceListPricesDTO[], sharedContext?: Context): Promise<TPrice[]>;
     protected removePrices_(ids: string[], sharedContext?: Context): Promise<void>;
-    protected addPriceListPrices_(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<Price[]>;
-    protected setPriceListRules_(data: PricingTypes.SetPriceListRulesDTO[], sharedContext?: Context): Promise<PriceList[]>;
-    protected removePriceListRules_(data: PricingTypes.RemovePriceListRulesDTO[], sharedContext?: Context): Promise<PriceList[]>;
-    protected normalizePriceListDate(data: (ServiceTypes.UpdatePriceListDTO | ServiceTypes.CreatePriceListDTO | CreatePriceListDTO)[]): any[];
-    protected normalizePriceSetConfig(config: FindConfig<PricingTypes.PriceSetDTO> | undefined): {
-        select?: string[] | undefined;
-        skip?: number | null | undefined;
-        take?: number | null | undefined;
-        relations?: string[] | undefined;
-        order?: {
-            [K: string]: "ASC" | "DESC";
-        } | undefined;
-        withDeleted?: boolean | undefined;
-        filters?: Record<string, any> | undefined;
-        options: Record<string, any>;
-    };
+    protected addPriceListPrices_(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<TPrice[]>;
+    protected setPriceListRules_(data: PricingTypes.SetPriceListRulesDTO[], sharedContext?: Context): Promise<TPriceList[]>;
+    protected removePriceListRules_(data: PricingTypes.RemovePriceListRulesDTO[], sharedContext?: Context): Promise<TPriceList[]>;
 }
 export {};
-//# sourceMappingURL=pricing-module.d.ts.map