@medusajs/types 1.12.0-snapshot-20240531102054 → 1.12.0-snapshot-20240701122250

package/dist/inventory/service.d.ts

@@ -1,601 +1,637 @@
-import { BulkUpdateInventoryLevelInput, CreateInventoryItemInput, CreateInventoryLevelInput, CreateReservationItemInput, FilterableInventoryItemProps, FilterableInventoryLevelProps, FilterableReservationItemProps, InventoryItemDTO, InventoryLevelDTO, ReservationItemDTO, UpdateInventoryLevelInput, UpdateReservationItemInput } from "./common";
+import { RestoreReturn, SoftDeleteReturn } from "../dal";
 import { FindConfig } from "../common";
 import { IModuleService } from "../modules-sdk";
-import { SharedContext } from "../shared-context";
+import { Context } from "../shared-context";
+import { FilterableInventoryItemProps, FilterableInventoryLevelProps, FilterableReservationItemProps, InventoryItemDTO, InventoryLevelDTO, ReservationItemDTO } from "./common";
+import { BulkUpdateInventoryLevelInput, CreateInventoryItemInput, CreateInventoryLevelInput, CreateReservationItemInput, UpdateInventoryItemInput, UpdateReservationItemInput } from "./mutations";
 /**
- * The main service interface for the inventory module.
+ * The main service interface for the Inventory Module.
  */
 export interface IInventoryService extends IModuleService {
     /**
-     * This method is used to retrieve a paginated list of inventory items along with the total count of available inventory items satisfying the provided filters.
+     * This method retrieves a paginated list of inventory items based on optional filters and configuration.
+     *
      * @param {FilterableInventoryItemProps} selector - The filters to apply on the retrieved inventory items.
-     * @param {FindConfig<InventoryItemDTO>} config -
-     * The configurations determining how the inventory items are retrieved. Its properties, such as `select` or `relations`, accept the
+     * @param {FindConfig<InventoryItemDTO>} config - The configurations determining how the inventory item is retrieved. Its properties, such as `select` or `relations`, accept the
      * attributes or relations associated with a inventory item.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @return {Promise<[InventoryItemDTO[], number]>} The list of inventory items along with the total count.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryItemDTO[]>} The list of inventory items.
      *
      * @example
      * To retrieve a list of inventory items using their IDs:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveInventoryItems (ids: string[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * const inventoryItems = await inventoryModuleService.listInventoryItems({
+     *   id: ["iitem_123", "iitem_321"],
+     * })
+     * ```
      *
-     *   const [inventoryItems, count] = await inventoryModule.listInventoryItems({
-     *     id: ids
-     *   })
+     * To specify relations that should be retrieved within the inventory items:
      *
-     *   // do something with the inventory items or return them
-     * }
+     * ```ts
+     * const inventoryItems = await inventoryModuleService.listInventoryItems(
+     *   {
+     *     id: ["iitem_123", "iitem_321"],
+     *   },
+     *   {
+     *     relations: ["location_levels"],
+     *   }
+     * )
      * ```
      *
-     * To specify relations that should be retrieved within the inventory items:
+     * By default, only the first `10` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * const inventoryItems = await inventoryModuleService.listInventoryItems(
+     *   {
+     *     id: ["iitem_123", "iitem_321"],
+     *   },
+     *   {
+     *     relations: ["location_levels"],
+     *     take: 20,
+     *     skip: 2,
+     *   }
+     * )
+     * ```
+     */
+    listInventoryItems(selector: FilterableInventoryItemProps, config?: FindConfig<InventoryItemDTO>, context?: Context): Promise<InventoryItemDTO[]>;
+    /**
+     * This method retrieves a paginated list of inventory items along with the total count of available inventory items satisfying the provided filters.
      *
-     * async function retrieveInventoryItems (ids: string[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {FilterableInventoryItemProps} selector - The filters to apply on the retrieved inventory items.
+     * @param {FindConfig<InventoryItemDTO>} config - The configurations determining how the inventory item is retrieved. Its properties, such as `select` or `relations`, accept the
+     * attributes or relations associated with a inventory item.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<[InventoryItemDTO[], number]>} The list of inventory items along with their total count.
      *
-     *   const [inventoryItems, count] = await inventoryModule.listInventoryItems({
-     *     id: ids
-     *   }, {
-     *     relations: ["inventory_level"]
-     *   })
+     * @example
+     * To retrieve a list of inventory items using their IDs:
      *
-     *   // do something with the inventory items or return them
-     * }
+     * ```ts
+     * const [inventoryItems, count] =
+     *   await inventoryModuleService.listAndCountInventoryItems({
+     *     id: ["iitem_123", "iitem_321"],
+     *   })
      * ```
      *
-     * By default, only the first `10` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
+     * To specify relations that should be retrieved within the inventory items:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveInventoryItems (ids: string[], skip: number, take: number) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * const [inventoryItems, count] =
+     *   await inventoryModuleService.listAndCountInventoryItems(
+     *     {
+     *       id: ["iitem_123", "iitem_321"],
+     *     },
+     *     {
+     *       relations: ["location_levels"],
+     *     }
+     *   )
+     * ```
      *
-     *   const [inventoryItems, count] = await inventoryModule.listInventoryItems({
-     *     id: ids
-     *   }, {
-     *     relations: ["inventory_level"],
-     *     skip,
-     *     take
-     *   })
+     * By default, only the first `10` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
      *
-     *   // do something with the inventory items or return them
-     * }
+     * ```ts
+     * const [inventoryItems, count] =
+     *   await inventoryModuleService.listAndCountInventoryItems(
+     *     {
+     *       id: ["iitem_123", "iitem_321"],
+     *     },
+     *     {
+     *       relations: ["location_levels"],
+     *       take: 20,
+     *       skip: 2,
+     *     }
+     *   )
      * ```
      */
-    listInventoryItems(selector: FilterableInventoryItemProps, config?: FindConfig<InventoryItemDTO>, context?: SharedContext): Promise<[InventoryItemDTO[], number]>;
+    listAndCountInventoryItems(selector: FilterableInventoryItemProps, config?: FindConfig<InventoryItemDTO>, context?: Context): Promise<[InventoryItemDTO[], number]>;
     /**
-     * This method is used to retrieve a paginated list of reservation items along with the total count of available reservation items satisfying the provided filters.
+     * This method retrieves a paginated list of reservation items based on optional filters and configuration.
+     *
      * @param {FilterableReservationItemProps} selector - The filters to apply on the retrieved reservation items.
-     * @param {FindConfig<ReservationItemDTO>} config -
-     * The configurations determining how the reservation items are retrieved. Its properties, such as `select` or `relations`, accept the
+     * @param {FindConfig<ReservationItemDTO>} config - The configurations determining how the reservation item is retrieved. Its properties, such as `select` or `relations`, accept the
      * attributes or relations associated with a reservation item.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @return {Promise<[ReservationItemDTO[], number]>} The list of reservation items along with the total count.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ReservationItemDTO[]>} The list of reservation items.
      *
      * @example
      * To retrieve a list of reservation items using their IDs:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveReservationItems (ids: string[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const [reservationItems, count] = await inventoryModule.listReservationItems({
-     *     id: ids
+     * const reservationItems =
+     *   await inventoryModuleService.listReservationItems({
+     *     id: ["resitem_123", "resitem_321"],
      *   })
-     *
-     *   // do something with the reservation items or return them
-     * }
      * ```
      *
      * To specify relations that should be retrieved within the reservation items:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveReservationItems (ids: string[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const [reservationItems, count] = await inventoryModule.listReservationItems({
-     *     id: ids
-     *   }, {
-     *     relations: ["inventory_item"]
-     *   })
-     *
-     *   // do something with the reservation items or return them
-     * }
+     * const reservationItems =
+     *   await inventoryModuleService.listReservationItems(
+     *     {
+     *       id: ["resitem_123", "resitem_321"],
+     *     },
+     *     {
+     *       relations: ["inventory_item"],
+     *     }
+     *   )
      * ```
      *
      * By default, only the first `10` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * const reservationItems =
+     *   await inventoryModuleService.listReservationItems(
+     *     {
+     *       id: ["resitem_123", "resitem_321"],
+     *     },
+     *     {
+     *       relations: ["inventory_item"],
+     *       take: 20,
+     *       skip: 2,
+     *     }
+     *   )
+     * ```
+     */
+    listReservationItems(selector: FilterableReservationItemProps, config?: FindConfig<ReservationItemDTO>, context?: Context): Promise<ReservationItemDTO[]>;
+    /**
+     * This method retrieves a paginated list of reservation items along with the total count of available reservation items satisfying the provided filters.
      *
-     * async function retrieveReservationItems (ids: string[], skip: number, take: number) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {FilterableReservationItemProps} selector - The filters to apply on the retrieved reservation items.
+     * @param {FindConfig<ReservationItemDTO>} config - The configurations determining how the reservation item is retrieved. Its properties, such as `select` or `relations`, accept the
+     * attributes or relations associated with a reservation item.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<[ReservationItemDTO[], number]>} The list of reservation items along with their total count.
      *
-     *   const [reservationItems, count] = await inventoryModule.listReservationItems({
-     *     id: ids
-     *   }, {
-     *     relations: ["inventory_item"],
-     *     skip,
-     *     take
+     * @example
+     * To retrieve a list of reservation items using their IDs:
+     *
+     * ```ts
+     * const [reservationItems, count] =
+     *   await inventoryModuleService.listAndCountReservationItems({
+     *     id: ["resitem_123", "resitem_321"],
      *   })
+     * ```
      *
-     *   // do something with the reservation items or return them
-     * }
+     * To specify relations that should be retrieved within the reservation items:
+     *
+     * ```ts
+     * const [reservationItems, count] =
+     *   await inventoryModuleService.listAndCountReservationItems(
+     *     {
+     *       id: ["resitem_123", "resitem_321"],
+     *     },
+     *     {
+     *       relations: ["inventory_item"],
+     *     }
+     *   )
+     * ```
+     *
+     * By default, only the first `10` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
+     *
+     * ```ts
+     * const [reservationItems, count] =
+     *   await inventoryModuleService.listAndCountReservationItems(
+     *     {
+     *       id: ["resitem_123", "resitem_321"],
+     *     },
+     *     {
+     *       relations: ["inventory_item"],
+     *       take: 20,
+     *       skip: 2,
+     *     }
+     *   )
      * ```
      */
-    listReservationItems(selector: FilterableReservationItemProps, config?: FindConfig<ReservationItemDTO>, context?: SharedContext): Promise<[ReservationItemDTO[], number]>;
+    listAndCountReservationItems(selector: FilterableReservationItemProps, config?: FindConfig<ReservationItemDTO>, context?: Context): Promise<[ReservationItemDTO[], number]>;
     /**
-     * This method is used to retrieve a paginated list of inventory levels along with the total count of available inventory levels satisfying the provided filters.
+     * This method retrieves a paginated list of inventory levels based on optional filters and configuration.
+     *
      * @param {FilterableInventoryLevelProps} selector - The filters to apply on the retrieved inventory levels.
-     * @param {FindConfig<InventoryLevelDTO>} config -
-     * The configurations determining how the inventory levels are retrieved. Its properties, such as `select` or `relations`, accept the
+     * @param {FindConfig<InventoryLevelDTO>} config - The configurations determining how the inventory level is retrieved. Its properties, such as `select` or `relations`, accept the
      * attributes or relations associated with a inventory level.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @return {Promise<[InventoryLevelDTO[], number]>} The list of inventory levels along with the total count.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryLevelDTO[]>} The list of inventory levels.
      *
      * @example
-     * To retrieve a list of inventory levels using their IDs:
+     * To retrieve a list of inventory levels using the IDs of their associated inventory items:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveInventoryLevels (inventoryItemIds: string[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const [inventoryLevels, count] = await inventoryModule.listInventoryLevels({
-     *     inventory_item_id: inventoryItemIds
+     * const inventoryLevels =
+     *   await inventoryModuleService.listInventoryLevels({
+     *     inventory_item_id: ["iitem_123", "iitem_321"],
      *   })
-     *
-     *   // do something with the inventory levels or return them
-     * }
      * ```
      *
      * To specify relations that should be retrieved within the inventory levels:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * const inventoryLevels =
+     *   await inventoryModuleService.listInventoryLevels(
+     *     {
+     *       inventory_item_id: ["iitem_123", "iitem_321"],
+     *     },
+     *     {
+     *       relations: ["inventory_item"],
+     *     }
+     *   )
+     * ```
      *
-     * async function retrieveInventoryLevels (inventoryItemIds: string[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * By default, only the first `10` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
      *
-     *   const [inventoryLevels, count] = await inventoryModule.listInventoryLevels({
-     *     inventory_item_id: inventoryItemIds
-     *   }, {
-     *     relations: ["inventory_item"]
-     *   })
+     * ```ts
+     * const inventoryLevels =
+     *   await inventoryModuleService.listInventoryLevels(
+     *     {
+     *       inventory_item_id: ["iitem_123", "iitem_321"],
+     *     },
+     *     {
+     *       relations: ["inventory_item"],
+     *       take: 20,
+     *       skip: 2,
+     *     }
+     *   )
+     * ```
+     */
+    listInventoryLevels(selector: FilterableInventoryLevelProps, config?: FindConfig<InventoryLevelDTO>, context?: Context): Promise<InventoryLevelDTO[]>;
+    /**
+     * This method retrieves a paginated list of inventory levels along with the total count of available inventory levels satisfying the provided filters.
      *
-     *   // do something with the inventory levels or return them
-     * }
+     * @param {FilterableInventoryLevelProps} selector - The filters to apply on the retrieved inventory levels.
+     * @param {FindConfig<InventoryLevelDTO>} config - The configurations determining how the inventory level is retrieved. Its properties, such as `select` or `relations`, accept the
+     * attributes or relations associated with a inventory level.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<[InventoryLevelDTO[], number]>} The list of inventory levels along with their total count.
+     *
+     * @example
+     * To retrieve a list of inventory levels using the IDs of their associated inventory items:
+     *
+     * ```ts
+     * const [inventoryLevels, count] =
+     *   await inventoryModuleService.listAndCountInventoryLevels(
+     *     {
+     *       inventory_item_id: ["iitem_123", "iitem_321"],
+     *     },
+     *     {
+     *       relations: ["inventory_item"],
+     *       take: 20,
+     *       skip: 2,
+     *     }
+     *   )
      * ```
      *
-     * By default, only the first `10` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
+     * To specify relations that should be retrieved within the inventory levels:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * const [inventoryLevels, count] =
+     *   await inventoryModuleService.listAndCountInventoryLevels(
+     *     {
+     *       inventory_item_id: ["iitem_123", "iitem_321"],
+     *     },
+     *     {
+     *       relations: ["inventory_item"],
+     *     }
+     *   )
+     * ```
      *
-     * async function retrieveInventoryLevels (inventoryItemIds: string[], skip: number, take: number) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * By default, only the first `10` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
      *
-     *   const [inventoryLevels, count] = await inventoryModule.listInventoryLevels({
-     *     inventory_item_id: inventoryItemIds
-     *   }, {
-     *     relations: ["inventory_item"],
-     *     skip,
-     *     take
+     * ```ts
+     * const [inventoryLevels, count] =
+     *   await inventoryModuleService.listAndCountInventoryLevels({
+     *     inventory_item_id: ["iitem_123", "iitem_321"],
      *   })
-     *
-     *   // do something with the inventory levels or return them
-     * }
      * ```
      */
-    listInventoryLevels(selector: FilterableInventoryLevelProps, config?: FindConfig<InventoryLevelDTO>, context?: SharedContext): Promise<[InventoryLevelDTO[], number]>;
+    listAndCountInventoryLevels(selector: FilterableInventoryLevelProps, config?: FindConfig<InventoryLevelDTO>, context?: Context): Promise<[InventoryLevelDTO[], number]>;
     /**
-     * This method is used to retrieve an inventory item by its ID
+     * This method retrieves an inventory item by its ID.
      *
-     * @param {string} inventoryItemId - The ID of the inventory item to retrieve.
-     * @param {FindConfig<InventoryItemDTO>} config -
-     * The configurations determining how the inventory item is retrieved. Its properties, such as `select` or `relations`, accept the
+     * @param {string} inventoryItemId - The inventory item's ID.
+     * @param {FindConfig<InventoryItemDTO>} config - The configurations determining how the inventory item is retrieved. Its properties, such as `select` or `relations`, accept the
      * attributes or relations associated with a inventory item.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
      * @returns {Promise<InventoryItemDTO>} The retrieved inventory item.
      *
      * @example
      * A simple example that retrieves a inventory item by its ID:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveInventoryItem (id: string) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const inventoryItem = await inventoryModule.retrieveInventoryItem(id)
-     *
-     *   // do something with the inventory item or return it
-     * }
+     * const inventoryItem =
+     *   await inventoryModuleService.retrieveInventoryItem("iitem_123")
      * ```
      *
      * To specify relations that should be retrieved:
      *
      * ```ts
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveInventoryItem (id: string) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const inventoryItem = await inventoryModule.retrieveInventoryItem(id, {
-     *     relations: ["inventory_level"]
-     *   })
-     *
-     *   // do something with the inventory item or return it
-     * }
+     * const inventoryItem = await inventoryModuleService.retrieveInventoryItem(
+     *   "iitem_123",
+     *   {
+     *     relations: ["location_levels"],
+     *   }
+     * )
      * ```
      */
-    retrieveInventoryItem(inventoryItemId: string, config?: FindConfig<InventoryItemDTO>, context?: SharedContext): Promise<InventoryItemDTO>;
+    retrieveInventoryItem(inventoryItemId: string, config?: FindConfig<InventoryItemDTO>, context?: Context): Promise<InventoryItemDTO>;
     /**
-     * This method is used to retrieve an inventory level for an inventory item and a location.
+     * This method retrieves an inventory level based on its associated inventory item and location.
      *
-     * @param {string} inventoryItemId - The ID of the inventory item.
-     * @param {string} locationId - The ID of the location.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @param {string} inventoryItemId - The inventory item's ID.
+     * @param {string} locationId - The location's ID.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
      * @returns {Promise<InventoryLevelDTO>} The retrieved inventory level.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveInventoryLevel (
-     *   inventoryItemId: string,
-     *   locationId: string
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const inventoryLevel = await inventoryModule.retrieveInventoryLevel(
-     *     inventoryItemId,
-     *     locationId
+     * const inventoryLevel =
+     *   await inventoryModuleService.retrieveInventoryLevelByItemAndLocation(
+     *     "iitem_123",
+     *     "loc_123"
      *   )
-     *
-     *   // do something with the inventory level or return it
-     * }
      */
-    retrieveInventoryLevel(inventoryItemId: string, locationId: string, context?: SharedContext): Promise<InventoryLevelDTO>;
+    retrieveInventoryLevelByItemAndLocation(inventoryItemId: string, locationId: string, context?: Context): Promise<InventoryLevelDTO>;
     /**
-     * This method is used to retrieve a reservation item by its ID.
+     * This method retrieves an inventory level by its ID.
      *
-     * @param {string} reservationId - The ID of the reservation item.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ReservationItemDTO>} The retrieved reservation item.
+     * @param {string} inventoryLevelId - The inventory level's ID.
+     * @param {FindConfig<InventoryLevelDTO>} config - The configurations determining how the inventory level is retrieved. Its properties, such as `select` or `relations`, accept the
+     * attributes or relations associated with a inventory level.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryLevelDTO>} The retrieved inventory level.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * A simple example that retrieves a inventory level by its ID:
      *
-     * async function retrieveReservationItem (id: string) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * ```ts
+     * const inventoryLevel =
+     *   await inventoryModuleService.retrieveInventoryLevel(
+     *     "iitem_123"
+     *   )
+     * ```
      *
-     *   const reservationItem = await inventoryModule.retrieveReservationItem(id)
+     * To specify relations that should be retrieved:
      *
-     *   // do something with the reservation item or return it
-     * }
+     * ```ts
+     * const inventoryLevel =
+     *   await inventoryModuleService.retrieveInventoryLevel(
+     *     "iitem_123",
+     *     {
+     *       relations: ["inventory_item"],
+     *     }
+     *   )
+     * ```
      */
-    retrieveReservationItem(reservationId: string, context?: SharedContext): Promise<ReservationItemDTO>;
+    retrieveInventoryLevel(inventoryLevelId: string, config?: FindConfig<InventoryLevelDTO>, context?: Context): Promise<InventoryLevelDTO>;
     /**
-     * This method is used to create a reservation item.
+     * This method retrieves a reservation item by its ID.
      *
-     * @param {CreateReservationItemInput} input - The details of the reservation item to create.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ReservationItemDTO>} The created reservation item's details.
+     * @param {string} reservationId - The reservation's ID.
+     * @param {FindConfig<ReservationItemDTO>} config - The configurations determining how the reservation item is retrieved. Its properties, such as `select` or `relations`, accept the
+     * attributes or relations associated with a reservation item.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ReservationItemDTO>} The retrieved reservation item.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * A simple example that retrieves a reservation item by its ID:
      *
-     * async function createReservationItem (item: {
-     *   inventory_item_id: string,
-     *   location_id: string,
-     *   quantity: number
-     * }) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const reservationItem = await inventoryModule.createReservationItems(
-     *     item
+     * ```ts
+     * const reservationItem =
+     *   await inventoryModuleService.retrieveReservationItem(
+     *     "resitem"
      *   )
+     * ```
      *
-     *   // do something with the reservation item or return them
-     * }
+     * To specify relations that should be retrieved:
+     *
+     * ```ts
+     * const reservationItem =
+     *   await inventoryModuleService.retrieveReservationItem(
+     *     "resitem",
+     *     {
+     *       relations: ["inventory_item"],
+     *     }
+     *   )
+     * ```
      */
-    createReservationItem(input: CreateReservationItemInput, context?: SharedContext): Promise<ReservationItemDTO>;
+    retrieveReservationItem(reservationId: string, config?: FindConfig<ReservationItemDTO>, context?: Context): Promise<ReservationItemDTO>;
     /**
-     * This method is used to create reservation items.
+     * This method creates reservation items.
      *
-     * @param {CreateReservationItemInput[]} input - The details of the reservation items to create.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns { Promise<ReservationItemDTO[]>} The created reservation items' details.
+     * @param {CreateReservationItemInput[]} input - The details of the reservation items to be created.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ReservationItemDTO[]>} The created reservation items.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function createReservationItems (items: {
-     *   inventory_item_id: string,
-     *   location_id: string,
-     *   quantity: number
-     * }[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const reservationItems = await inventoryModule.createReservationItems(
-     *     items
-     *   )
-     *
-     *   // do something with the reservation items or return them
-     * }
+     * const reservationItems =
+     *   await inventoryModuleService.createReservationItems([
+     *     {
+     *       inventory_item_id: "iitem_123",
+     *       location_id: "loc_123",
+     *       quantity: 10,
+     *     },
+     *   ])
      */
-    createReservationItems(input: CreateReservationItemInput[], context?: SharedContext): Promise<ReservationItemDTO[]>;
+    createReservationItems(input: CreateReservationItemInput[], context?: Context): Promise<ReservationItemDTO[]>;
     /**
-     * This method is used to create an inventory item.
+     * This method creates a reservation item.
      *
-     * @param {CreateInventoryItemInput} input - The details of the inventory item to create.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<InventoryItemDTO>} The created inventory item's details.
+     * @param {CreateReservationItemInput} input - The details of the reservation item to be created.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ReservationItemDTO>} The created reservation item.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function createInventoryItem (item: {
-     *   sku: string,
-     *   requires_shipping: boolean
-     * }) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const inventoryItem = await inventoryModule.createInventoryItem(
-     *     item
-     *   )
-     *
-     *   // do something with the inventory item or return it
-     * }
+     * const reservationItem =
+     *   await inventoryModuleService.createReservationItems({
+     *     inventory_item_id: "iitem_123",
+     *     location_id: "loc_123",
+     *     quantity: 10,
+     *   })
      */
-    createInventoryItem(input: CreateInventoryItemInput, context?: SharedContext): Promise<InventoryItemDTO>;
+    createReservationItems(input: CreateReservationItemInput, context?: Context): Promise<ReservationItemDTO>;
     /**
-     * This method is used to create inventory items.
+     * This method creates inventory items.
      *
-     * @param {CreateInventoryItemInput[]} input - The details of the inventory items to create.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<InventoryItemDTO[]>} The created inventory items' details.
+     * @param {CreateInventoryItemInput[]} input - The details of the inventory items to be created.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryItemDTO[]>} The created inventory items.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function createInventoryItems (items: {
-     *   sku: string,
-     *   requires_shipping: boolean
-     * }[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const inventoryItems = await inventoryModule.createInventoryItems(
-     *     items
-     *   )
-     *
-     *   // do something with the inventory items or return them
-     * }
+     * const inventoryItems = await inventoryModuleService.createInventoryItems([
+     *   {
+     *     sku: "SHIRT",
+     *   },
+     * ])
      */
-    createInventoryItems(input: CreateInventoryItemInput[], context?: SharedContext): Promise<InventoryItemDTO[]>;
+    createInventoryItems(input: CreateInventoryItemInput[], context?: Context): Promise<InventoryItemDTO[]>;
     /**
-     * This method is used to create inventory level.
+     * This method creates an inventory item.
      *
-     * @param {CreateInventoryLevelInput} data - The details of the inventory level to create.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<InventoryLevelDTO>} The created inventory level's details.
+     * @param {CreateInventoryItemInput} input - The details of the inventory item to be created.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryItemDTO>} The created inventory item.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function createInventoryLevel (item: {
-     *   inventory_item_id: string
-     *   location_id: string
-     *   stocked_quantity: number
-     * }) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const inventoryLevel = await inventoryModule.createInventoryLevel(
-     *     item
-     *   )
-     *
-     *   // do something with the inventory level or return it
-     * }
+     * const inventoryItem = await inventoryModuleService.createInventoryItems({
+     *   sku: "SHIRT",
+     * })
      */
-    createInventoryLevel(data: CreateInventoryLevelInput, context?: SharedContext): Promise<InventoryLevelDTO>;
+    createInventoryItems(input: CreateInventoryItemInput, context?: Context): Promise<InventoryItemDTO>;
     /**
-     * This method is used to create inventory levels.
+     * This method creates inventory levels.
      *
-     * @param {CreateInventoryLevelInput[]} data - The details of the inventory levels to create.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<InventoryLevelDTO[]>} The created inventory levels' details.
+     * @param {CreateInventoryLevelInput[]} data - The details of the inventory levels to be created.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryLevelDTO[]>} The created inventory levels.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function createInventoryLevels (items: {
-     *   inventory_item_id: string
-     *   location_id: string
-     *   stocked_quantity: number
-     * }[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const inventoryLevels = await inventoryModule.createInventoryLevels(
-     *     items
-     *   )
-     *
-     *   // do something with the inventory levels or return them
-     * }
+     * const inventoryLevels =
+     *   await inventoryModuleService.createInventoryLevels([
+     *     {
+     *       inventory_item_id: "iitem_123",
+     *       location_id: "loc_123",
+     *       stocked_quantity: 10,
+     *     },
+     *     {
+     *       inventory_item_id: "iitem_321",
+     *       location_id: "loc_321",
+     *       stocked_quantity: 20,
+     *       reserved_quantity: 10,
+     *     },
+     *   ])
      */
-    createInventoryLevels(data: CreateInventoryLevelInput[], context?: SharedContext): Promise<InventoryLevelDTO[]>;
+    createInventoryLevels(data: CreateInventoryLevelInput[], context?: Context): Promise<InventoryLevelDTO[]>;
     /**
-     * This method is used to update inventory levels. Each inventory level is identified by the IDs of its associated inventory item and location.
+     * This method creates an inventory level.
      *
-     * @param {BulkUpdateInventoryLevelInput} updates - The attributes to update in each inventory level.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<InventoryLevelDTO[]>} The updated inventory levels' details.
+     * @param {CreateInventoryLevelInput} data - The details of the inventory level to be created.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryLevelDTO>} The created inventory level.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function updateInventoryLevels (items: {
-     *   inventory_item_id: string,
-     *   location_id: string,
-     *   stocked_quantity: number
-     * }[]) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const inventoryLevels = await inventoryModule.updateInventoryLevels(
-     *     items
-     *   )
-     *
-     *   // do something with the inventory levels or return them
-     * }
+     * const inventoryLevels =
+     *   await inventoryModuleService.createInventoryLevels({
+     *     inventory_item_id: "iitem_123",
+     *     location_id: "loc_123",
+     *     stocked_quantity: 10,
+     *   })
      */
-    updateInventoryLevels(updates: BulkUpdateInventoryLevelInput[], context?: SharedContext): Promise<InventoryLevelDTO[]>;
+    createInventoryLevels(data: CreateInventoryLevelInput, context?: Context): Promise<InventoryLevelDTO>;
     /**
-     * This method is used to update an inventory level. The inventory level is identified by the IDs of its associated inventory item and location.
+     * This method updates existing inventory levels.
      *
-     * @param {string} inventoryItemId - The ID of the inventory item.
-     * @param {string} locationId - The ID of the location.
-     * @param {UpdateInventoryLevelInput} update - The attributes to update in the location level.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<InventoryLevelDTO>} The updated inventory level's details.
+     * @param {BulkUpdateInventoryLevelInput[]} updates - The list of The attributes to update in an inventory level. The inventory level is identified by the IDs of its associated inventory item and location.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryLevelDTO[]>} The updated inventory levels.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function updateInventoryLevel (
-     *   inventoryItemId: string,
-     *   locationId: string,
-     *   stockedQuantity: number
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const inventoryLevel = await inventoryModule.updateInventoryLevels(
-     *     inventoryItemId,
-     *     locationId,
+     * const inventoryLevels =
+     *   await inventoryModuleService.updateInventoryLevels([
      *     {
-     *       stocked_quantity: stockedQuantity
-     *     }
-     *   )
-     *
-     *   // do something with the inventory level or return it
-     * }
+     *       inventory_item_id: "iitem_123",
+     *       location_id: "loc_123",
+     *       id: "ilev_123",
+     *       stocked_quantity: 20,
+     *     },
+     *   ])
      */
-    updateInventoryLevel(inventoryItemId: string, locationId: string, update: UpdateInventoryLevelInput, context?: SharedContext): Promise<InventoryLevelDTO>;
+    updateInventoryLevels(updates: BulkUpdateInventoryLevelInput[], context?: Context): Promise<InventoryLevelDTO[]>;
     /**
-     * This method is used to update an inventory item.
+     * This method updates an existing inventory level.
      *
-     * @param {string} inventoryItemId - The ID of the inventory item.
-     * @param {Partial<CreateInventoryItemInput>} input - The attributes to update in the inventory item.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<InventoryItemDTO>} The updated inventory item's details.
+     * @param {BulkUpdateInventoryLevelInput} updates - The attributes to update in an inventory level. The inventory level is identified by the IDs of its associated inventory item and location.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryLevelDTO>} The updated inventory level.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * const inventoryLevel =
+     *   await inventoryModuleService.updateInventoryLevels({
+     *     inventory_item_id: "iitem_123",
+     *     location_id: "loc_123",
+     *     stocked_quantity: 20,
+     *   })
+     */
+    updateInventoryLevels(updates: BulkUpdateInventoryLevelInput, context?: Context): Promise<InventoryLevelDTO>;
+    /**
+     * This method updates an existing inventory item.
      *
-     * async function updateInventoryItem (
-     *   inventoryItemId: string,
-     *   sku: string
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {UpdateInventoryItemInput} input - The attributes to update in the inventory item.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryItemDTO>} The updated inventory item.
      *
-     *   const inventoryItem = await inventoryModule.updateInventoryItem(
-     *     inventoryItemId,
-     *     {
-     *       sku
-     *     }
-     *   )
+     * @example
+     * const inventoryItem = await inventoryModuleService.updateInventoryItems({
+     *   id: "iitem_123",
+     *   title: "Medusa Shirt Inventory",
+     * })
+     */
+    updateInventoryItems(input: UpdateInventoryItemInput, context?: Context): Promise<InventoryItemDTO>;
+    /**
+     * This method updates existing inventory items.
      *
-     *   // do something with the inventory item or return it
-     * }
+     * @param {UpdateInventoryItemInput[]} input - The attributes to update in the inventory items.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryItemDTO[]>} The updated inventory items.
+     *
+     * @example
+     * const inventoryItems = await inventoryModuleService.updateInventoryItems([
+     *   {
+     *     id: "iitem_123",
+     *     title: "Medusa Shirt Inventory",
+     *   },
+     *   {
+     *     id: "iitem_321",
+     *     description: "The inventory of Medusa pants",
+     *   },
+     * ])
      */
-    updateInventoryItem(inventoryItemId: string, input: Partial<CreateInventoryItemInput>, context?: SharedContext): Promise<InventoryItemDTO>;
+    updateInventoryItems(input: UpdateInventoryItemInput[], context?: Context): Promise<InventoryItemDTO[]>;
     /**
-     * This method is used to update a reservation item.
+     * This method updates an existing reservation item.
      *
-     * @param {string} reservationItemId - The ID of the reservation item.
-     * @param {UpdateReservationItemInput} input - The attributes to update in the reservation item.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @param {UpdateReservationItemInput} input - The attributes to update in a reservation item.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
      * @returns {Promise<ReservationItemDTO>} The updated reservation item.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * const reservationItem =
+     *   await inventoryModuleService.updateReservationItems({
+     *     id: "resitem_123",
+     *     quantity: 10,
+     *   })
+     */
+    updateReservationItems(input: UpdateReservationItemInput, context?: Context): Promise<ReservationItemDTO>;
+    /**
+     * This method updates existing reservation items.
      *
-     * async function updateReservationItem (
-     *   reservationItemId: string,
-     *   quantity: number
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {UpdateReservationItemInput[]} input - The attributes to update in the reservation items.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ReservationItemDTO[]>} The updated reservation items.
      *
-     *   const reservationItem = await inventoryModule.updateReservationItem(
-     *     reservationItemId,
+     * @example
+     * const reservationItems =
+     *   await inventoryModuleService.updateReservationItems([
      *     {
-     *       quantity
-     *     }
-     *   )
+     *       id: "resitem_123",
+     *       quantity: 10,
+     *     },
+     *   ])
+     */
+    updateReservationItems(input: UpdateReservationItemInput[], context?: Context): Promise<ReservationItemDTO[]>;
+    /**
+     * This method deletes a reservation item by its associated line item.
      *
-     *   // do something with the reservation item or return it
-     * }
+     * @param {string | string[]} lineItemId - The line item's ID.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void>} Resolves when the reservation item is deleted.
+     *
+     * @example
+     * await inventoryModuleService.deleteReservationItemByLocationId(
+     *   "cali_123"
+     * )
      */
-    updateReservationItem(reservationItemId: string, input: UpdateReservationItemInput, context?: SharedContext): Promise<ReservationItemDTO>;
+    deleteReservationItemsByLineItem(lineItemId: string | string[], context?: Context): Promise<void>;
     /**
-     * This method is used to delete the reservation items associated with a line item or multiple line items.
+     * This method is used to restore the reservation items associated with a line item or multiple line items that were deleted.
      *
      * @param {string | string[]} lineItemId - The ID(s) of the line item(s).
      * @param {SharedContext} context - A context used to share re9sources, such as transaction manager, between the application and the module.
@@ -606,302 +642,297 @@ export interface IInventoryService extends IModuleService {
      *   initialize as initializeInventoryModule,
      * } from "@medusajs/inventory"
      *
-     * async function deleteReservationItemsByLineItem (
+     * async function restoreReservationItemsByLineItem (
      *   lineItemIds: string[]
      * ) {
      *   const inventoryModule = await initializeInventoryModule({})
      *
-     *   await inventoryModule.deleteReservationItemsByLineItem(
+     *   await inventoryModule.restoreReservationItemsByLineItem(
      *     lineItemIds
      *   )
      * }
      */
-    deleteReservationItemsByLineItem(lineItemId: string | string[], context?: SharedContext): Promise<void>;
+    restoreReservationItemsByLineItem(lineItemId: string | string[], context?: Context): Promise<void>;
     /**
-     * This method is used to delete a reservation item or multiple reservation items by their IDs.
+     * This method deletes reservation items by their IDs.
      *
-     * @param {string | string[]} reservationItemId - The ID(s) of the reservation item(s) to delete.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<void>} Resolves when the reservation item(s) are successfully deleted.
+     * @param {string | string[]} reservationItemId - The reservation items' IDs.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void>} Resolves when the reservation item is deleted.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function deleteReservationItems (
-     *   reservationItemIds: string[]
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   await inventoryModule.deleteReservationItem(
-     *     reservationItemIds
-     *   )
-     * }
+     * await inventoryModuleService.deleteReservationItems(
+     *   "resitem_123"
+     * )
      */
-    deleteReservationItem(reservationItemId: string | string[], context?: SharedContext): Promise<void>;
+    deleteReservationItems(reservationItemId: string | string[], context?: Context): Promise<void>;
     /**
-     * This method is used to delete an inventory item or multiple inventory items. The inventory items are only soft deleted and can be restored using the
-     * {@link restoreInventoryItem} method.
+     * This method soft deletes reservations by their IDs.
      *
-     * @param {string | string[]} inventoryItemId - The ID(s) of the inventory item(s) to delete.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<void>} Resolves when the inventory item(s) are successfully deleted.
+     * @param {string[]} inventoryLevelIds - The reservations' IDs.
+     * @param {SoftDeleteReturn<TReturnableLinkableKeys>} config - An object that is used to specify an entity's related entities that should be soft-deleted when the main entity is soft-deleted.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void | Record<string, string[]>>} An object that includes the IDs of related records that were also soft deleted.
+     * If there are no related records, the promise resolves to `void`.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * await inventoryModuleService.softDeleteReservationItems([
+     *   "ilev_123",
+     * ])
+     */
+    softDeleteReservationItems<TReturnableLinkableKeys extends string = string>(ReservationItemIds: string[], config?: SoftDeleteReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
+    /**
+     * This method restores soft deleted reservations by their IDs.
      *
-     * async function deleteInventoryItem (
-     *   inventoryItems: string[]
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {string[]} ReservationItemIds - The reservations' IDs.
+     * @param {RestoreReturn<TReturnableLinkableKeys>} config - Configurations determining which relations to restore along with each of the reservation. You can pass to its `returnLinkableKeys`
+     * property any of the reservation's relation attribute names, such as `{type relation name}`.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void | Record<string, string[]>>} An object that includes the IDs of related records that were restored.
+     * If there are no related records restored, the promise resolves to `void`.
      *
-     *   await inventoryModule.deleteInventoryItem(
-     *     inventoryItems
-     *   )
-     * }
+     * @example
+     * await inventoryModuleService.restoreReservationItems([
+     *   "ilev_123",
+     * ])
      */
-    deleteInventoryItem(inventoryItemId: string | string[], context?: SharedContext): Promise<void>;
+    restoreReservationItems<TReturnableLinkableKeys extends string = string>(ReservationItemIds: string[], config?: RestoreReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
     /**
-     * This method is used to restore an inventory item or multiple inventory items that were previously deleted using the {@link deleteInventoryItem} method.
+     * This method deletes inventory items by their IDs.
      *
-     * @param {string | string[]} inventoryItemId - The ID(s) of the inventory item(s) to restore.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<void>} Resolves when the inventory item(s) are successfully restored.
+     * @param {string | string[]} inventoryItemId - The inventory item's ID.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void>} Resolves when the inventory items are deleted.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * await inventoryModuleService.deleteInventoryItems("iitem_123")
+     */
+    deleteInventoryItems(inventoryItemId: string | string[], context?: Context): Promise<void>;
+    /**
+     * This method soft deletes inventory items by their IDs.
      *
-     * async function restoreInventoryItem (
-     *   inventoryItems: string[]
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {string[]} inventoryItemIds - The inventory items' IDs.
+     * @param {SoftDeleteReturn<TReturnableLinkableKeys>} config - An object that is used to specify an entity's related entities that should be soft-deleted when the main entity is soft-deleted.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void | Record<string, string[]>>} An object that includes the IDs of related records that were also soft deleted, such as the ID of the associated location levels.
+     * The object's keys are the ID attribute names of the inventory service next entity's relations, such as `location_level_id`, and its value is an array of strings, each being the ID of a record associated
+     * with the inventory item through this relation, such as the IDs of associated location levels.
      *
-     *   await inventoryModule.restoreInventoryItem(
-     *     inventoryItems
-     *   )
-     * }
+     * If there are no related records, the promise resolves to `void`.
+     *
+     * @example
+     * await inventoryModuleService.softDeleteInventoryItems(
+     *   ["iitem_123", "iitem_321"],
+     *   {
+     *     returnLinkableKeys: ["location_level"],
+     *   }
+     * )
      */
-    restoreInventoryItem(inventoryItemId: string | string[], context?: SharedContext): Promise<void>;
+    softDeleteInventoryItems<TReturnableLinkableKeys extends string = string>(inventoryItemIds: string[], config?: SoftDeleteReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
     /**
-     * This method deletes the inventory item level(s) for the ID(s) of associated location(s).
+     * This method restores soft deleted inventory items by their IDs.
      *
-     * @param {string | string[]} locationId - The ID(s) of the associated location(s).
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<void>} Resolves when the inventory item level(s) are successfully restored.
+     * @param {string[]} inventoryItemIds - The inventory items' IDs.
+     * @param {RestoreReturn<TReturnableLinkableKeys>} config - Configurations determining which relations to restore along with each of the inventory items. You can pass to its `returnLinkableKeys`
+     * property any of the inventory item's relation attribute names, such as `location_levels`.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void | Record<string, string[]>>} An object that includes the IDs of related records that were restored, such as the ID of associated location levels.
+     * The object's keys are the ID attribute names of the inventory item entity's relations, such as `location_level_id`,
+     * and its value is an array of strings, each being the ID of the record associated with the inventory item through this relation,
+     * such as the IDs of associated location levels.
+     *
+     * If there are no related records restored, the promise resolves to `void`.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * await inventoryModuleService.restoreInventoryItems(
+     *   ["iitem_123", "iitem_321"],
+     *   {
+     *     returnLinkableKeys: ["location_level"],
+     *   }
+     * )
+     */
+    restoreInventoryItems<TReturnableLinkableKeys extends string = string>(inventoryItemIds: string[], config?: RestoreReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
+    /**
+     * This method soft deletes inventory item's level by the associated location.
      *
-     * async function deleteInventoryItemLevelByLocationId (
-     *   locationIds: string[]
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {string | string[]} locationId - The locations' IDs.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<[object[], Record<string, unknown[]>]>} An array, where the first item is an array includes the soft-deleted inventory levels,
+     * and the second is an object that includes the IDs of related records that were soft-deleted.
      *
-     *   await inventoryModule.deleteInventoryItemLevelByLocationId(
-     *     locationIds
-     *   )
-     * }
+     * @example
+     * await inventoryModuleService.deleteInventoryItemLevelByLocationId(
+     *   "loc_123"
+     * )
      */
-    deleteInventoryItemLevelByLocationId(locationId: string | string[], context?: SharedContext): Promise<void>;
+    deleteInventoryItemLevelByLocationId(locationId: string | string[], context?: Context): Promise<[object[], Record<string, unknown[]>]>;
     /**
-     * This method deletes reservation item(s) by the ID(s) of associated location(s).
+     * This method deletes reservation items by their associated location.
      *
-     * @param {string | string[]} locationId - The ID(s) of the associated location(s).
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<void>} Resolves when the reservation item(s) are successfully restored.
+     * @param {string | string[]} locationId - The location's ID.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void>} Resolves when then reservation items are deleted successfully.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * await inventoryModuleService.deleteReservationItemByLocationId(
+     *   "loc_123"
+     * )
+     */
+    deleteReservationItemByLocationId(locationId: string | string[], context?: Context): Promise<void>;
+    /**
+     * This method deletes an inventory level by its associated inventory item and location.
      *
-     * async function deleteReservationItemByLocationId (
-     *   locationIds: string[]
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {string} inventoryItemId - The inventory item's ID.
+     * @param {string} locationId - The location's ID.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void>} Resolves when the inventory level is deleted successfully.
      *
-     *   await inventoryModule.deleteReservationItemByLocationId(
-     *     locationIds
-     *   )
-     * }
+     * @example
+     * await inventoryModuleService.deleteInventoryLevel(
+     *   "iitem_123",
+     *   "loc_123"
+     * )
      */
-    deleteReservationItemByLocationId(locationId: string | string[], context?: SharedContext): Promise<void>;
+    deleteInventoryLevel(inventoryItemId: string, locationId: string, context?: Context): Promise<void>;
     /**
-     * This method is used to delete an inventory level. The inventory level is identified by the IDs of its associated inventory item and location.
+     * This method deletes inventory levels by their IDs.
      *
-     * @param {string} inventoryItemId - The ID of the associated inventory item.
-     * @param {string} locationId - The ID of the associated location.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<void>} Resolves when the inventory level(s) are successfully restored.
+     * @param {string | string[]} inventoryLevelIds - The inventory levels' IDs.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void>} Resolves when the inventory levels are deleted.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * await inventoryModuleService.deleteInventoryLevels("ilev_123")
+     */
+    deleteInventoryLevels(inventoryLevelIds: string | string[], context?: Context): Promise<void>;
+    /**
+     * This method soft deletes inventory levels by their IDs.
      *
-     * async function deleteInventoryLevel (
-     *   inventoryItemId: string,
-     *   locationId: string
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {string[]} inventoryLevelIds - The inventory levels' IDs.
+     * @param {SoftDeleteReturn<TReturnableLinkableKeys>} config - An object that is used to specify an entity's related entities that should be soft-deleted when the main entity is soft-deleted.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void | Record<string, string[]>>} An object that includes the IDs of related records that were also soft deleted.
+     * If there are no related records, the promise resolves to `void`.
      *
-     *   await inventoryModule.deleteInventoryLevel(
-     *     inventoryItemId,
-     *     locationId
-     *   )
-     * }
+     * @example
+     * await inventoryModuleService.softDeleteInventoryLevels([
+     *   "ilev_123",
+     * ])
      */
-    deleteInventoryLevel(inventoryItemId: string, locationId: string, context?: SharedContext): Promise<void>;
+    softDeleteInventoryLevels<TReturnableLinkableKeys extends string = string>(inventoryLevelIds: string[], config?: SoftDeleteReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
     /**
-     * This method is used to adjust the inventory level's stocked quantity. The inventory level is identified by the IDs of its associated inventory item and location.
+     * This method restores soft deleted inventory levels by their IDs.
      *
-     * @param {string} inventoryItemId - The ID of the associated inventory item.
-     * @param {string} locationId - The ID of the associated location.
-     * @param {number} adjustment - A positive or negative number used to adjust the inventory level's stocked quantity.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<InventoryLevelDTO>} The inventory level's details.
+     * @param {string[]} inventoryLevelIds - The inventory levels' IDs.
+     * @param {RestoreReturn<TReturnableLinkableKeys>} config - Configurations determining which relations to restore along with each of the inventory level. You can pass to its `returnLinkableKeys`
+     * property any of the inventory level's relation attribute names, such as `{type relation name}`.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void | Record<string, string[]>>} An object that includes the IDs of related records that were restored.
+     * If there are no related records restored, the promise resolves to `void`.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
+     * await inventoryModuleService.restoreInventoryLevels([
+     *   "ilev_123",
+     * ])
+     */
+    restoreInventoryLevels<TReturnableLinkableKeys extends string = string>(inventoryLevelIds: string[], config?: RestoreReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
+    /**
+     * This method adjusts the inventory quantity of an item in a location.
      *
-     * async function adjustInventory (
-     *   inventoryItemId: string,
-     *   locationId: string,
-     *   adjustment: number
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
+     * @param {string} inventoryItemId - The inventory item's ID.
+     * @param {string} locationId - The location's ID.
+     * @param {number} adjustment - the adjustment to make to the quantity.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<InventoryLevelDTO>} The updated inventory level.
      *
-     *   const inventoryLevel = await inventoryModule.adjustInventory(
-     *     inventoryItemId,
-     *     locationId,
-     *     adjustment
+     * @example
+     * // add to the inventory quantity
+     * const inventoryLevel1 =
+     *   await inventoryModuleService.adjustInventory(
+     *     "iitem_123",
+     *     "loc_123",
+     *     5
      *   )
      *
-     *   // do something with the inventory level or return it.
-     * }
+     * // subtract from the inventory quantity
+     * const inventoryLevel2 =
+     *   await inventoryModuleService.adjustInventory(
+     *     "iitem_123",
+     *     "loc_123",
+     *     -5
+     *   )
      */
-    adjustInventory(inventoryItemId: string, locationId: string, adjustment: number, context?: SharedContext): Promise<InventoryLevelDTO>;
+    adjustInventory(data: {
+        inventoryItemId: string;
+        locationId: string;
+        adjustment: number;
+    }[], context?: Context): Promise<InventoryLevelDTO[]>;
+    adjustInventory(inventoryItemId: string, locationId: string, adjustment: number, context?: Context): Promise<InventoryLevelDTO>;
     /**
-     * This method is used to confirm whether the specified quantity of an inventory item is available in the specified locations.
+     * This method confirms that a quantity is available of an inventory item in the specified locations.
      *
-     * @param {string} inventoryItemId - The ID of the inventory item to check its availability.
-     * @param {string[]} locationIds - The IDs of the locations to check the quantity availability in.
-     * @param {number} quantity - The quantity to check if available for the inventory item in the specified locations.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<boolean>} Whether the specified quantity is available for the inventory item in the specified locations.
+     * @param {string} inventoryItemId - The inventory item's ID.
+     * @param {string[]} locationIds - The locations' IDs.
+     * @param {number} quantity - The quantity to confirm its availability.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<boolean>} Whether the quantity is available.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function confirmInventory (
-     *   inventoryItemId: string,
-     *   locationIds: string[],
-     *   quantity: number
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   return await inventoryModule.confirmInventory(
-     *     inventoryItemId,
-     *     locationIds,
-     *     quantity
+     * const isAvailable =
+     *   await inventoryModuleService.confirmInventory(
+     *     "iitem_123",
+     *     ["loc_123", "loc_321"],
+     *     10
      *   )
-     * }
      */
-    confirmInventory(inventoryItemId: string, locationIds: string[], quantity: number, context?: SharedContext): Promise<boolean>;
+    confirmInventory(inventoryItemId: string, locationIds: string[], quantity: number, context?: Context): Promise<boolean>;
     /**
-     * This method is used to retrieve the available quantity of an inventory item within the specified locations.
+     * This method retrieves the available quantity of an inventory item in the specified locations.
      *
-     * @param {string} inventoryItemId - The ID of the inventory item to retrieve its quantity.
-     * @param {string[]} locationIds - The IDs of the locations to retrieve the available quantity from.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<number>} The available quantity of the inventory item in the specified locations.
+     * @param {string} inventoryItemId - The inventory item's ID.
+     * @param {string[]} locationIds - The locations' IDs.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<number>} The available quantity of the item.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveAvailableQuantity (
-     *   inventoryItemId: string,
-     *   locationIds: string[],
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const quantity = await inventoryModule.retrieveAvailableQuantity(
-     *     inventoryItemId,
-     *     locationIds,
+     * const availableQuantity =
+     *   await inventoryModuleService.retrieveAvailableQuantity(
+     *     "iitem_123",
+     *     ["loc_123", "loc_321"]
      *   )
-     *
-     *   // do something with the quantity or return it
-     * }
      */
-    retrieveAvailableQuantity(inventoryItemId: string, locationIds: string[], context?: SharedContext): Promise<number>;
+    retrieveAvailableQuantity(inventoryItemId: string, locationIds: string[], context?: Context): Promise<number>;
     /**
-     * This method is used to retrieve the stocked quantity of an inventory item within the specified locations.
+     * This method retrieves the stocked quantity of an inventory item in the specified location.
      *
-     * @param {string} inventoryItemId - The ID of the inventory item to retrieve its stocked quantity.
-     * @param {string[]} locationIds - The IDs of the locations to retrieve the stocked quantity from.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<number>} The stocked quantity of the inventory item in the specified locations.
+     * @param {string} inventoryItemId - The inventory item's ID.
+     * @param {string[]} locationIds - The locations' IDs.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<number>} The stocked quantity of the item.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveStockedQuantity (
-     *   inventoryItemId: string,
-     *   locationIds: string[],
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const quantity = await inventoryModule.retrieveStockedQuantity(
-     *     inventoryItemId,
-     *     locationIds,
+     * const stockedQuantity =
+     *   await inventoryModuleService.retrieveStockedQuantity(
+     *     "iitem_123",
+     *     ["loc_123", "loc_321"]
      *   )
-     *
-     *   // do something with the quantity or return it
-     * }
      */
-    retrieveStockedQuantity(inventoryItemId: string, locationIds: string[], context?: SharedContext): Promise<number>;
+    retrieveStockedQuantity(inventoryItemId: string, locationIds: string[], context?: Context): Promise<number>;
     /**
-     * This method is used to retrieve the reserved quantity of an inventory item within the specified locations.
+     * This method retrieves the reserved quantity of an inventory item in the specified location.
      *
-     * @param {string} inventoryItemId - The ID of the inventory item to retrieve its reserved quantity.
-     * @param {string[]} locationIds - The IDs of the locations to retrieve the reserved quantity from.
-     * @param {SharedContext} context - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<number>} The reserved quantity of the inventory item in the specified locations.
+     * @param {string} inventoryItemId - The inventory item's ID.
+     * @param {string[]} locationIds - The locations' IDs.
+     * @param {Context} context - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<number>} The reserved quantity of the item.
      *
      * @example
-     * import {
-     *   initialize as initializeInventoryModule,
-     * } from "@medusajs/inventory"
-     *
-     * async function retrieveReservedQuantity (
-     *   inventoryItemId: string,
-     *   locationIds: string[],
-     * ) {
-     *   const inventoryModule = await initializeInventoryModule({})
-     *
-     *   const quantity = await inventoryModule.retrieveReservedQuantity(
-     *     inventoryItemId,
-     *     locationIds,
+     * const reservedQuantity =
+     *   await inventoryModuleService.retrieveReservedQuantity(
+     *     "iitem_123",
+     *     ["loc_123", "loc_321"]
      *   )
-     *
-     *   // do something with the quantity or return it
-     * }
      */
-    retrieveReservedQuantity(inventoryItemId: string, locationIds: string[], context?: SharedContext): Promise<number>;
+    retrieveReservedQuantity(inventoryItemId: string, locationIds: string[], context?: Context): Promise<number>;
 }
 //# sourceMappingURL=service.d.ts.map