---
displayed_sidebar: servicesSidebar
---
import ParameterTypes from "@site/src/components/ParameterTypes"
# IPricingModuleService
## Methods
### addPriceListPrices
`**addPriceListPrices**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)[]>`
This method is used to add prices to price lists.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function addPriceListPrices (items: {
priceListId: string,
prices: {
currency_code: string,
amount: number,
price_set_id: string
}[]
}[]) {
const pricingService = await initializePricingModule()
const priceLists = await pricingService.addPriceListPrices(items)
// do something with the price lists or return them
}
```
#### Parameters
#### Returns
Promise<[PriceListDTO](PriceListDTO.mdx)[]>
___
### addPrices
`**addPrices**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)>`
This method adds prices to a price set.
#### Example
To add a default price to a price set, don't pass it any rules and make sure to pass it the `currency_code`:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function addPricesToPriceSet (priceSetId: string) {
const pricingService = await initializePricingModule()
const priceSet = await pricingService.addPrices({
priceSetId,
prices: [
{
amount: 500,
currency_code: "USD",
rules: {},
},
],
})
// do something with the price set or return it
}
```
To add prices with rules:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function addPricesToPriceSet (priceSetId: string) {
const pricingService = await initializePricingModule()
const priceSet = await pricingService.addPrices({
priceSetId,
prices: [
{
amount: 300,
currency_code: "EUR",
rules: {
region_id: "PL",
city: "krakow"
},
},
{
amount: 400,
currency_code: "EUR",
min_quantity: 0,
max_quantity: 4,
rules: {
region_id: "PL"
},
},
{
amount: 450,
currency_code: "EUR",
rules: {
city: "krakow"
},
}
],
})
// do something with the price set or return it
}
```
#### Parameters
#### Returns
Promise<[PriceSetDTO](PriceSetDTO.mdx)>
`**addPrices**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>`
This method adds prices to multiple price sets.
#### Example
To add a default price to a price set, don't pass it any rules and make sure to pass it the `currency_code`:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function addPricesToPriceSet (priceSetId: string) {
const pricingService = await initializePricingModule()
const priceSets = await pricingService.addPrices([{
priceSetId,
prices: [
{
amount: 500,
currency_code: "USD",
rules: {},
},
],
}])
// do something with the price sets or return them
}
```
To add prices with rules:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function addPricesToPriceSet (priceSetId: string) {
const pricingService = await initializePricingModule()
const priceSets = await pricingService.addPrices([{
priceSetId,
prices: [
{
amount: 300,
currency_code: "EUR",
rules: {
region_id: "PL",
city: "krakow"
},
},
{
amount: 400,
currency_code: "EUR",
min_quantity: 0,
max_quantity: 4,
rules: {
region_id: "PL"
},
},
{
amount: 450,
currency_code: "EUR",
rules: {
city: "krakow"
},
}
],
}])
// do something with the price sets or return them
}
```
#### Parameters
#### Returns
Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>
___
### addRules
`**addRules**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)>`
This method adds rules to a price set.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function addRulesToPriceSet (priceSetId: string) {
const pricingService = await initializePricingModule()
const priceSet = await pricingService.addRules({
priceSetId,
rules: [{
attribute: "region_id"
}]
})
// do something with the price set or return it
}
```
#### Parameters
#### Returns
Promise<[PriceSetDTO](PriceSetDTO.mdx)>
`**addRules**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>`
This method adds rules to multiple price sets.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function addRulesToPriceSet (priceSetId: string) {
const pricingService = await initializePricingModule()
const priceSets = await pricingService.addRules([{
priceSetId,
rules: [{
attribute: "region_id"
}]
}])
// do something with the price sets or return them
}
```
#### Parameters
#### Returns
Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>
___
### calculatePrices
`**calculatePrices**(filters, context?, sharedContext?): Promise<[CalculatedPriceSetDTO](CalculatedPriceSetDTO.mdx)>`
This method is used to calculate prices based on the provided filters and context.
#### Example
When you calculate prices, you must at least specify the currency code:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function calculatePrice (priceSetId: string, currencyCode: string) {
const pricingService = await initializePricingModule()
const price = await pricingService.calculatePrices(
{ id: [priceSetId] },
{
context: {
currency_code: currencyCode
}
}
)
// do something with the price or return it
}
```
To calculate prices for specific minimum and/or maximum quantity:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function calculatePrice (priceSetId: string, currencyCode: string) {
const pricingService = await initializePricingModule()
const price = await pricingService.calculatePrices(
{ id: [priceSetId] },
{
context: {
currency_code: currencyCode,
min_quantity: 4
}
}
)
// do something with the price or return it
}
```
To calculate prices for custom rule types:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function calculatePrice (priceSetId: string, currencyCode: string) {
const pricingService = await initializePricingModule()
const price = await pricingService.calculatePrices(
{ id: [priceSetId] },
{
context: {
currency_code: currencyCode,
region_id: "US"
}
}
)
// do something with the price or return it
}
```
#### Parameters
#### Returns
Promise<[CalculatedPriceSetDTO](CalculatedPriceSetDTO.mdx)>
___
### create
`**create**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)>`
This method is used to create a new price set.
#### Example
To create a default price set, don't pass any rules. For example:
```ts
import { initialize as initializePricingModule } from "@medusajs/pricing"
async function createPriceSet() {
const pricingService = await initializePricingModule()
const priceSet = await pricingService.create({
rules: [],
prices: [
{
amount: 500,
currency_code: "USD",
min_quantity: 0,
max_quantity: 4,
rules: {},
},
{
amount: 400,
currency_code: "USD",
min_quantity: 5,
max_quantity: 10,
rules: {},
},
],
})
// do something with the price set or return it
}
```
To create a price set and associate it with rule types:
```ts
import { initialize as initializePricingModule } from "@medusajs/pricing"
async function createPriceSet() {
const pricingService = await initializePricingModule()
const priceSet = await pricingService.create({
rules: [{ rule_attribute: "region_id" }, { rule_attribute: "city" }],
prices: [
{
amount: 300,
currency_code: "EUR",
rules: {
region_id: "PL",
city: "krakow",
},
},
{
amount: 400,
currency_code: "EUR",
rules: {
region_id: "PL",
},
},
{
amount: 450,
currency_code: "EUR",
rules: {
city: "krakow",
},
},
],
})
// do something with the price set or return it
}
```
#### Parameters
#### Returns
Promise<[PriceSetDTO](PriceSetDTO.mdx)>
`**create**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>`
This method is used to create multiple price sets.
#### Example
To create price sets with a default price, don't pass any rules and make sure to pass the `currency_code` of the price. For example:
```ts
import { initialize as initializePricingModule } from "@medusajs/pricing"
async function createPriceSets() {
const pricingService = await initializePricingModule()
const priceSets = await pricingService.create([
{
rules: [],
prices: [
{
amount: 500,
currency_code: "USD",
rules: {},
},
],
},
])
// do something with the price sets or return them
}
```
To create price sets and associate them with rule types:
```ts
import { initialize as initializePricingModule } from "@medusajs/pricing"
async function createPriceSets() {
const pricingService = await initializePricingModule()
const priceSets = await pricingService.create([
{
rules: [{ rule_attribute: "region_id" }, { rule_attribute: "city" }],
prices: [
{
amount: 300,
currency_code: "EUR",
rules: {
region_id: "PL",
city: "krakow",
},
},
{
amount: 400,
currency_code: "EUR",
min_quantity: 0,
max_quantity: 4,
rules: {
region_id: "PL",
},
},
{
amount: 450,
currency_code: "EUR",
rules: {
city: "krakow",
},
},
],
},
])
// do something with the price sets or return them
}
```
#### Parameters
#### Returns
Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>
___
### createCurrencies
`**createCurrencies**(data, sharedContext?): Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>`
This method is used to create new currencies.
#### Example
```ts
import { initialize as initializePricingModule } from "@medusajs/pricing"
async function createCurrencies() {
const pricingService = await initializePricingModule()
const currencies = await pricingService.createCurrencies([
{
code: "USD",
symbol: "$",
symbol_native: "$",
name: "US Dollar",
},
])
// do something with the currencies or return them
}
```
#### Parameters
#### Returns
Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>
___
### createMoneyAmounts
`**createMoneyAmounts**(data, sharedContext?): Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>`
This method creates money amounts.
#### Example
```ts
import { initialize as initializePricingModule } from "@medusajs/pricing"
async function retrieveMoneyAmounts() {
const pricingService = await initializePricingModule()
const moneyAmounts = await pricingService.createMoneyAmounts([
{
amount: 500,
currency_code: "USD",
},
{
amount: 400,
currency_code: "USD",
min_quantity: 0,
max_quantity: 4,
},
])
// do something with the money amounts or return them
}
```
#### Parameters
#### Returns
Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>
___
### createPriceListRules
`**createPriceListRules**(data, sharedContext?): Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>`
This method is used to create price list rules.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function createPriceListRules (items: {
rule_type_id: string
price_list_id: string
}[]) {
const pricingService = await initializePricingModule()
const priceListRules = await pricingService.createPriceListRules(items)
// do something with the price list rule or return them
}
```
#### Parameters
#### Returns
Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>
___
### createPriceLists
`**createPriceLists**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)[]>`
This method is used to create price lists.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function createPriceList (items: {
title: string
description: string
starts_at?: string
ends_at?: string
}[]) {
const pricingService = await initializePricingModule()
const priceList = await pricingService.createPriceLists(items)
// do something with the price lists or return them
}
```
#### Parameters
#### Returns
Promise<[PriceListDTO](PriceListDTO.mdx)[]>
___
### createPriceRules
`**createPriceRules**(data, sharedContext?): Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>`
This method is used to create new price rules based on the provided data.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function createPriceRules (
id: string,
priceSetId: string,
ruleTypeId: string,
value: string,
priceSetMoneyAmountId: string,
priceListId: string
) {
const pricingService = await initializePricingModule()
const priceRules = await pricingService.createPriceRules([
{
id,
price_set_id: priceSetId,
rule_type_id: ruleTypeId,
value,
price_set_money_amount_id: priceSetMoneyAmountId,
price_list_id: priceListId
}
])
// do something with the price rules or return them
}
```
#### Parameters
#### Returns
Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>
___
### createPriceSetMoneyAmountRules
`**createPriceSetMoneyAmountRules**(data, sharedContext?): Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>`
This method is used to create new price set money amount rules. A price set money amount rule creates an association between a price set money amount and
a rule type.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function createPriceSetMoneyAmountRules (priceSetMoneyAmountId: string, ruleTypeId: string, value: string) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmountRules = await pricingService.createPriceSetMoneyAmountRules([
{
price_set_money_amount: priceSetMoneyAmountId,
rule_type: ruleTypeId,
value
}
])
// do something with the price set money amount rules or return them
}
```
#### Parameters
#### Returns
Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>
___
### createRuleTypes
`**createRuleTypes**(data, sharedContext?): Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>`
This method is used to create new rule types.
#### Example
```ts
import { initialize as initializePricingModule } from "@medusajs/pricing"
async function createRuleTypes() {
const pricingService = await initializePricingModule()
const ruleTypes = await pricingService.createRuleTypes([
{
name: "Region",
rule_attribute: "region_id",
},
])
// do something with the rule types or return them
}
```
#### Parameters
#### Returns
Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>
___
### delete
`**delete**(ids, sharedContext?): Promise<void>`
This method deletes price sets by their IDs.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function removePriceSetRule (priceSetIds: string[]) {
const pricingService = await initializePricingModule()
await pricingService.delete(priceSetIds)
}
```
#### Parameters
#### Returns
Promise<void>
___
### deleteCurrencies
`**deleteCurrencies**(currencyCodes, sharedContext?): Promise<void>`
This method is used to delete currencies based on their currency code.
#### Example
```ts
import { initialize as initializePricingModule } from "@medusajs/pricing"
async function deleteCurrencies() {
const pricingService = await initializePricingModule()
await pricingService.deleteCurrencies(["USD"])
}
```
#### Parameters
#### Returns
Promise<void>
___
### deleteMoneyAmounts
`**deleteMoneyAmounts**(ids, sharedContext?): Promise<void>`
This method deletes money amounts by their IDs.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function deleteMoneyAmounts (moneyAmountIds: string[]) {
const pricingService = await initializePricingModule()
await pricingService.deleteMoneyAmounts(
moneyAmountIds
)
}
```
#### Parameters
#### Returns
Promise<void>
___
### deletePriceListRules
`**deletePriceListRules**(priceListRuleIds, sharedContext?): Promise<void>`
This method is used to delete price list rules.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function deletePriceListRules (priceListRuleIds: string[]) {
const pricingService = await initializePricingModule()
await pricingService.deletePriceListRules(priceListRuleIds)
}
```
#### Parameters
#### Returns
Promise<void>
___
### deletePriceLists
`**deletePriceLists**(priceListIds, sharedContext?): Promise<void>`
This method is used to delete price lists.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function deletePriceLists (ids: string[]) {
const pricingService = await initializePricingModule()
await pricingService.deletePriceLists(ids)
}
```
#### Parameters
#### Returns
Promise<void>
___
### deletePriceRules
`**deletePriceRules**(priceRuleIds, sharedContext?): Promise<void>`
This method is used to delete price rules based on the specified IDs.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function deletePriceRules (
id: string,
) {
const pricingService = await initializePricingModule()
await pricingService.deletePriceRules([id])
}
```
#### Parameters
#### Returns
Promise<void>
___
### deletePriceSetMoneyAmountRules
`**deletePriceSetMoneyAmountRules**(ids, sharedContext?): Promise<void>`
This method is used to delete price set money amount rules based on the specified IDs.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function deletePriceSetMoneyAmountRule (id: string) {
const pricingService = await initializePricingModule()
await pricingService.deletePriceSetMoneyAmountRules([id])
}
```
#### Parameters
#### Returns
Promise<void>
___
### deleteRuleTypes
`**deleteRuleTypes**(ruleTypeIds, sharedContext?): Promise<void>`
This method is used to delete rule types based on the provided IDs.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function deleteRuleTypes (ruleTypeId: string) {
const pricingService = await initializePricingModule()
await pricingService.deleteRuleTypes([ruleTypeId])
}
```
#### Parameters
#### Returns
Promise<void>
___
### list
`**list**(filters?, config?, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>`
This method is used to retrieve a paginated list of price sets based on optional filters and configuration.
#### Example
To retrieve a list of price sets using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSets (priceSetIds: string[]) {
const pricingService = await initializePricingModule()
const priceSets = await pricingService.list(
{
id: priceSetIds
},
)
// do something with the price sets or return them
}
```
To specify relations that should be retrieved within the price sets:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSets (priceSetIds: string[]) {
const pricingService = await initializePricingModule()
const priceSets = await pricingService.list(
{
id: priceSetIds
},
{
relations: ["money_amounts"]
}
)
// do something with the price sets or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSets (priceSetIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceSets = await pricingService.list(
{
id: priceSetIds
},
{
relations: ["money_amounts"],
skip,
take
}
)
// do something with the price sets or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSets (priceSetIds: string[], moneyAmountIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceSets = await pricingService.list(
{
$and: [
{
id: priceSetIds
},
{
money_amounts: {
id: moneyAmountIds
}
}
]
},
{
relations: ["money_amounts"],
skip,
take
}
)
// do something with the price sets or return them
}
```
#### Parameters
#### Returns
Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>
___
### listAndCount
`**listAndCount**(filters?, config?, sharedContext?): Promise<[[PriceSetDTO](PriceSetDTO.mdx)[], number]>`
This method is used to retrieve a paginated list of price sets along with the total count of available price sets satisfying the provided filters.
#### Example
To retrieve a list of prices sets using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSets (priceSetIds: string[]) {
const pricingService = await initializePricingModule()
const [priceSets, count] = await pricingService.listAndCount(
{
id: priceSetIds
},
)
// do something with the price sets or return them
}
```
To specify relations that should be retrieved within the price sets:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSets (priceSetIds: string[]) {
const pricingService = await initializePricingModule()
const [priceSets, count] = await pricingService.listAndCount(
{
id: priceSetIds
},
{
relations: ["money_amounts"]
}
)
// do something with the price sets or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSets (priceSetIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceSets, count] = await pricingService.listAndCount(
{
id: priceSetIds
},
{
relations: ["money_amounts"],
skip,
take
}
)
// do something with the price sets or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSets (priceSetIds: string[], moneyAmountIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceSets, count] = await pricingService.listAndCount(
{
$and: [
{
id: priceSetIds
},
{
money_amounts: {
id: moneyAmountIds
}
}
]
},
{
relations: ["money_amounts"],
skip,
take
}
)
// do something with the price sets or return them
}
```
#### Parameters
#### Returns
Promise<[[PriceSetDTO](PriceSetDTO.mdx)[], number]>
___
### listAndCountCurrencies
`**listAndCountCurrencies**(filters?, config?, sharedContext?): Promise<[[CurrencyDTO](CurrencyDTO.mdx)[], number]>`
This method is used to retrieve a paginated list of currencies along with the total count of available currencies satisfying the provided filters.
#### Example
To retrieve a list of currencies using their codes:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveCurrencies (codes: string[]) {
const pricingService = await initializePricingModule()
const [currencies, count] = await pricingService.listAndCountCurrencies(
{
code: codes
},
)
// do something with the currencies or return them
}
```
To specify attributes that should be retrieved within the money amounts:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveCurrencies (codes: string[]) {
const pricingService = await initializePricingModule()
const [currencies, count] = await pricingService.listAndCountCurrencies(
{
code: codes
},
{
select: ["symbol_native"]
}
)
// do something with the currencies or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveCurrencies (codes: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [currencies, count] = await pricingService.listAndCountCurrencies(
{
code: codes
},
{
select: ["symbol_native"],
skip,
take
}
)
// do something with the currencies or return them
}
```
#### Parameters
#### Returns
Promise<[[CurrencyDTO](CurrencyDTO.mdx)[], number]>
___
### listAndCountMoneyAmounts
`**listAndCountMoneyAmounts**(filters?, config?, sharedContext?): Promise<[[MoneyAmountDTO](MoneyAmountDTO.mdx)[], number]>`
This method is used to retrieve a paginated list of money amounts along with the total count of available money amounts satisfying the provided filters.
#### Example
To retrieve a list of money amounts using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmounts (moneyAmountIds: string[]) {
const pricingService = await initializePricingModule()
const [moneyAmounts, count] = await pricingService.listAndCountMoneyAmounts(
{
id: moneyAmountIds
}
)
// do something with the money amounts or return them
}
```
To specify relations that should be retrieved within the money amounts:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmounts (moneyAmountIds: string[]) {
const pricingService = await initializePricingModule()
const [moneyAmounts, count] = await pricingService.listAndCountMoneyAmounts(
{
id: moneyAmountIds
},
{
relations: ["currency"]
}
)
// do something with the money amounts or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmounts (moneyAmountIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [moneyAmounts, count] = await pricingService.listAndCountMoneyAmounts(
{
id: moneyAmountIds
},
{
relations: ["currency"],
skip,
take
}
)
// do something with the money amounts or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmounts (moneyAmountIds: string[], currencyCode: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [moneyAmounts, count] = await pricingService.listAndCountMoneyAmounts(
{
$and: [
{
id: moneyAmountIds
},
{
currency_code: currencyCode
}
]
},
{
relations: ["currency"],
skip,
take
}
)
// do something with the money amounts or return them
}
```
#### Parameters
#### Returns
Promise<[[MoneyAmountDTO](MoneyAmountDTO.mdx)[], number]>
___
### listAndCountPriceListRules
`**listAndCountPriceListRules**(filters?, config?, sharedContext?): Promise<[[PriceListRuleDTO](PriceListRuleDTO.mdx)[], number]>`
This method is used to retrieve a paginated list of price list ruless along with the total count of available price list ruless satisfying the provided filters.
#### Example
To retrieve a list of price list vs using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listAndCountPriceListRules (priceListRuleIds: string[]) {
const pricingService = await initializePricingModule()
const [priceListRules, count] = await pricingService.listAndCountPriceListRules(
{
id: priceListRuleIds
},
)
// do something with the price list rules or return them
}
```
To specify relations that should be retrieved within the price list rules:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listAndCountPriceListRules (priceListRuleIds: string[]) {
const pricingService = await initializePricingModule()
const [priceListRules, count] = await pricingService.listAndCountPriceListRules(
{
id: priceListRuleIds
},
{
relations: ["price_list_rule_values"]
}
)
// do something with the price list rules or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listAndCountPriceListRules (priceListRuleIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceListRules, count] = await pricingService.listAndCountPriceListRules(
{
id: priceListRuleIds
},
{
relations: ["price_list_rule_values"],
skip,
take
}
)
// do something with the price list rules or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listAndCountPriceListRules (priceListRuleIds: string[], ruleTypeIDs: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceListRules, count] = await pricingService.listAndCountPriceListRules(
{
$and: [
{
id: priceListRuleIds
},
{
rule_types: ruleTypeIDs
}
]
},
{
relations: ["price_list_rule_values"],
skip,
take
}
)
// do something with the price list rules or return them
}
```
#### Parameters
#### Returns
Promise<[[PriceListRuleDTO](PriceListRuleDTO.mdx)[], number]>
___
### listAndCountPriceLists
`**listAndCountPriceLists**(filters?, config?, sharedContext?): Promise<[[PriceListDTO](PriceListDTO.mdx)[], number]>`
This method is used to retrieve a paginated list of price lists along with the total count of available price lists satisfying the provided filters.
#### Example
To retrieve a list of price lists using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceLists (priceListIds: string[]) {
const pricingService = await initializePricingModule()
const [priceLists, count] = await pricingService.listPriceLists(
{
id: priceListIds
},
)
// do something with the price lists or return them
}
```
To specify relations that should be retrieved within the price lists:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceLists (priceListIds: string[]) {
const pricingService = await initializePricingModule()
const [priceLists, count] = await pricingService.listPriceLists(
{
id: priceListIds
},
{
relations: ["price_set_money_amounts"]
}
)
// do something with the price lists or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceLists (priceListIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceLists, count] = await pricingService.listPriceLists(
{
id: priceListIds
},
{
relations: ["price_set_money_amounts"],
skip,
take
}
)
// do something with the price lists or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceLists (priceListIds: string[], titles: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceLists, count] = await pricingService.listPriceLists(
{
$and: [
{
id: priceListIds
},
{
title: titles
}
]
},
{
relations: ["price_set_money_amounts"],
skip,
take
}
)
// do something with the price lists or return them
}
```
#### Parameters
#### Returns
Promise<[[PriceListDTO](PriceListDTO.mdx)[], number]>
___
### listAndCountPriceRules
`**listAndCountPriceRules**(filters?, config?, sharedContext?): Promise<[[PriceRuleDTO](PriceRuleDTO.mdx)[], number]>`
This method is used to retrieve a paginated list of price rules along with the total count of available price rules satisfying the provided filters.
#### Example
To retrieve a list of price rules using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRules (id: string) {
const pricingService = await initializePricingModule()
const [priceRules, count] = await pricingService.listAndCountPriceRules({
id: [id]
})
// do something with the price rules or return them
}
```
To specify relations that should be retrieved within the price rules:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRules (id: string) {
const pricingService = await initializePricingModule()
const [priceRules, count] = await pricingService.listAndCountPriceRules({
id: [id],
}, {
relations: ["price_set"]
})
// do something with the price rules or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRules (id: string, skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceRules, count] = await pricingService.listAndCountPriceRules({
id: [id],
}, {
relations: ["price_set"],
skip,
take
})
// do something with the price rules or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRules (ids: string[], name: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceRules, count] = await pricingService.listAndCountPriceRules({
$and: [
{
id: ids
},
{
name
}
]
}, {
relations: ["price_set"],
skip,
take
})
// do something with the price rules or return them
}
```
#### Parameters
#### Returns
Promise<[[PriceRuleDTO](PriceRuleDTO.mdx)[], number]>
___
### listAndCountPriceSetMoneyAmountRules
`**listAndCountPriceSetMoneyAmountRules**(filters?, config?, sharedContext?): Promise<[[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[], number]>`
This method is used to retrieve a paginated list of price set money amount rules along with the total count of
available price set money amount rules satisfying the provided filters.
#### Example
To retrieve a list of price set money amounts using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRules (id: string) {
const pricingService = await initializePricingModule()
const [priceSetMoneyAmountRules, count] = await pricingService.listAndCountPriceSetMoneyAmountRules({
id: [id]
})
// do something with the price set money amount rules or return them
}
```
To specify relations that should be retrieved within the price set money amount rules:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRules (id: string) {
const pricingService = await initializePricingModule()
const [priceSetMoneyAmountRules, count] = await pricingService.listAndCountPriceSetMoneyAmountRules({
id: [id]
}, {
relations: ["price_set_money_amount"],
})
// do something with the price set money amount rules or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRules (id: string, skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceSetMoneyAmountRules, count] = await pricingService.listAndCountPriceSetMoneyAmountRules({
id: [id]
}, {
relations: ["price_set_money_amount"],
skip,
take
})
// do something with the price set money amount rules or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRules (ids: string[], ruleTypeId: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceSetMoneyAmountRules, count] = await pricingService.listAndCountPriceSetMoneyAmountRules({
$and: [
{
id: ids
},
{
rule_type_id: ruleTypeId
}
]
}, {
relations: ["price_set_money_amount"],
skip,
take
})
// do something with the price set money amount rules or return them
}
```
#### Parameters
#### Returns
Promise<[[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[], number]>
___
### listAndCountPriceSetMoneyAmounts
`**listAndCountPriceSetMoneyAmounts**(filters?, config?, sharedContext?): Promise<[[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[], number]>`
This method is used to retrieve a paginated list of price set money amounts along with the total count of
available price set money amounts satisfying the provided filters.
#### Example
To retrieve a list of price set money amounts using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmounts (id: string) {
const pricingService = await initializePricingModule()
const [priceSetMoneyAmounts, count] = await pricingService.listAndCountPriceSetMoneyAmounts({
id: [id]
})
// do something with the price set money amounts or return them
}
```
To specify relations that should be retrieved within the price set money amounts:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmounts (id: string) {
const pricingService = await initializePricingModule()
const [priceSetMoneyAmounts, count] = await pricingService.listAndCountPriceSetMoneyAmounts({
id: [id]
}, {
relations: ["price_rules"],
})
// do something with the price set money amounts or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmounts (id: string, skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceSetMoneyAmounts, count] = await pricingService.listAndCountPriceSetMoneyAmounts({
id: [id]
}, {
relations: ["price_rules"],
skip,
take
})
// do something with the price set money amounts or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmounts (ids: string[], titles: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [priceSetMoneyAmounts, count] = await pricingService.listAndCountPriceSetMoneyAmounts({
$and: [
{
id: ids
},
{
title: titles
}
]
}, {
relations: ["price_rules"],
skip,
take
})
// do something with the price set money amounts or return them
}
```
#### Parameters
#### Returns
Promise<[[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[], number]>
___
### listAndCountRuleTypes
`**listAndCountRuleTypes**(filters?, config?, sharedContext?): Promise<[[RuleTypeDTO](RuleTypeDTO.mdx)[], number]>`
This method is used to retrieve a paginated list of rule types along with the total count of available rule types satisfying the provided filters.
#### Example
To retrieve a list of rule types using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleTypes (ruleTypeId: string) {
const pricingService = await initializePricingModule()
const [ruleTypes, count] = await pricingService.listAndCountRuleTypes({
id: [
ruleTypeId
]
})
// do something with the rule types or return them
}
```
To specify attributes that should be retrieved within the rule types:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleTypes (ruleTypeId: string) {
const pricingService = await initializePricingModule()
const [ruleTypes, count] = await pricingService.listAndCountRuleTypes({
id: [
ruleTypeId
]
}, {
select: ["name"]
})
// do something with the rule types or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleTypes (ruleTypeId: string, skip: number, take: number) {
const pricingService = await initializePricingModule()
const [ruleTypes, count] = await pricingService.listAndCountRuleTypes({
id: [
ruleTypeId
]
}, {
select: ["name"],
skip,
take
})
// do something with the rule types or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleTypes (ruleTypeId: string[], name: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const [ruleTypes, count] = await pricingService.listAndCountRuleTypes({
$and: [
{
id: ruleTypeId
},
{
name
}
]
}, {
select: ["name"],
skip,
take
})
// do something with the rule types or return them
}
```
#### Parameters
#### Returns
Promise<[[RuleTypeDTO](RuleTypeDTO.mdx)[], number]>
___
### listCurrencies
`**listCurrencies**(filters?, config?, sharedContext?): Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>`
This method is used to retrieve a paginated list of currencies based on optional filters and configuration.
#### Example
To retrieve a list of currencies using their codes:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveCurrencies (codes: string[]) {
const pricingService = await initializePricingModule()
const currencies = await pricingService.listCurrencies(
{
code: codes
},
)
// do something with the currencies or return them
}
```
To specify attributes that should be retrieved within the money amounts:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveCurrencies (codes: string[]) {
const pricingService = await initializePricingModule()
const currencies = await pricingService.listCurrencies(
{
code: codes
},
{
select: ["symbol_native"]
}
)
// do something with the currencies or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveCurrencies (codes: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const currencies = await pricingService.listCurrencies(
{
code: codes
},
{
select: ["symbol_native"],
skip,
take
}
)
// do something with the currencies or return them
}
```
#### Parameters
#### Returns
Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>
___
### listMoneyAmounts
`**listMoneyAmounts**(filters?, config?, sharedContext?): Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>`
This method is used to retrieve a paginated list of money amounts based on optional filters and configuration.
#### Example
To retrieve a list of money amounts using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmounts (moneyAmountIds: string[]) {
const pricingService = await initializePricingModule()
const moneyAmounts = await pricingService.listMoneyAmounts(
{
id: moneyAmountIds
}
)
// do something with the money amounts or return them
}
```
To specify relations that should be retrieved within the money amounts:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmounts (moneyAmountIds: string[]) {
const pricingService = await initializePricingModule()
const moneyAmounts = await pricingService.listMoneyAmounts(
{
id: moneyAmountIds
},
{
relations: ["currency"]
}
)
// do something with the money amounts or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmounts (moneyAmountIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const moneyAmounts = await pricingService.listMoneyAmounts(
{
id: moneyAmountIds
},
{
relations: ["currency"],
skip,
take
}
)
// do something with the money amounts or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmounts (moneyAmountIds: string[], currencyCode: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const moneyAmounts = await pricingService.listMoneyAmounts(
{
$and: [
{
id: moneyAmountIds
},
{
currency_code: currencyCode
}
]
},
{
relations: ["currency"],
skip,
take
}
)
// do something with the money amounts or return them
}
```
#### Parameters
#### Returns
Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>
___
### listPriceListRules
`**listPriceListRules**(filters?, config?, sharedContext?): Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>`
This method is used to retrieve a paginated list of price list rules based on optional filters and configuration.
#### Example
To retrieve a list of price list vs using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listPriceListRules (priceListRuleIds: string[]) {
const pricingService = await initializePricingModule()
const priceListRules = await pricingService.listPriceListRules(
{
id: priceListRuleIds
},
)
// do something with the price list rules or return them
}
```
To specify relations that should be retrieved within the price list rules:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listPriceListRules (priceListRuleIds: string[]) {
const pricingService = await initializePricingModule()
const priceListRules = await pricingService.listPriceListRules(
{
id: priceListRuleIds
},
{
relations: ["price_list_rule_values"]
}
)
// do something with the price list rules or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listPriceListRules (priceListRuleIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceListRules = await pricingService.listPriceListRules(
{
id: priceListRuleIds
},
{
relations: ["price_list_rule_values"],
skip,
take
}
)
// do something with the price list rules or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listPriceListRules (priceListRuleIds: string[], ruleTypeIDs: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceListRules = await pricingService.listPriceListRules(
{
$and: [
{
id: priceListRuleIds
},
{
rule_types: ruleTypeIDs
}
]
},
{
relations: ["price_list_rule_values"],
skip,
take
}
)
// do something with the price list rules or return them
}
```
#### Parameters
#### Returns
Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>
___
### listPriceLists
`**listPriceLists**(filters?, config?, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)[]>`
This method is used to retrieve a paginated list of price lists based on optional filters and configuration.
#### Example
To retrieve a list of price lists using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listPriceLists (priceListIds: string[]) {
const pricingService = await initializePricingModule()
const priceLists = await pricingService.listPriceLists(
{
id: priceListIds
},
)
// do something with the price lists or return them
}
```
To specify relations that should be retrieved within the price lists:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listPriceLists (priceListIds: string[]) {
const pricingService = await initializePricingModule()
const priceLists = await pricingService.listPriceLists(
{
id: priceListIds
},
{
relations: ["price_set_money_amounts"]
}
)
// do something with the price lists or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listPriceLists (priceListIds: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceLists = await pricingService.listPriceLists(
{
id: priceListIds
},
{
relations: ["price_set_money_amounts"],
skip,
take
}
)
// do something with the price lists or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function listPriceLists (priceListIds: string[], titles: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceLists = await pricingService.listPriceLists(
{
$and: [
{
id: priceListIds
},
{
title: titles
}
]
},
{
relations: ["price_set_money_amounts"],
skip,
take
}
)
// do something with the price lists or return them
}
```
#### Parameters
#### Returns
Promise<[PriceListDTO](PriceListDTO.mdx)[]>
___
### listPriceRules
`**listPriceRules**(filters?, config?, sharedContext?): Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>`
This method is used to retrieve a paginated list of price rules based on optional filters and configuration.
#### Example
To retrieve a list of price rules using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRules (id: string) {
const pricingService = await initializePricingModule()
const priceRules = await pricingService.listPriceRules({
id: [id]
})
// do something with the price rules or return them
}
```
To specify relations that should be retrieved within the price rules:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRules (id: string) {
const pricingService = await initializePricingModule()
const priceRules = await pricingService.listPriceRules({
id: [id],
}, {
relations: ["price_set"]
})
// do something with the price rules or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRules (id: string, skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceRules = await pricingService.listPriceRules({
id: [id],
}, {
relations: ["price_set"],
skip,
take
})
// do something with the price rules or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRules (ids: string[], name: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceRules = await pricingService.listPriceRules({
$and: [
{
id: ids
},
{
name
}
]
}, {
relations: ["price_set"],
skip,
take
})
// do something with the price rules or return them
}
```
#### Parameters
#### Returns
Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>
___
### listPriceSetMoneyAmountRules
`**listPriceSetMoneyAmountRules**(filters?, config?, sharedContext?): Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>`
This method is used to retrieve a paginated list of price set money amount rules based on optional filters and configuration.
#### Example
To retrieve a list of price set money amount rules using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRules (id: string) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmountRules = await pricingService.listPriceSetMoneyAmountRules({
id: [id]
})
// do something with the price set money amount rules or return them
}
```
To specify relations that should be retrieved within the price set money amount rules:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRules (id: string) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmountRules = await pricingService.listPriceSetMoneyAmountRules({
id: [id]
}, {
relations: ["price_set_money_amount"]
})
// do something with the price set money amount rules or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRules (id: string, skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmountRules = await pricingService.listPriceSetMoneyAmountRules({
id: [id]
}, {
relations: ["price_set_money_amount"],
skip,
take
})
// do something with the price set money amount rules or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRules (ids: string[], ruleTypeId: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmountRules = await pricingService.listPriceSetMoneyAmountRules({
$and: [
{
id: ids
},
{
rule_type_id: ruleTypeId
}
]
}, {
relations: ["price_set_money_amount"],
skip,
take
})
// do something with the price set money amount rules or return them
}
```
#### Parameters
#### Returns
Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>
___
### listPriceSetMoneyAmounts
`**listPriceSetMoneyAmounts**(filters?, config?, sharedContext?): Promise<[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[]>`
This method is used to retrieve a paginated list of price set money amounts based on optional filters and configuration.
#### Example
To retrieve a list of price set money amounts using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmounts (id: string) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmounts = await pricingService.listPriceSetMoneyAmounts({
id: [id]
})
// do something with the price set money amounts or return them
}
```
To specify relations that should be retrieved within the price set money amounts:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmounts (id: string) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmounts = await pricingService.listPriceSetMoneyAmounts({
id: [id]
}, {
relations: ["price_rules"]
})
// do something with the price set money amounts or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmounts (id: string, skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmounts = await pricingService.listPriceSetMoneyAmounts({
id: [id]
}, {
relations: ["price_rules"],
skip,
take
})
// do something with the price set money amounts or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmounts (ids: string[], titles: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmounts = await pricingService.listPriceSetMoneyAmounts({
$and: [
{
id: ids
},
{
title: titles
}
]
}, {
relations: ["price_rules"],
skip,
take
})
// do something with the price set money amounts or return them
}
```
#### Parameters
#### Returns
Promise<[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[]>
___
### listRuleTypes
`**listRuleTypes**(filters?, config?, sharedContext?): Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>`
This method is used to retrieve a paginated list of rule types based on optional filters and configuration.
#### Example
To retrieve a list of rule types using their IDs:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleTypes (ruleTypeId: string) {
const pricingService = await initializePricingModule()
const ruleTypes = await pricingService.listRuleTypes({
id: [
ruleTypeId
]
})
// do something with the rule types or return them
}
```
To specify attributes that should be retrieved within the rule types:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleTypes (ruleTypeId: string) {
const pricingService = await initializePricingModule()
const ruleTypes = await pricingService.listRuleTypes({
id: [
ruleTypeId
]
}, {
select: ["name"]
})
// do something with the rule types or return them
}
```
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleTypes (ruleTypeId: string, skip: number, take: number) {
const pricingService = await initializePricingModule()
const ruleTypes = await pricingService.listRuleTypes({
id: [
ruleTypeId
]
}, {
select: ["name"],
skip,
take
})
// do something with the rule types or return them
}
```
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleTypes (ruleTypeId: string[], name: string[], skip: number, take: number) {
const pricingService = await initializePricingModule()
const ruleTypes = await pricingService.listRuleTypes({
$and: [
{
id: ruleTypeId
},
{
name
}
]
}, {
select: ["name"],
skip,
take
})
// do something with the rule types or return them
}
```
#### Parameters
#### Returns
Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>
___
### removePriceListRules
`**removePriceListRules**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)>`
This method is used to remove rules from a price list.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function setPriceListRules (priceListId: string) {
const pricingService = await initializePricingModule()
const priceList = await pricingService.removePriceListRules({
priceListId,
rules: ["region_id"]
})
// do something with the price list or return it
}
```
#### Parameters
#### Returns
Promise<[PriceListDTO](PriceListDTO.mdx)>
___
### removeRules
`**removeRules**(data, sharedContext?): Promise<void>`
This method remove rules from a price set.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function removePriceSetRule (priceSetId: string, ruleAttributes: []) {
const pricingService = await initializePricingModule()
await pricingService.removeRules([
{
id: priceSetId,
rules: ruleAttributes
},
])
}
```
#### Parameters
#### Returns
Promise<void>
___
### retrieve
`**retrieve**(id, config?, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)>`
This method is used to retrieve a price set by its ID.
#### Example
A simple example that retrieves a price set by its ID:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSet (priceSetId: string) {
const pricingService = await initializePricingModule()
const priceSet = await pricingService.retrieve(
priceSetId
)
// do something with the price set or return it
}
```
To specify relations that should be retrieved:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSet (priceSetId: string) {
const pricingService = await initializePricingModule()
const priceSet = await pricingService.retrieve(
priceSetId,
{
relations: ["money_amounts"]
}
)
// do something with the price set or return it
}
```
#### Parameters
#### Returns
Promise<[PriceSetDTO](PriceSetDTO.mdx)>
___
### retrieveCurrency
`**retrieveCurrency**(code, config?, sharedContext?): Promise<[CurrencyDTO](CurrencyDTO.mdx)>`
This method retrieves a currency by its code and and optionally based on the provided configurations.
#### Example
A simple example that retrieves a currency by its code:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveCurrency (code: string) {
const pricingService = await initializePricingModule()
const currency = await pricingService.retrieveCurrency(
code
)
// do something with the currency or return it
}
```
To specify attributes that should be retrieved:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveCurrency (code: string) {
const pricingService = await initializePricingModule()
const currency = await pricingService.retrieveCurrency(
code,
{
select: ["symbol_native"]
}
)
// do something with the currency or return it
}
```
#### Parameters
#### Returns
Promise<[CurrencyDTO](CurrencyDTO.mdx)>
___
### retrieveMoneyAmount
`**retrieveMoneyAmount**(id, config?, sharedContext?): Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)>`
This method retrieves a money amount by its ID.
#### Example
To retrieve a money amount by its ID:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmount (moneyAmountId: string) {
const pricingService = await initializePricingModule()
const moneyAmount = await pricingService.retrieveMoneyAmount(
moneyAmountId,
)
// do something with the money amount or return it
}
```
To retrieve relations along with the money amount:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveMoneyAmount (moneyAmountId: string) {
const pricingService = await initializePricingModule()
const moneyAmount = await pricingService.retrieveMoneyAmount(
moneyAmountId,
{
relations: ["currency"]
}
)
// do something with the money amount or return it
}
```
#### Parameters
#### Returns
Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)>
___
### retrievePriceList
`**retrievePriceList**(id, config?, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)>`
This method is used to retrieve a price list by its ID.
#### Example
A simple example that retrieves a price list by its ID:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceList (priceListId: string) {
const pricingService = await initializePricingModule()
const priceList = await pricingService.retrievePriceList(
priceListId
)
// do something with the price list or return it
}
```
To specify relations that should be retrieved:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceList (priceListId: string) {
const pricingService = await initializePricingModule()
const priceList = await pricingService.retrievePriceList(
priceListId,
{
relations: ["price_set_money_amounts"]
}
)
// do something with the price list or return it
}
```
#### Parameters
#### Returns
Promise<[PriceListDTO](PriceListDTO.mdx)>
___
### retrievePriceListRule
`**retrievePriceListRule**(id, config?, sharedContext?): Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)>`
This method is used to retrieve a price list rule by its ID.
#### Example
A simple example that retrieves a price list rule by its ID:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceListRule (priceListRuleId: string) {
const pricingService = await initializePricingModule()
const priceListRule = await pricingService.retrievePriceListRule(
priceListRuleId
)
// do something with the price list rule or return it
}
```
To specify relations that should be retrieved:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceListRule (priceListRuleId: string) {
const pricingService = await initializePricingModule()
const priceListRule = await pricingService.retrievePriceListRule(
priceListRuleId,
{
relations: ["price_list"]
}
)
// do something with the price list rule or return it
}
```
#### Parameters
#### Returns
Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)>
___
### retrievePriceRule
`**retrievePriceRule**(id, config?, sharedContext?): Promise<[PriceRuleDTO](PriceRuleDTO.mdx)>`
This method is used to retrieve a price rule by its ID.
#### Example
A simple example that retrieves a price rule by its ID:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRule (id: string) {
const pricingService = await initializePricingModule()
const priceRule = await pricingService.retrievePriceRule(id)
// do something with the price rule or return it
}
```
To specify relations that should be retrieved:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceRule (id: string) {
const pricingService = await initializePricingModule()
const priceRule = await pricingService.retrievePriceRule(id, {
relations: ["price_set"]
})
// do something with the price rule or return it
}
```
#### Parameters
#### Returns
Promise<[PriceRuleDTO](PriceRuleDTO.mdx)>
___
### retrievePriceSetMoneyAmountRules
`**retrievePriceSetMoneyAmountRules**(id, config?, sharedContext?): Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)>`
This method is used to a price set money amount rule by its ID based on the provided configuration.
#### Example
A simple example that retrieves a price set money amount rule by its ID:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRule (id: string) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmountRule = await pricingService.retrievePriceSetMoneyAmountRules(id)
// do something with the price set money amount rule or return it
}
```
To specify relations that should be retrieved:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrievePriceSetMoneyAmountRule (id: string) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmountRule = await pricingService.retrievePriceSetMoneyAmountRules(id, {
relations: ["price_set_money_amount"]
})
// do something with the price set money amount rule or return it
}
```
#### Parameters
#### Returns
Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)>
___
### retrieveRuleType
`**retrieveRuleType**(id, config?, sharedContext?): Promise<[RuleTypeDTO](RuleTypeDTO.mdx)>`
This method is used to retrieve a rule type by its ID and and optionally based on the provided configurations.
#### Example
A simple example that retrieves a rule type by its code:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleType (ruleTypeId: string) {
const pricingService = await initializePricingModule()
const ruleType = await pricingService.retrieveRuleType(ruleTypeId)
// do something with the rule type or return it
}
```
To specify attributes that should be retrieved:
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function retrieveRuleType (ruleTypeId: string) {
const pricingService = await initializePricingModule()
const ruleType = await pricingService.retrieveRuleType(ruleTypeId, {
select: ["name"]
})
// do something with the rule type or return it
}
```
#### Parameters
#### Returns
Promise<[RuleTypeDTO](RuleTypeDTO.mdx)>
___
### setPriceListRules
`**setPriceListRules**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)>`
This method is used to set the rules of a price list.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function setPriceListRules (priceListId: string) {
const pricingService = await initializePricingModule()
const priceList = await pricingService.setPriceListRules({
priceListId,
rules: {
region_id: "US"
}
})
// do something with the price list or return it
}
```
#### Parameters
#### Returns
Promise<[PriceListDTO](PriceListDTO.mdx)>
___
### updateCurrencies
`**updateCurrencies**(data, sharedContext?): Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>`
This method is used to update existing currencies with the provided data. In each currency object, the currency code must be provided to identify which currency to update.
#### Example
```ts
import { initialize as initializePricingModule } from "@medusajs/pricing"
async function updateCurrencies() {
const pricingService = await initializePricingModule()
const currencies = await pricingService.updateCurrencies([
{
code: "USD",
symbol: "$",
},
])
// do something with the currencies or return them
}
```
#### Parameters
#### Returns
Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>
___
### updateMoneyAmounts
`**updateMoneyAmounts**(data, sharedContext?): Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>`
This method updates existing money amounts.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function updateMoneyAmounts (moneyAmountId: string, amount: number) {
const pricingService = await initializePricingModule()
const moneyAmounts = await pricingService.updateMoneyAmounts([
{
id: moneyAmountId,
amount
}
])
// do something with the money amounts or return them
}
```
#### Parameters
#### Returns
Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>
___
### updatePriceListRules
`**updatePriceListRules**(data, sharedContext?): Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>`
This method is used to update price list rules.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function updatePriceListRules (items: {
id: string
rule_type_id?: string
price_list_id?: string
}[]) {
const pricingService = await initializePricingModule()
const priceListRules = await pricingService.updatePriceListRules(items)
// do something with the price list rule or return them
}
```
#### Parameters
#### Returns
Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>
___
### updatePriceLists
`**updatePriceLists**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)[]>`
This method is used to update price lists.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function updatePriceLists (items: {
id: string
title: string
description: string
starts_at?: string
ends_at?: string
}[]) {
const pricingService = await initializePricingModule()
const priceList = await pricingService.updatePriceLists(items)
// do something with the price lists or return them
}
```
#### Parameters
#### Returns
Promise<[PriceListDTO](PriceListDTO.mdx)[]>
___
### updatePriceRules
`**updatePriceRules**(data, sharedContext?): Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>`
This method is used to update price rules, each with their provided data.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function updatePriceRules (
id: string,
priceSetId: string,
) {
const pricingService = await initializePricingModule()
const priceRules = await pricingService.updatePriceRules([
{
id,
price_set_id: priceSetId,
}
])
// do something with the price rules or return them
}
```
#### Parameters
#### Returns
Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>
___
### updatePriceSetMoneyAmountRules
`**updatePriceSetMoneyAmountRules**(data, sharedContext?): Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>`
This method is used to update price set money amount rules, each with their provided data.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function updatePriceSetMoneyAmountRules (id: string, value: string) {
const pricingService = await initializePricingModule()
const priceSetMoneyAmountRules = await pricingService.updatePriceSetMoneyAmountRules([
{
id,
value
}
])
// do something with the price set money amount rules or return them
}
```
#### Parameters
#### Returns
Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>
___
### updateRuleTypes
`**updateRuleTypes**(data, sharedContext?): Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>`
This method is used to update existing rule types with the provided data.
#### Example
```ts
import {
initialize as initializePricingModule,
} from "@medusajs/pricing"
async function updateRuleTypes (ruleTypeId: string) {
const pricingService = await initializePricingModule()
const ruleTypes = await pricingService.updateRuleTypes([
{
id: ruleTypeId,
name: "Region",
}
])
// do something with the rule types or return them
}
```
#### Parameters
#### Returns
Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>