@medusajs/pricing 0.1.8 → 0.1.9-next-20240208080225

package/dist/joiner-config.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.joinerConfig = exports.entityNameToLinkableKeysMap = exports.LinkableKeys = void 0;
 const modules_sdk_1 = require("@medusajs/modules-sdk");
 const _models_1 = require("./models");
+const schema_1 = __importDefault(require("./schema"));
 exports.LinkableKeys = {
     money_amount_id: _models_1.MoneyAmount.name,
     currency_code: _models_1.Currency.name,
@@ -23,45 +27,30 @@ exports.joinerConfig = {
     serviceName: modules_sdk_1.Modules.PRICING,
     primaryKeys: ["id"],
     linkableKeys: exports.LinkableKeys,
+    schema: schema_1.default,
     alias: [
         {
-            name: "price_set",
-        },
-        {
-            name: "price_sets",
-        },
-        {
-            name: "money_amount",
+            name: ["price_set", "price_sets"],
             args: {
-                methodSuffix: "MoneyAmounts",
+                entity: "PriceSet",
             },
         },
         {
-            name: "money_amounts",
+            name: ["money_amount", "money_amounts"],
             args: {
                 methodSuffix: "MoneyAmounts",
+                entity: "MoneyAmount",
             },
         },
         {
-            name: "currency",
-            args: {
-                methodSuffix: "Currencies",
-            },
-        },
-        {
-            name: "currencies",
+            name: ["currency", "currencies"],
             args: {
                 methodSuffix: "Currencies",
+                entity: "Currency",
             },
         },
         {
-            name: "price_list",
-            args: {
-                methodSuffix: "PriceLists",
-            },
-        },
-        {
-            name: "price_lists",
+            name: ["price_list", "price_lists"],
             args: {
                 methodSuffix: "PriceLists",
             },

package/dist/schema/index.d.ts

@@ -0,0 +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  currency: Currency\n  amount: Float\n  min_quantity: Float\n  max_quantity: Float\n}\n";
+export default schema;

package/dist/schema/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+exports.schema = `
+type PriceSet {
+  id: String!
+  money_amounts: [MoneyAmount]
+}
+
+type MoneyAmount {
+  id: String!
+  currency_code: String
+  currency: Currency
+  amount: Float
+  min_quantity: Float
+  max_quantity: Float
+}
+`;
+exports.default = exports.schema;

package/dist/services/index.d.ts

@@ -1,12 +1,6 @@
-export { default as CurrencyService } from "./currency";
-export { default as MoneyAmountService } from "./money-amount";
 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 PriceSetService } from "./price-set";
-export { default as PriceSetMoneyAmountService } from "./price-set-money-amount";
-export { default as PriceSetMoneyAmountRulesService } from "./price-set-money-amount-rules";
-export { default as PriceSetRuleTypeService } from "./price-set-rule-type";
 export { default as PricingModuleService } from "./pricing-module";
 export { default as RuleTypeService } from "./rule-type";

package/dist/services/index.js

@@ -3,11 +3,7 @@ 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.PriceSetRuleTypeService = exports.PriceSetMoneyAmountRulesService = exports.PriceSetMoneyAmountService = exports.PriceSetService = exports.PriceRuleService = exports.PriceListRuleValueService = exports.PriceListRuleService = exports.PriceListService = exports.MoneyAmountService = exports.CurrencyService = void 0;
-var currency_1 = require("./currency");
-Object.defineProperty(exports, "CurrencyService", { enumerable: true, get: function () { return __importDefault(currency_1).default; } });
-var money_amount_1 = require("./money-amount");
-Object.defineProperty(exports, "MoneyAmountService", { enumerable: true, get: function () { return __importDefault(money_amount_1).default; } });
+exports.RuleTypeService = exports.PricingModuleService = exports.PriceRuleService = exports.PriceListRuleValueService = exports.PriceListRuleService = 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");
@@ -16,14 +12,6 @@ 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 price_set_1 = require("./price-set");
-Object.defineProperty(exports, "PriceSetService", { enumerable: true, get: function () { return __importDefault(price_set_1).default; } });
-var price_set_money_amount_1 = require("./price-set-money-amount");
-Object.defineProperty(exports, "PriceSetMoneyAmountService", { enumerable: true, get: function () { return __importDefault(price_set_money_amount_1).default; } });
-var price_set_money_amount_rules_1 = require("./price-set-money-amount-rules");
-Object.defineProperty(exports, "PriceSetMoneyAmountRulesService", { enumerable: true, get: function () { return __importDefault(price_set_money_amount_rules_1).default; } });
-var price_set_rule_type_1 = require("./price-set-rule-type");
-Object.defineProperty(exports, "PriceSetRuleTypeService", { enumerable: true, get: function () { return __importDefault(price_set_rule_type_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/price-list-rule-value.d.ts

@@ -1,18 +1,13 @@
 import { Context, DAL } from "@medusajs/types";
-import { ModulesSdkUtils } from "@medusajs/utils";
 import { PriceListRuleValue } from "../models";
 import { ServiceTypes } from "../types";
 type InjectedDependencies = {
     priceListRuleValueRepository: DAL.RepositoryService;
 };
-declare const PriceListRuleValueService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {
-    update: ServiceTypes.UpdatePriceListRuleValueDTO;
-}, {
-    list: ServiceTypes.FilterablePriceListRuleValueProps;
-    listAndCount: ServiceTypes.FilterablePriceListRuleValueProps;
-}>;
+declare const PriceListRuleValueService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => import("@medusajs/types").InternalModuleService<TEntity_1, InjectedDependencies>;
 export default class PriceListRuleValueService<TEntity extends PriceListRuleValue = PriceListRuleValue> extends PriceListRuleValueService_base<TEntity> {
     constructor(container: InjectedDependencies);
-    create(data: ServiceTypes.CreatePriceListRuleValueDTO[], context?: Context): Promise<TEntity[]>;
+    create(data: ServiceTypes.CreatePriceListRuleValueDTO[], context: Context): Promise<TEntity[]>;
+    create(data: ServiceTypes.CreatePriceListRuleValueDTO, context: Context): Promise<TEntity>;
 }
 export {};

package/dist/services/price-list-rule-value.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
-class PriceListRuleValueService extends utils_1.ModulesSdkUtils.abstractServiceFactory(_models_1.PriceListRuleValue) {
+class PriceListRuleValueService extends utils_1.ModulesSdkUtils.internalModuleServiceFactory(_models_1.PriceListRuleValue) {
     constructor(container) {
         // @ts-ignore
         super(...arguments);
     }
     async create(data, context = {}) {
-        const priceListRuleValues = data.map((priceRuleValueData) => {
+        const data_ = Array.isArray(data) ? data : [data];
+        const priceListRuleValues = data_.map((priceRuleValueData) => {
             const { price_list_rule_id: priceListRuleId, ...priceRuleValue } = priceRuleValueData;
             if (priceListRuleId) {
                 priceRuleValue.price_list_rule = priceListRuleId;

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

@@ -1,20 +1,15 @@
 import { Context, DAL } from "@medusajs/types";
-import { ModulesSdkUtils } from "@medusajs/utils";
 import { PriceListRule } from "../models";
 import { ServiceTypes } from "../types";
 type InjectedDependencies = {
     priceListRuleRepository: DAL.RepositoryService;
 };
-declare const PriceListRuleService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {
-    create: ServiceTypes.CreatePriceListRuleDTO;
-    update: ServiceTypes.UpdatePriceListRuleDTO;
-}, {
-    list: ServiceTypes.FilterablePriceListRuleProps;
-    listAndCount: ServiceTypes.FilterablePriceListRuleProps;
-}>;
+declare const PriceListRuleService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => import("@medusajs/types").InternalModuleService<TEntity_1, InjectedDependencies>;
 export default class PriceListRuleService<TEntity extends PriceListRule = PriceListRule> extends PriceListRuleService_base<TEntity> {
     constructor(container: InjectedDependencies);
-    create(data: ServiceTypes.CreatePriceListRuleDTO[], context?: Context): Promise<TEntity[]>;
-    update(data: ServiceTypes.UpdatePriceListRuleDTO[], context?: Context): Promise<TEntity[]>;
+    create(data: ServiceTypes.CreatePriceListRuleDTO[], sharedContext?: Context): Promise<TEntity[]>;
+    create(data: ServiceTypes.CreatePriceListRuleDTO, sharedContext?: Context): Promise<TEntity>;
+    update(data: ServiceTypes.UpdatePriceListRuleDTO[], context: Context): Promise<TEntity[]>;
+    update(data: ServiceTypes.UpdatePriceListRuleDTO, context: Context): Promise<TEntity>;
 }
 export {};

package/dist/services/price-list-rule.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
-class PriceListRuleService extends utils_1.ModulesSdkUtils.abstractServiceFactory(_models_1.PriceListRule) {
+class PriceListRuleService extends utils_1.ModulesSdkUtils.internalModuleServiceFactory(_models_1.PriceListRule) {
     constructor(container) {
         // @ts-ignore
         super(...arguments);
     }
     async create(data, context = {}) {
-        const priceListRule = data.map((priceListRule) => {
+        const data_ = Array.isArray(data) ? data : [data];
+        const priceListRule = data_.map((priceListRule) => {
             const { price_list_id: priceListId, rule_type_id: ruleTypeId, ...createData } = priceListRule;
             if (priceListId) {
                 createData.price_list = priceListId;
@@ -20,8 +21,11 @@ class PriceListRuleService extends utils_1.ModulesSdkUtils.abstractServiceFactor
         });
         return await super.create(priceListRule, context);
     }
+    // TODO add support for selector? and then rm ts ignore
+    // @ts-ignore
     async update(data, context = {}) {
-        const priceListRules = data.map((priceListRule) => {
+        const data_ = Array.isArray(data) ? data : [data];
+        const priceListRules = data_.map((priceListRule) => {
             const { price_list_id, rule_type_id, ...priceListRuleData } = priceListRule;
             if (price_list_id) {
                 priceListRuleData.price_list = price_list_id;

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

@@ -1,18 +1,16 @@
 import { Context, DAL } from "@medusajs/types";
-import { ModulesSdkUtils } from "@medusajs/utils";
 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) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {}, {
-    list: ServiceTypes.FilterablePriceListProps;
-    listAndCount: ServiceTypes.FilterablePriceListProps;
-}>;
+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[]>;
-    update(data: ServiceTypes.UpdatePriceListDTO[], 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

@@ -2,17 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
-class PriceListService extends utils_1.ModulesSdkUtils.abstractServiceFactory(_models_1.PriceList) {
+class PriceListService extends utils_1.ModulesSdkUtils.internalModuleServiceFactory(_models_1.PriceList) {
     constructor(container) {
         // @ts-ignore
         super(...arguments);
     }
     async create(data, sharedContext) {
-        const priceLists = this.normalizePriceListDate(data);
+        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 priceLists = this.normalizePriceListDate(data);
+        const data_ = Array.isArray(data) ? data : [data];
+        const priceLists = this.normalizePriceListDate(data_);
         return await super.update(priceLists, sharedContext);
     }
     normalizePriceListDate(data) {

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

@@ -1,18 +1,13 @@
 import { Context, DAL } from "@medusajs/types";
-import { ModulesSdkUtils } from "@medusajs/utils";
 import { PriceRule } from "../models";
 import { ServiceTypes } from "../types";
 type InjectedDependencies = {
     priceRuleRepository: DAL.RepositoryService;
 };
-declare const PriceRuleService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {
-    update: ServiceTypes.UpdatePriceRuleDTO;
-}, {
-    list: ServiceTypes.FilterablePriceRuleProps;
-    listAndCount: ServiceTypes.FilterablePriceRuleProps;
-}>;
+declare const PriceRuleService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => import("@medusajs/types").InternalModuleService<TEntity_1, InjectedDependencies>;
 export default class PriceRuleService<TEntity extends PriceRule = PriceRule> extends PriceRuleService_base<TEntity> {
     constructor(container: InjectedDependencies);
     create(data: ServiceTypes.CreatePriceRuleDTO[], sharedContext?: Context): Promise<TEntity[]>;
+    create(data: ServiceTypes.CreatePriceRuleDTO, sharedContext?: Context): Promise<TEntity>;
 }
 export {};

package/dist/services/price-rule.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
-class PriceRuleService extends utils_1.ModulesSdkUtils.abstractServiceFactory(_models_1.PriceRule) {
+class PriceRuleService extends utils_1.ModulesSdkUtils.internalModuleServiceFactory(_models_1.PriceRule) {
     constructor(container) {
         // @ts-ignore
         super(...arguments);
     }
-    async create(data, sharedContext) {
-        const toCreate = data.map((ruleData) => {
+    async create(data, sharedContext = {}) {
+        const data_ = Array.isArray(data) ? data : [data];
+        const toCreate = data_.map((ruleData) => {
             const ruleDataClone = { ...ruleData };
             ruleDataClone.rule_type ?? (ruleDataClone.rule_type = ruleData.rule_type_id);
             ruleDataClone.price_set ?? (ruleDataClone.price_set = ruleData.price_set_id);

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

@@ -1,43 +1,66 @@
-import { AddPricesDTO, Context, DAL, FindConfig, InternalModuleDeclaration, ModuleJoinerConfig, MoneyAmountDTO, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, RestoreReturn } from "@medusajs/types";
+import { AddPricesDTO, Context, DAL, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, RuleTypeDTO } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
 import { Currency, MoneyAmount, PriceList, PriceListRule, PriceListRuleValue, PriceRule, PriceSet, PriceSetMoneyAmount, PriceSetMoneyAmountRules, PriceSetRuleType, RuleType } from "../models";
-import { CurrencyService, MoneyAmountService, PriceListRuleService, PriceListRuleValueService, PriceListService, PriceRuleService, PriceSetMoneyAmountRulesService, PriceSetMoneyAmountService, PriceSetRuleTypeService, PriceSetService, RuleTypeService } from ".";
-import { LinkableKeys } from "../joiner-config";
+import { PriceListRuleService, PriceListRuleValueService, PriceListService, PriceRuleService, RuleTypeService } from ".";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     pricingRepository: PricingRepositoryService;
-    currencyService: CurrencyService<any>;
-    moneyAmountService: MoneyAmountService<any>;
-    priceSetService: PriceSetService<any>;
-    priceSetMoneyAmountRulesService: PriceSetMoneyAmountRulesService<any>;
+    currencyService: ModulesSdkTypes.InternalModuleService<any>;
+    moneyAmountService: ModulesSdkTypes.InternalModuleService<any>;
+    priceSetService: ModulesSdkTypes.InternalModuleService<any>;
+    priceSetMoneyAmountRulesService: ModulesSdkTypes.InternalModuleService<any>;
     ruleTypeService: RuleTypeService<any>;
     priceRuleService: PriceRuleService<any>;
-    priceSetRuleTypeService: PriceSetRuleTypeService<any>;
-    priceSetMoneyAmountService: PriceSetMoneyAmountService<any>;
+    priceSetRuleTypeService: ModulesSdkTypes.InternalModuleService<any>;
+    priceSetMoneyAmountService: ModulesSdkTypes.InternalModuleService<any>;
     priceListService: PriceListService<any>;
     priceListRuleService: PriceListRuleService<any>;
     priceListRuleValueService: PriceListRuleValueService<any>;
 };
-export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet, TMoneyAmount extends MoneyAmount = MoneyAmount, TCurrency extends Currency = Currency, 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> implements PricingTypes.IPricingModuleService {
+declare const PricingModuleService_base: new (container: InjectedDependencies) => ModulesSdkUtils.AbstractModuleService<InjectedDependencies, PriceSetDTO, {
+    Currency: {
+        dto: PricingTypes.CurrencyDTO;
+    };
+    MoneyAmount: {
+        dto: PricingTypes.MoneyAmountDTO;
+    };
+    PriceSetMoneyAmount: {
+        dto: PricingTypes.PriceSetMoneyAmountDTO;
+    };
+    PriceSetMoneyAmountRules: {
+        dto: PricingTypes.PriceSetMoneyAmountRulesDTO;
+    };
+    PriceRule: {
+        dto: PricingTypes.PriceRuleDTO;
+    };
+    RuleType: {
+        dto: PricingTypes.RuleTypeDTO;
+    };
+    PriceList: {
+        dto: PricingTypes.PriceListDTO;
+    };
+    PriceListRule: {
+        dto: PricingTypes.PriceListRuleDTO;
+    };
+}>;
+export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet, TMoneyAmount extends MoneyAmount = MoneyAmount, TCurrency extends Currency = Currency, 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 {
     protected readonly moduleDeclaration: InternalModuleDeclaration;
     protected baseRepository_: DAL.RepositoryService;
     protected readonly pricingRepository_: PricingRepositoryService;
-    protected readonly currencyService_: CurrencyService<TCurrency>;
-    protected readonly moneyAmountService_: MoneyAmountService<TMoneyAmount>;
+    protected readonly currencyService_: ModulesSdkTypes.InternalModuleService<TCurrency>;
+    protected readonly moneyAmountService_: ModulesSdkTypes.InternalModuleService<TMoneyAmount>;
     protected readonly ruleTypeService_: RuleTypeService<TRuleType>;
-    protected readonly priceSetService_: PriceSetService<TPriceSet>;
-    protected readonly priceSetMoneyAmountRulesService_: PriceSetMoneyAmountRulesService<TPriceSetMoneyAmountRules>;
+    protected readonly priceSetService_: ModulesSdkTypes.InternalModuleService<TPriceSet>;
+    protected readonly priceSetMoneyAmountRulesService_: ModulesSdkTypes.InternalModuleService<TPriceSetMoneyAmountRules>;
     protected readonly priceRuleService_: PriceRuleService<TPriceRule>;
-    protected readonly priceSetRuleTypeService_: PriceSetRuleTypeService<TPriceSetRuleType>;
-    protected readonly priceSetMoneyAmountService_: PriceSetMoneyAmountService<TPriceSetMoneyAmount>;
+    protected readonly priceSetRuleTypeService_: ModulesSdkTypes.InternalModuleService<TPriceSetRuleType>;
+    protected readonly priceSetMoneyAmountService_: ModulesSdkTypes.InternalModuleService<TPriceSetMoneyAmount>;
     protected readonly priceListService_: PriceListService<TPriceList>;
     protected readonly priceListRuleService_: PriceListRuleService<TPriceListRule>;
     protected readonly priceListRuleValueService_: PriceListRuleValueService<TPriceListRuleValue>;
     constructor({ baseRepository, pricingRepository, moneyAmountService, currencyService, ruleTypeService, priceSetService, priceSetMoneyAmountRulesService, priceRuleService, priceSetRuleTypeService, priceSetMoneyAmountService, priceListService, priceListRuleService, priceListRuleValueService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
     __joinerConfig(): ModuleJoinerConfig;
     calculatePrices(pricingFilters: PricingFilters, pricingContext?: PricingContext, sharedContext?: Context): Promise<PricingTypes.CalculatedPriceSet[]>;
-    retrieve(id: string, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO>;
-    list(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
-    listAndCount(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<[PricingTypes.PriceSetDTO[], number]>;
     create(data: PricingTypes.CreatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
     create(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
     protected create_(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<TPriceSet[]>;
@@ -49,56 +72,23 @@ 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[]>;
-    delete(ids: string[], sharedContext?: Context): Promise<void>;
-    retrieveMoneyAmount(id: string, config?: FindConfig<PricingTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO>;
-    listMoneyAmounts(filters?: PricingTypes.FilterableMoneyAmountProps, config?: FindConfig<PricingTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
-    listAndCountMoneyAmounts(filters?: PricingTypes.FilterableMoneyAmountProps, config?: FindConfig<PricingTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<[PricingTypes.MoneyAmountDTO[], number]>;
-    createMoneyAmounts(data: PricingTypes.CreateMoneyAmountDTO[], sharedContext?: Context): Promise<MoneyAmountDTO[]>;
-    updateMoneyAmounts(data: PricingTypes.UpdateMoneyAmountDTO[], sharedContext?: Context): Promise<MoneyAmountDTO[]>;
-    deleteMoneyAmounts(ids: string[], sharedContext?: Context): Promise<void>;
-    softDeleteMoneyAmounts(ids: string[], sharedContext?: Context): Promise<void>;
-    restoreDeletedMoneyAmounts<TReturnableLinkableKeys extends string = Lowercase<keyof typeof LinkableKeys>>(ids: string[], { returnLinkableKeys }?: RestoreReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<Lowercase<keyof typeof LinkableKeys>, string[]> | void>;
-    retrieveCurrency(code: string, config?: FindConfig<PricingTypes.CurrencyDTO>, sharedContext?: Context): Promise<PricingTypes.CurrencyDTO>;
-    listCurrencies(filters?: PricingTypes.FilterableCurrencyProps, config?: FindConfig<PricingTypes.CurrencyDTO>, sharedContext?: Context): Promise<PricingTypes.CurrencyDTO[]>;
-    listAndCountCurrencies(filters?: PricingTypes.FilterableCurrencyProps, config?: FindConfig<PricingTypes.CurrencyDTO>, sharedContext?: Context): Promise<[PricingTypes.CurrencyDTO[], number]>;
+    createMoneyAmounts(data: PricingTypes.CreateMoneyAmountDTO[], sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
+    updateMoneyAmounts(data: PricingTypes.UpdateMoneyAmountDTO[], sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
     createCurrencies(data: PricingTypes.CreateCurrencyDTO[], sharedContext?: Context): Promise<PricingTypes.CurrencyDTO[]>;
     updateCurrencies(data: PricingTypes.UpdateCurrencyDTO[], sharedContext?: Context): Promise<PricingTypes.CurrencyDTO[]>;
-    deleteCurrencies(currencyCodes: string[], sharedContext?: Context): Promise<void>;
-    retrieveRuleType(id: string, config?: FindConfig<PricingTypes.RuleTypeDTO>, sharedContext?: Context): Promise<PricingTypes.RuleTypeDTO>;
-    listRuleTypes(filters?: PricingTypes.FilterableRuleTypeProps, config?: FindConfig<PricingTypes.RuleTypeDTO>, sharedContext?: Context): Promise<PricingTypes.RuleTypeDTO[]>;
-    listAndCountRuleTypes(filters?: PricingTypes.FilterableRuleTypeProps, config?: FindConfig<PricingTypes.RuleTypeDTO>, sharedContext?: Context): Promise<[PricingTypes.RuleTypeDTO[], number]>;
     createRuleTypes(data: PricingTypes.CreateRuleTypeDTO[], sharedContext?: Context): Promise<PricingTypes.RuleTypeDTO[]>;
     updateRuleTypes(data: PricingTypes.UpdateRuleTypeDTO[], sharedContext?: Context): Promise<PricingTypes.RuleTypeDTO[]>;
-    deleteRuleTypes(ruleTypeIds: string[], sharedContext?: Context): Promise<void>;
-    retrievePriceSetMoneyAmountRules(id: string, config?: FindConfig<PricingTypes.PriceSetMoneyAmountRulesDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO>;
-    listPriceSetMoneyAmountRules(filters?: PricingTypes.FilterablePriceSetMoneyAmountRulesProps, config?: FindConfig<PricingTypes.PriceSetMoneyAmountRulesDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO[]>;
-    listAndCountPriceSetMoneyAmountRules(filters?: PricingTypes.FilterablePriceSetMoneyAmountRulesProps, config?: FindConfig<PricingTypes.PriceSetMoneyAmountRulesDTO>, sharedContext?: Context): Promise<[PricingTypes.PriceSetMoneyAmountRulesDTO[], number]>;
-    listPriceSetMoneyAmounts(filters?: PricingTypes.FilterablePriceSetMoneyAmountProps, config?: FindConfig<PricingTypes.PriceSetMoneyAmountDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountDTO[]>;
-    listAndCountPriceSetMoneyAmounts(filters?: PricingTypes.FilterablePriceSetMoneyAmountProps, config?: FindConfig<PricingTypes.PriceSetMoneyAmountDTO>, sharedContext?: Context): Promise<[PricingTypes.PriceSetMoneyAmountDTO[], number]>;
     createPriceSetMoneyAmountRules(data: PricingTypes.CreatePriceSetMoneyAmountRulesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO[]>;
     updatePriceSetMoneyAmountRules(data: PricingTypes.UpdatePriceSetMoneyAmountRulesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO[]>;
-    deletePriceSetMoneyAmountRules(ids: string[], sharedContext?: Context): Promise<void>;
-    retrievePriceRule(id: string, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO>;
-    listPriceRules(filters?: PricingTypes.FilterablePriceRuleProps, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO[]>;
-    listAndCountPriceRules(filters?: PricingTypes.FilterablePriceRuleProps, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<[PricingTypes.PriceRuleDTO[], number]>;
     createPriceRules(data: PricingTypes.CreatePriceRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO[]>;
     updatePriceRules(data: PricingTypes.UpdatePriceRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO[]>;
-    deletePriceRules(priceRuleIds: string[], sharedContext?: Context): Promise<void>;
-    retrievePriceList(id: string, config?: FindConfig<PricingTypes.PriceListDTO>, sharedContext?: Context): Promise<PricingTypes.PriceListDTO>;
-    listPriceLists(filters?: PricingTypes.FilterablePriceListProps, config?: FindConfig<PricingTypes.PriceListDTO>, sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
-    listAndCountPriceLists(filters?: PricingTypes.FilterablePriceListProps, config?: FindConfig<PricingTypes.PriceListDTO>, sharedContext?: Context): Promise<[PricingTypes.PriceListDTO[], number]>;
     createPriceLists(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     protected createPriceLists_(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     updatePriceLists(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     protected updatePriceLists_(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
-    deletePriceLists(priceListIds: string[], sharedContext?: Context): Promise<void>;
-    retrievePriceListRule(id: string, config?: FindConfig<PricingTypes.PriceListRuleDTO>, sharedContext?: Context): Promise<PricingTypes.PriceListRuleDTO>;
-    listPriceListRules(filters?: PricingTypes.FilterablePriceListRuleProps, config?: FindConfig<PricingTypes.PriceListRuleDTO>, sharedContext?: Context): Promise<PricingTypes.PriceListRuleDTO[]>;
-    listAndCountPriceListRules(filters?: PricingTypes.FilterablePriceListRuleProps, config?: FindConfig<PricingTypes.PriceListRuleDTO>, sharedContext?: Context): Promise<[PricingTypes.PriceListRuleDTO[], number]>;
     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[]>;
-    deletePriceListRules(priceListRuleIds: string[], sharedContext?: Context): Promise<void>;
     addPriceListPrices(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     protected addPriceListPrices_(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     setPriceListRules(data: PricingTypes.SetPriceListRulesDTO, sharedContext?: Context): Promise<PricingTypes.PriceListDTO>;