@medusajs/types 1.12.0-snapshot-20240328221015 → 1.12.0-snapshot-20240329181714

package/dist/product/service.d.ts

@@ -255,6 +255,233 @@ export interface IProductModuleService extends IModuleService {
      * ```
      */
     listAndCount(filters?: FilterableProductProps, config?: FindConfig<ProductDTO>, sharedContext?: Context): Promise<[ProductDTO[], number]>;
+    /**
+     * This method is used to create a list of products.
+     *
+     * @param {CreateProductDTO[]} data - The products to be created.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ProductDTO[]>} The list of created products.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function createProduct (title: string) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const products = await productModule.create([
+     *     {
+     *       title
+     *     }
+     *   ])
+     *
+     *   // do something with the products or return them
+     * }
+     */
+    create(data: CreateProductDTO[], sharedContext?: Context): Promise<ProductDTO[]>;
+    /**
+     * This method is used to create a product.
+     *
+     * @param {CreateProductDTO} data - The product to be created.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ProductDTO>} The created product.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function createProduct (title: string) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const product = await productModule.create(
+     *     {
+     *       title
+     *     }
+     *   )
+     *
+     *   // do something with the product or return it
+     * }
+     */
+    create(data: CreateProductDTO, sharedContext?: Context): Promise<ProductDTO>;
+    /**
+     * This method updates existing products, or creates new ones if they don't exist.
+     *
+     * @param {CreateProductDTO[]} data - The attributes to update or create for each product.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ProductDTO[]>} The updated and created products.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function upserProduct (title: string) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const createdProducts = await productModule.upsert([
+     *     {
+     *       title
+     *     }
+     *   ])
+     *
+     *   // do something with the products or return them
+     * }
+     */
+    upsert(data: UpsertProductDTO[], sharedContext?: Context): Promise<ProductDTO[]>;
+    /**
+     * This method updates the product if it exists, or creates a new ones if it doesn't.
+     *
+     * @param {CreateProductDTO} data - The attributes to update or create for the new product.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ProductDTO>} The updated or created product.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function upserProduct (title: string) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const createdProduct = await productModule.upsert(
+     *     {
+     *       title
+     *     }
+     *   )
+     *
+     *   // do something with the product or return it
+     * }
+     */
+    upsert(data: UpsertProductDTO[], sharedContext?: Context): Promise<ProductDTO[]>;
+    /**
+     * This method is used to update a product.
+     *
+     * @param {string} id - The ID of the product to be updated.
+     * @param {UpdateProductDTO} data - The attributes of the product to be updated
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ProductDTO>} The updated product.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function updateProduct (id: string, title: string) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const product = await productModule.update(id, {
+     *       title
+     *     }
+     *   )
+     *
+     *   // do something with the product or return it
+     * }
+     */
+    update(id: string, data: UpdateProductDTO, sharedContext?: Context): Promise<ProductDTO>;
+    /**
+     * This method is used to update a list of products determined by the selector filters.
+     *
+     * @param {FilterableProductProps} selector - The filters that will determine which products will be updated.
+     * @param {UpdateProductDTO} data - The attributes to be updated on the selected products
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ProductDTO[]>} The updated products.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function updateProduct (id: string, title: string) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const products = await productModule.update({id}, {
+     *       title
+     *     }
+     *   )
+     *
+     *   // do something with the products or return them
+     * }
+     */
+    update(selector: FilterableProductProps, data: UpdateProductDTO, sharedContext?: Context): Promise<ProductDTO[]>;
+    /**
+     * This method is used to delete products. Unlike the {@link softDelete} method, this method will completely remove the products and they can no longer be accessed or retrieved.
+     *
+     * @param {string[]} productIds - The IDs of the products to be deleted.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<void>} Resolves when the products are successfully deleted.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function deleteProducts (ids: string[]) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   await productModule.delete(ids)
+     * }
+     */
+    delete(productIds: string[], sharedContext?: Context): Promise<void>;
+    /**
+     * This method is used to delete products. Unlike the {@link delete} method, this method won't completely remove the product. It can still be accessed or retrieved using methods like {@link retrieve} if you pass the `withDeleted` property to the `config` object parameter.
+     *
+     * The soft-deleted products can be restored using the {@link restore} method.
+     *
+     * @param {string[]} productIds - The IDs of the products to soft-delete.
+     * @param {SoftDeleteReturn<TReturnableLinkableKeys>} config -
+     * Configurations determining which relations to soft delete along with the each of the products. You can pass to its `returnLinkableKeys`
+     * property any of the product's relation attribute names, such as `variant_id`.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<Record<string, string[]> | void>}
+     * An object that includes the IDs of related records that were also soft deleted, such as the ID of associated product variants. The object's keys are the ID attribute names of the product entity's relations, such as `variant_id`, and its value is an array of strings, each being the ID of a record associated with the product through this relation, such as the IDs of associated product variants.
+     *
+     * If there are no related records, the promise resolved to `void`.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function deleteProducts (ids: string[]) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const cascadedEntities = await productModule.softDelete(ids)
+     *
+     *   // do something with the returned cascaded entity IDs or return them
+     * }
+     */
+    softDelete<TReturnableLinkableKeys extends string = string>(productIds: string[], config?: SoftDeleteReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
+    /**
+     * This method is used to restore products which were deleted using the {@link softDelete} method.
+     *
+     * @param {string[]} productIds - The IDs of the products to restore.
+     * @param {RestoreReturn<TReturnableLinkableKeys>} config -
+     * Configurations determining which relations to restore along with each of the products. You can pass to its `returnLinkableKeys`
+     * property any of the product's relation attribute names, such as `variant_id`.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<Record<string, string[]> | void>}
+     * An object that includes the IDs of related records that were restored, such as the ID of associated product variants. The object's keys are the ID attribute names of the product entity's relations, such as `variant_id`, and its value is an array of strings, each being the ID of the record associated with the product through this relation, such as the IDs of associated product variants.
+     *
+     * If there are no related records that were restored, the promise resolved to `void`.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function restoreProducts (ids: string[]) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const cascadedEntities = await productModule.restore(ids, {
+     *     returnLinkableKeys: ["variant_id"]
+     *   })
+     *
+     *   // do something with the returned cascaded entity IDs or return them
+     * }
+     */
+    restore<TReturnableLinkableKeys extends string = string>(productIds: string[], config?: RestoreReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
     /**
      * This method is used to retrieve a tag by its ID.
      *
@@ -1517,35 +1744,136 @@ export interface IProductModuleService extends IModuleService {
      */
     listVariants(filters?: FilterableProductVariantProps, config?: FindConfig<ProductVariantDTO>, sharedContext?: Context): Promise<ProductVariantDTO[]>;
     /**
-     * This method is used to create product variants.
+     * This method is used to retrieve a paginated list of product variants along with the total count of available product variants satisfying the provided filters.
      *
-     * @param {CreateProductVariantDTO[]} data - The product variants to be created.
+     * @param {FilterableProductVariantProps} filters - The filters applied on the retrieved product variants.
+     * @param {FindConfig<ProductVariantDTO>} config -
+     * The configurations determining how the product variants are retrieved. Its properties, such as `select` or `relations`, accept the
+     * attributes or relations associated with a product variant.
      * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ProductVariantDTO[]>} The list of created product variants.
+     * @returns {Promise<[ProductVariantDTO[], number]>} The list of product variants along with their total count.
      *
      * @example
+     * To retrieve a list of product variants using their IDs:
+     *
+     * ```ts
      * import {
      *   initialize as initializeProductModule,
      * } from "@medusajs/product"
      *
-     * async function createVariants (title: string) {
+     * async function retrieveProductVariants (ids: string[]) {
      *   const productModule = await initializeProductModule()
      *
-     *   const variants = await productModule.createVariants([
-     *     {
-     *       title
-     *     }
-     *   ])
+     *   const [variants, count] = await productModule.listAndCountVariants({
+     *     id: ids
+     *   })
      *
      *   // do something with the product variants or return them
      * }
+     * ```
      *
-     */
-    createVariants(data: CreateProductVariantDTO[], sharedContext?: Context): Promise<ProductVariantDTO[]>;
-    /**
-     * This method is used to create a product variant.
+     * To specify relations that should be retrieved within the product variants:
      *
-     * @param {CreateProductVariantDTO} data - The product variant to be created.
+     * ```ts
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function retrieveProductVariants (ids: string[]) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const [variants, count] = await productModule.listAndCountVariants({
+     *     id: ids
+     *   }, {
+     *     relations: ["options"]
+     *   })
+     *
+     *   // do something with the product variants 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 initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function retrieveProductVariants (ids: string[], skip: number, take: number) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const [variants, count] = await productModule.listAndCountVariants({
+     *     id: ids
+     *   }, {
+     *     relations: ["options"],
+     *     skip,
+     *     take
+     *   })
+     *
+     *   // do something with the product variants 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 initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function retrieveProductVariants (ids: string[], sku: string, skip: number, take: number) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const [variants, count] = await productModule.listAndCountVariants({
+     *     $and: [
+     *       {
+     *         id: ids
+     *       },
+     *       {
+     *         sku
+     *       }
+     *     ]
+     *   }, {
+     *     relations: ["options"],
+     *     skip,
+     *     take
+     *   })
+     *
+     *   // do something with the product variants or return them
+     * }
+     * ```
+     */
+    listAndCountVariants(filters?: FilterableProductVariantProps, config?: FindConfig<ProductVariantDTO>, sharedContext?: Context): Promise<[ProductVariantDTO[], number]>;
+    /**
+     * This method is used to create product variants.
+     *
+     * @param {CreateProductVariantDTO[]} data - The product variants to be created.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ProductVariantDTO[]>} The list of created product variants.
+     *
+     * @example
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function createVariants (title: string) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const variants = await productModule.createVariants([
+     *     {
+     *       title
+     *     }
+     *   ])
+     *
+     *   // do something with the product variants or return them
+     * }
+     *
+     */
+    createVariants(data: CreateProductVariantDTO[], sharedContext?: Context): Promise<ProductVariantDTO[]>;
+    /**
+     * This method is used to create a product variant.
+     *
+     * @param {CreateProductVariantDTO} data - The product variant to be created.
      * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
      * @returns {Promise<ProductVariantDTO>} The created product variant.
      *
@@ -1687,107 +2015,6 @@ export interface IProductModuleService extends IModuleService {
      * }
      */
     deleteVariants(productVariantIds: string[], sharedContext?: Context): Promise<void>;
-    /**
-     * This method is used to retrieve a paginated list of product variants along with the total count of available product variants satisfying the provided filters.
-     *
-     * @param {FilterableProductVariantProps} filters - The filters applied on the retrieved product variants.
-     * @param {FindConfig<ProductVariantDTO>} config -
-     * The configurations determining how the product variants are retrieved. Its properties, such as `select` or `relations`, accept the
-     * attributes or relations associated with a product variant.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<[ProductVariantDTO[], number]>} The list of product variants along with their total count.
-     *
-     * @example
-     * To retrieve a list of product variants using their IDs:
-     *
-     * ```ts
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function retrieveProductVariants (ids: string[]) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const [variants, count] = await productModule.listAndCountVariants({
-     *     id: ids
-     *   })
-     *
-     *   // do something with the product variants or return them
-     * }
-     * ```
-     *
-     * To specify relations that should be retrieved within the product variants:
-     *
-     * ```ts
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function retrieveProductVariants (ids: string[]) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const [variants, count] = await productModule.listAndCountVariants({
-     *     id: ids
-     *   }, {
-     *     relations: ["options"]
-     *   })
-     *
-     *   // do something with the product variants 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 initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function retrieveProductVariants (ids: string[], skip: number, take: number) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const [variants, count] = await productModule.listAndCountVariants({
-     *     id: ids
-     *   }, {
-     *     relations: ["options"],
-     *     skip,
-     *     take
-     *   })
-     *
-     *   // do something with the product variants 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 initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function retrieveProductVariants (ids: string[], sku: string, skip: number, take: number) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const [variants, count] = await productModule.listAndCountVariants({
-     *     $and: [
-     *       {
-     *         id: ids
-     *       },
-     *       {
-     *         sku
-     *       }
-     *     ]
-     *   }, {
-     *     relations: ["options"],
-     *     skip,
-     *     take
-     *   })
-     *
-     *   // do something with the product variants or return them
-     * }
-     * ```
-     */
-    listAndCountVariants(filters?: FilterableProductVariantProps, config?: FindConfig<ProductVariantDTO>, sharedContext?: Context): Promise<[ProductVariantDTO[], number]>;
     /**
      * This method is used to delete variants. Unlike the {@link delete} method, this method won't completely remove the variant. It can still be accessed or retrieved using methods like {@link retrieve} if you pass the `withDeleted` property to the `config` object parameter.
      *
@@ -2267,53 +2494,111 @@ export interface IProductModuleService extends IModuleService {
      */
     deleteCollections(productCollectionIds: string[], sharedContext?: Context): Promise<void>;
     /**
-     * This method is used to retrieve a product category by its ID.
+     * This method is used to delete product collections. Unlike the {@link deleteCollections} method, this method won't completely remove the collection. It can still be accessed or retrieved using methods like {@link retrieveCollections} if you pass the `withDeleted` property to the `config` object parameter.
      *
-     * @param {string} productCategoryId - The ID of the product category to retrieve.
-     * @param {FindConfig<ProductCategoryDTO>} config -
-     * The configurations determining how the product category is retrieved. Its properties, such as `select` or `relations`, accept the
-     * attributes or relations associated with a product category.
+     * The soft-deleted collections can be restored using the {@link restoreCollections} method.
+     *
+     * @param {string[]} collectionIds - The IDs of the collections to soft-delete.
+     * @param {SoftDeleteReturn<TReturnableLinkableKeys>} config -
+     * Configurations determining which relations to soft delete along with the each of the collections. You can pass to its `returnLinkableKeys`
+     * property any of the collection's relation attribute names.
      * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ProductCategoryDTO>} The retrieved product category.
+     * @returns {Promise<Record<string, string[]> | void>}
+     * An object that includes the IDs of related records that were also soft deleted. The object's keys are the ID attribute names of the collection entity's relations.
      *
-     * @example
-     * A simple example that retrieves a product category by its ID:
+     * If there are no related records, the promise resolved to `void`.
      *
-     * ```ts
+     * @example
      * import {
      *   initialize as initializeProductModule,
      * } from "@medusajs/product"
      *
-     * async function retrieveCategory (id: string) {
+     * async function deleteCollections (ids: string[]) {
      *   const productModule = await initializeProductModule()
      *
-     *   const category = await productModule.retrieveCategory(id)
+     *   const cascadedEntities = await productModule.softDeleteCollections(ids)
      *
-     *   // do something with the product category or return it
+     *   // do something with the returned cascaded entity IDs or return them
      * }
-     * ```
+     */
+    softDeleteCollections<TReturnableLinkableKeys extends string = string>(collectionIds: string[], config?: SoftDeleteReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
+    /**
+     * This method is used to restore collections which were deleted using the {@link softDelete} method.
      *
-     * To specify relations that should be retrieved:
+     * @param {string[]} collectionIds - The IDs of the collections to restore.
+     * @param {RestoreReturn<TReturnableLinkableKeys>} config -
+     * Configurations determining which relations to restore along with each of the collections. You can pass to its `returnLinkableKeys`
+     * property any of the collection's relation attribute names.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<Record<string, string[]> | void>}
+     * An object that includes the IDs of related records that were restored. The object's keys are the ID attribute names of the product entity's relations.
      *
-     * ```ts
+     * If there are no related records that were restored, the promise resolved to `void`.
+     *
+     * @example
      * import {
      *   initialize as initializeProductModule,
      * } from "@medusajs/product"
      *
-     * async function retrieveCategory (id: string) {
+     * async function restoreCollections (ids: string[]) {
      *   const productModule = await initializeProductModule()
      *
-     *   const category = await productModule.retrieveCategory(id, {
-     *     relations: ["parent_category"]
+     *   const cascadedEntities = await productModule.restoreCollections(ids, {
+     *     returnLinkableKeys: []
      *   })
      *
-     *   // do something with the product category or return it
+     *   // do something with the returned cascaded entity IDs or return them
      * }
-     * ```
      */
-    retrieveCategory(productCategoryId: string, config?: FindConfig<ProductCategoryDTO>, sharedContext?: Context): Promise<ProductCategoryDTO>;
+    restoreCollections<TReturnableLinkableKeys extends string = string>(collectionIds: string[], config?: RestoreReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
     /**
-     * This method is used to retrieve a paginated list of product categories based on optional filters and configuration.
+     * This method is used to retrieve a product category by its ID.
+     *
+     * @param {string} productCategoryId - The ID of the product category to retrieve.
+     * @param {FindConfig<ProductCategoryDTO>} config -
+     * The configurations determining how the product category is retrieved. Its properties, such as `select` or `relations`, accept the
+     * attributes or relations associated with a product category.
+     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
+     * @returns {Promise<ProductCategoryDTO>} The retrieved product category.
+     *
+     * @example
+     * A simple example that retrieves a product category by its ID:
+     *
+     * ```ts
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function retrieveCategory (id: string) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const category = await productModule.retrieveCategory(id)
+     *
+     *   // do something with the product category or return it
+     * }
+     * ```
+     *
+     * To specify relations that should be retrieved:
+     *
+     * ```ts
+     * import {
+     *   initialize as initializeProductModule,
+     * } from "@medusajs/product"
+     *
+     * async function retrieveCategory (id: string) {
+     *   const productModule = await initializeProductModule()
+     *
+     *   const category = await productModule.retrieveCategory(id, {
+     *     relations: ["parent_category"]
+     *   })
+     *
+     *   // do something with the product category or return it
+     * }
+     * ```
+     */
+    retrieveCategory(productCategoryId: string, config?: FindConfig<ProductCategoryDTO>, sharedContext?: Context): Promise<ProductCategoryDTO>;
+    /**
+     * This method is used to retrieve a paginated list of product categories based on optional filters and configuration.
      *
      * @param {FilterableProductCategoryProps} filters - The filters to be applied on the retrieved product categories.
      * @param {FindConfig<ProductCategoryDTO>} config -
@@ -2582,317 +2867,5 @@ export interface IProductModuleService extends IModuleService {
      * }
      */
     deleteCategory(categoryId: string, sharedContext?: Context): Promise<void>;
-    /**
-     * This method is used to create a list of products.
-     *
-     * @param {CreateProductDTO[]} data - The products to be created.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ProductDTO[]>} The list of created products.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function createProduct (title: string) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const products = await productModule.create([
-     *     {
-     *       title
-     *     }
-     *   ])
-     *
-     *   // do something with the products or return them
-     * }
-     */
-    create(data: CreateProductDTO[], sharedContext?: Context): Promise<ProductDTO[]>;
-    /**
-     * This method is used to create a product.
-     *
-     * @param {CreateProductDTO} data - The product to be created.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ProductDTO>} The created product.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function createProduct (title: string) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const product = await productModule.create(
-     *     {
-     *       title
-     *     }
-     *   )
-     *
-     *   // do something with the product or return it
-     * }
-     */
-    create(data: CreateProductDTO, sharedContext?: Context): Promise<ProductDTO>;
-    /**
-     * This method updates existing products, or creates new ones if they don't exist.
-     *
-     * @param {CreateProductDTO[]} data - The attributes to update or create for each product.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ProductDTO[]>} The updated and created products.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function upserProduct (title: string) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const createdProducts = await productModule.upsert([
-     *     {
-     *       title
-     *     }
-     *   ])
-     *
-     *   // do something with the products or return them
-     * }
-     */
-    upsert(data: UpsertProductDTO[], sharedContext?: Context): Promise<ProductDTO[]>;
-    /**
-     * This method updates the product if it exists, or creates a new ones if it doesn't.
-     *
-     * @param {CreateProductDTO} data - The attributes to update or create for the new product.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ProductDTO>} The updated or created product.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function upserProduct (title: string) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const createdProduct = await productModule.upsert(
-     *     {
-     *       title
-     *     }
-     *   )
-     *
-     *   // do something with the product or return it
-     * }
-     */
-    upsert(data: UpsertProductDTO[], sharedContext?: Context): Promise<ProductDTO[]>;
-    /**
-     * This method is used to update a product.
-     *
-     * @param {string} id - The ID of the product to be updated.
-     * @param {UpdateProductDTO} data - The attributes of the product to be updated
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ProductDTO>} The updated product.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function updateProduct (id: string, title: string) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const product = await productModule.update(id, {
-     *       title
-     *     }
-     *   )
-     *
-     *   // do something with the product or return it
-     * }
-     */
-    update(id: string, data: UpdateProductDTO, sharedContext?: Context): Promise<ProductDTO>;
-    /**
-     * This method is used to update a list of products determined by the selector filters.
-     *
-     * @param {FilterableProductProps} selector - The filters that will determine which products will be updated.
-     * @param {UpdateProductDTO} data - The attributes to be updated on the selected products
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<ProductDTO[]>} The updated products.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function updateProduct (id: string, title: string) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const products = await productModule.update({id}, {
-     *       title
-     *     }
-     *   )
-     *
-     *   // do something with the products or return them
-     * }
-     */
-    update(selector: FilterableProductProps, data: UpdateProductDTO, sharedContext?: Context): Promise<ProductDTO[]>;
-    /**
-     * This method is used to delete products. Unlike the {@link softDelete} method, this method will completely remove the products and they can no longer be accessed or retrieved.
-     *
-     * @param {string[]} productIds - The IDs of the products to be deleted.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<void>} Resolves when the products are successfully deleted.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function deleteProducts (ids: string[]) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   await productModule.delete(ids)
-     * }
-     */
-    delete(productIds: string[], sharedContext?: Context): Promise<void>;
-    /**
-     * This method is used to delete products. Unlike the {@link delete} method, this method won't completely remove the product. It can still be accessed or retrieved using methods like {@link retrieve} if you pass the `withDeleted` property to the `config` object parameter.
-     *
-     * The soft-deleted products can be restored using the {@link restore} method.
-     *
-     * @param {string[]} productIds - The IDs of the products to soft-delete.
-     * @param {SoftDeleteReturn<TReturnableLinkableKeys>} config -
-     * Configurations determining which relations to soft delete along with the each of the products. You can pass to its `returnLinkableKeys`
-     * property any of the product's relation attribute names, such as `variant_id`.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<Record<string, string[]> | void>}
-     * An object that includes the IDs of related records that were also soft deleted, such as the ID of associated product variants. The object's keys are the ID attribute names of the product entity's relations, such as `variant_id`, and its value is an array of strings, each being the ID of a record associated with the product through this relation, such as the IDs of associated product variants.
-     *
-     * If there are no related records, the promise resolved to `void`.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function deleteProducts (ids: string[]) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const cascadedEntities = await productModule.softDelete(ids)
-     *
-     *   // do something with the returned cascaded entity IDs or return them
-     * }
-     */
-    softDelete<TReturnableLinkableKeys extends string = string>(productIds: string[], config?: SoftDeleteReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
-    /**
-     * This method is used to restore products which were deleted using the {@link softDelete} method.
-     *
-     * @param {string[]} productIds - The IDs of the products to restore.
-     * @param {RestoreReturn<TReturnableLinkableKeys>} config -
-     * Configurations determining which relations to restore along with each of the products. You can pass to its `returnLinkableKeys`
-     * property any of the product's relation attribute names, such as `variant_id`.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<Record<string, string[]> | void>}
-     * An object that includes the IDs of related records that were restored, such as the ID of associated product variants. The object's keys are the ID attribute names of the product entity's relations, such as `variant_id`, and its value is an array of strings, each being the ID of the record associated with the product through this relation, such as the IDs of associated product variants.
-     *
-     * If there are no related records that were restored, the promise resolved to `void`.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function restoreProducts (ids: string[]) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const cascadedEntities = await productModule.restore(ids, {
-     *     returnLinkableKeys: ["variant_id"]
-     *   })
-     *
-     *   // do something with the returned cascaded entity IDs or return them
-     * }
-     */
-    restore<TReturnableLinkableKeys extends string = string>(productIds: string[], config?: RestoreReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
-    /**
-     * This method is used to delete product collections. Unlike the {@link deleteCollections} method, this method won't completely remove the collection. It can still be accessed or retrieved using methods like {@link retrieveCollections} if you pass the `withDeleted` property to the `config` object parameter.
-     *
-     * The soft-deleted collections can be restored using the {@link restoreCollections} method.
-     *
-     * @param {string[]} collectionIds - The IDs of the collections to soft-delete.
-     * @param {SoftDeleteReturn<TReturnableLinkableKeys>} config -
-     * Configurations determining which relations to soft delete along with the each of the collections. You can pass to its `returnLinkableKeys`
-     * property any of the collection's relation attribute names.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<Record<string, string[]> | void>}
-     * An object that includes the IDs of related records that were also soft deleted. The object's keys are the ID attribute names of the collection entity's relations.
-     *
-     * If there are no related records, the promise resolved to `void`.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function deleteCollections (ids: string[]) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const cascadedEntities = await productModule.softDeleteCollections(ids)
-     *
-     *   // do something with the returned cascaded entity IDs or return them
-     * }
-     */
-    softDeleteCollections<TReturnableLinkableKeys extends string = string>(collectionIds: string[], config?: SoftDeleteReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
-    /**
-     * This method is used to restore collections which were deleted using the {@link softDelete} method.
-     *
-     * @param {string[]} collectionIds - The IDs of the collections to restore.
-     * @param {RestoreReturn<TReturnableLinkableKeys>} config -
-     * Configurations determining which relations to restore along with each of the collections. You can pass to its `returnLinkableKeys`
-     * property any of the collection's relation attribute names.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<Record<string, string[]> | void>}
-     * An object that includes the IDs of related records that were restored. The object's keys are the ID attribute names of the product entity's relations.
-     *
-     * If there are no related records that were restored, the promise resolved to `void`.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function restoreCollections (ids: string[]) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   const cascadedEntities = await productModule.restoreCollections(ids, {
-     *     returnLinkableKeys: []
-     *   })
-     *
-     *   // do something with the returned cascaded entity IDs or return them
-     * }
-     */
-    restoreCollections<TReturnableLinkableKeys extends string = string>(collectionIds: string[], config?: RestoreReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
-    /**
-     * This method is used to restore product varaints that were soft deleted. Product variants are soft deleted when they're not
-     * provided in a product's details passed to the {@link update} method.
-     *
-     * @param {string[]} variantIds - The IDs of the variants to restore.
-     * @param {RestoreReturn<TReturnableLinkableKeys>} config -
-     * Configurations determining which relations to restore along with each of the product variants. You can pass to its `returnLinkableKeys`
-     * property any of the product variant's relation attribute names.
-     * @param {Context} sharedContext - A context used to share resources, such as transaction manager, between the application and the module.
-     * @returns {Promise<Record<string, string[]> | void>}
-     * An object that includes the IDs of related records that were restored. The object's keys are the ID attribute names of the product variant entity's relations
-     * and its value is an array of strings, each being the ID of the record associated with the product variant through this relation.
-     *
-     * If there are no related records that were restored, the promise resolved to `void`.
-     *
-     * @example
-     * import {
-     *   initialize as initializeProductModule,
-     * } from "@medusajs/product"
-     *
-     * async function restoreProductVariants (ids: string[]) {
-     *   const productModule = await initializeProductModule()
-     *
-     *   await productModule.restoreVariants(ids)
-     * }
-     */
-    restoreVariants<TReturnableLinkableKeys extends string = string>(variantIds: string[], config?: RestoreReturn<TReturnableLinkableKeys>, sharedContext?: Context): Promise<Record<string, string[]> | void>;
 }
 //# sourceMappingURL=service.d.ts.map