Type alias ProductsModule

Type declaration

• assignments: { addProxyAssignment: ((productId: string, params: { proxyId: string; vectors: ProductConfiguration[] }, userId?: string) => Promise<string>); removeAssignment: ((productId: string, params: { vectors: ProductConfiguration[] }, userId?: string) => Promise<number>) }

  • addProxyAssignment: ((productId: string, params: { proxyId: string; vectors: ProductConfiguration[] }, userId?: string) => Promise<string>)

    • • (productId: string, params: { proxyId: string; vectors: ProductConfiguration[] }, userId?: string): Promise<string>

      • Parameters

        • productId: string

        • params: { proxyId: string; vectors: ProductConfiguration[] }

          • proxyId: string

          • vectors: ProductConfiguration[]

        • Optional userId: string

        Returns Promise<string>

  • removeAssignment: ((productId: string, params: { vectors: ProductConfiguration[] }, userId?: string) => Promise<number>)

    • • (productId: string, params: { vectors: ProductConfiguration[] }, userId?: string): Promise<number>

      • Parameters

        • productId: string

        • params: { vectors: ProductConfiguration[] }

          • vectors: ProductConfiguration[]

        • Optional userId: string

        Returns Promise<number>

• bundleItems: { addBundleItem: ((productId: string, doc: ProductBundleItem, userId?: string) => Promise<string>); removeBundleItem: ((productId: string, index: number, userId?: string) => Promise<ProductBundleItem>) }

  • addBundleItem: ((productId: string, doc: ProductBundleItem, userId?: string) => Promise<string>)

    • • (productId: string, doc: ProductBundleItem, userId?: string): Promise<string>

      • Parameters

        • productId: string

        • doc: ProductBundleItem

        • Optional userId: string

        Returns Promise<string>

  • removeBundleItem: ((productId: string, index: number, userId?: string) => Promise<ProductBundleItem>)

    • • (productId: string, index: number, userId?: string): Promise<ProductBundleItem>

      • Parameters

        • productId: string

        • index: number

        • Optional userId: string

        Returns Promise<ProductBundleItem>

• calculate: ((pricingContext: ProductPricingContext & { item: OrderPosition }, requestContext: Context) => Promise<ProductPricingCalculation[]>)

  • • (pricingContext: ProductPricingContext & { item: OrderPosition }, requestContext: Context): Promise<ProductPricingCalculation[]>

    • Parameters

      • pricingContext: ProductPricingContext & { item: OrderPosition }

      • requestContext: Context

      Returns Promise<ProductPricingCalculation[]>

• count: ((query: ProductQuery) => Promise<number>)

  • • (query: ProductQuery): Promise<number>

    • Parameters

      • query: ProductQuery

      Returns Promise<number>

• create: ((doc: Product & { locale: string; title: string }, userId?: string, options?: { autopublish?: boolean }) => Promise<Product>)

  • • (doc: Product & { locale: string; title: string }, userId?: string, options?: { autopublish?: boolean }): Promise<Product>

    • Parameters

      • doc: Product & { locale: string; title: string }

      • Optional userId: string

      • Optional options: { autopublish?: boolean }

        • Optional autopublish?: boolean

      Returns Promise<Product>

• delete: ((productId: string, userId?: string) => Promise<number>)

  • • (productId: string, userId?: string): Promise<number>

    • Parameters

      • productId: string

      • Optional userId: string

      Returns Promise<number>

• deleteProductsPermanently: ((params: { excludedProductIds?: _ID[]; productId?: string }) => Promise<number>)

  • • (params: { excludedProductIds?: _ID[]; productId?: string }): Promise<number>

    • Parameters

      • params: { excludedProductIds?: _ID[]; productId?: string }

        • Optional excludedProductIds?: _ID[]

        • Optional productId?: string

      Returns Promise<number>

• findProduct: ((params: { productId?: string; sku?: string; slug?: string }) => Promise<Product>)

  • • (params: { productId?: string; sku?: string; slug?: string }): Promise<Product>

    • Parameters

      • params: { productId?: string; sku?: string; slug?: string }

        • Optional productId?: string

        • Optional sku?: string

        • Optional slug?: string

      Returns Promise<Product>

• findProducts: ((params: ProductQuery & { limit?: number; offset?: number; sort?: SortOption[] }, options?: FindOptions) => Promise<Product[]>)

  • • (params: ProductQuery & { limit?: number; offset?: number; sort?: SortOption[] }, options?: FindOptions): Promise<Product[]>

    • Parameters

      • params: ProductQuery & { limit?: number; offset?: number; sort?: SortOption[] }

      • Optional options: FindOptions

      Returns Promise<Product[]>

• interface: ((productDiscount: ProductDiscount) => IDiscountAdapter)

  • • (productDiscount: ProductDiscount): IDiscountAdapter

    • Parameters

      • productDiscount: ProductDiscount

      Returns IDiscountAdapter

• isActive: ((product: Product) => boolean)

  • • (product: Product): boolean

    • Parameters

      • product: Product

      Returns boolean

• isDraft: ((product: Product) => boolean)

  • • (product: Product): boolean

    • Parameters

      • product: Product

      Returns boolean

• media: ProductMediaModule

• normalizedStatus: ((product: Product) => ProductStatus)

  • • (product: Product): ProductStatus

    • Parameters

      • product: Product

      Returns ProductStatus

• prices: { catalogPriceRange: ((product: Product, params: { country: string; currency: string; includeInactive?: boolean; quantity?: number; vectors: ProductConfiguration[] }) => Promise<ProductPriceRange>); catalogPrices: ((prodct: Product) => ProductPrice[]); catalogPricesLeveled: ((product: Product, params: { country: string; currency: string }) => Promise<{ maxQuantity: number; minQuantity: number; price: ProductPrice }[]>); price: ((product: Product, params: { country: string; currency: string; quantity?: number }) => Promise<ProductPrice>); rates: { getRate: any; updateRate: any }; simulatedPriceRange: ((prodct: Product, params: { country: string; currency: string; includeInactive?: boolean; quantity?: number; useNetPrice?: boolean; vectors: ProductConfiguration[] }, requestContext: Context) => Promise<ProductPriceRange>); userPrice: ((prodct: Product, params: { configuration?: ProductConfiguration[]; country: string; currency: string; quantity?: number; useNetPrice?: boolean }, requestContext: Context) => Promise<ProductPrice>) }

  • catalogPriceRange: ((product: Product, params: { country: string; currency: string; includeInactive?: boolean; quantity?: number; vectors: ProductConfiguration[] }) => Promise<ProductPriceRange>)

    • • (product: Product, params: { country: string; currency: string; includeInactive?: boolean; quantity?: number; vectors: ProductConfiguration[] }): Promise<ProductPriceRange>

      • Parameters

        • product: Product

        • params: { country: string; currency: string; includeInactive?: boolean; quantity?: number; vectors: ProductConfiguration[] }

          • country: string

          • currency: string

          • Optional includeInactive?: boolean

          • Optional quantity?: number

          • vectors: ProductConfiguration[]

        Returns Promise<ProductPriceRange>

  • catalogPrices: ((prodct: Product) => ProductPrice[])

    • • (prodct: Product): ProductPrice[]

      • Parameters

        • prodct: Product

        Returns ProductPrice[]

  • catalogPricesLeveled: ((product: Product, params: { country: string; currency: string }) => Promise<{ maxQuantity: number; minQuantity: number; price: ProductPrice }[]>)

    • • (product: Product, params: { country: string; currency: string }): Promise<{ maxQuantity: number; minQuantity: number; price: ProductPrice }[]>

      • Parameters

        • product: Product

        • params: { country: string; currency: string }

          • country: string

          • currency: string

        Returns Promise<{ maxQuantity: number; minQuantity: number; price: ProductPrice }[]>

  • price: ((product: Product, params: { country: string; currency: string; quantity?: number }) => Promise<ProductPrice>)

    • • (product: Product, params: { country: string; currency: string; quantity?: number }): Promise<ProductPrice>

      • Parameters

        • product: Product

        • params: { country: string; currency: string; quantity?: number }

          • country: string

          • currency: string

          • Optional quantity?: number

        Returns Promise<ProductPrice>

  • rates: { getRate: any; updateRate: any }

    • getRate:function

      • getRate(baseCurrency: string, quoteCurrency: string, maxAge: number): Promise<number>

      • Parameters

        • baseCurrency: string

        • quoteCurrency: string

        • maxAge: number

        Returns Promise<number>

    • updateRate:function

      • updateRate(rate: ProductPriceRate): Promise<boolean>

      • Parameters

        • rate: ProductPriceRate

        Returns Promise<boolean>

  • simulatedPriceRange: ((prodct: Product, params: { country: string; currency: string; includeInactive?: boolean; quantity?: number; useNetPrice?: boolean; vectors: ProductConfiguration[] }, requestContext: Context) => Promise<ProductPriceRange>)

    • • (prodct: Product, params: { country: string; currency: string; includeInactive?: boolean; quantity?: number; useNetPrice?: boolean; vectors: ProductConfiguration[] }, requestContext: Context): Promise<ProductPriceRange>

      • Parameters

        • prodct: Product

        • params: { country: string; currency: string; includeInactive?: boolean; quantity?: number; useNetPrice?: boolean; vectors: ProductConfiguration[] }

          • country: string

          • currency: string

          • Optional includeInactive?: boolean

          • Optional quantity?: number

          • Optional useNetPrice?: boolean

          • vectors: ProductConfiguration[]

        • requestContext: Context

        Returns Promise<ProductPriceRange>

  • userPrice: ((prodct: Product, params: { configuration?: ProductConfiguration[]; country: string; currency: string; quantity?: number; useNetPrice?: boolean }, requestContext: Context) => Promise<ProductPrice>)

    • • (prodct: Product, params: { configuration?: ProductConfiguration[]; country: string; currency: string; quantity?: number; useNetPrice?: boolean }, requestContext: Context): Promise<ProductPrice>

      • Parameters

        • prodct: Product

        • params: { configuration?: ProductConfiguration[]; country: string; currency: string; quantity?: number; useNetPrice?: boolean }

          • Optional configuration?: ProductConfiguration[]

          • country: string

          • currency: string

          • Optional quantity?: number

          • Optional useNetPrice?: boolean

        • requestContext: Context

        Returns Promise<ProductPrice>

• pricingSheet: ((params: { calculation: ProductPricingCalculation[]; currency: string; quantity: number }) => IProductPricingSheet)

  • • (params: { calculation: ProductPricingCalculation[]; currency: string; quantity: number }): IProductPricingSheet

    • Parameters

      • params: { calculation: ProductPricingCalculation[]; currency: string; quantity: number }

        • calculation: ProductPricingCalculation[]

        • currency: string

        • quantity: number

      Returns IProductPricingSheet

• productExists: ((params: { productId?: string; slug?: string }) => Promise<boolean>)

  • • (params: { productId?: string; slug?: string }): Promise<boolean>

    • Parameters

      • params: { productId?: string; slug?: string }

        • Optional productId?: string

        • Optional slug?: string

      Returns Promise<boolean>

• proxyAssignments: ((product: Product, options: { includeInactive?: boolean }) => Promise<{ assignment: ProductAssignment; product: Product }[]>)

  • • (product: Product, options: { includeInactive?: boolean }): Promise<{ assignment: ProductAssignment; product: Product }[]>

    • Parameters

      • product: Product

      • options: { includeInactive?: boolean }

        • Optional includeInactive?: boolean

      Returns Promise<{ assignment: ProductAssignment; product: Product }[]>

• proxyProducts: ((product: Product, vectors: ProductConfiguration[], options: { includeInactive?: boolean }) => Promise<Product[]>)

  • • (product: Product, vectors: ProductConfiguration[], options: { includeInactive?: boolean }): Promise<Product[]>

    • Parameters

      • product: Product

      • vectors: ProductConfiguration[]

      • options: { includeInactive?: boolean }

        • Optional includeInactive?: boolean

      Returns Promise<Product[]>

• publish: ((product: Product, userId?: string) => Promise<boolean>)

  • • (product: Product, userId?: string): Promise<boolean>

    • Parameters

      • product: Product

      • Optional userId: string

      Returns Promise<boolean>

• resolveOrderableProduct: ((product: Product, params: { configuration?: ProductConfiguration[] }, requestContext: Context) => Promise<Product>)

  • • (product: Product, params: { configuration?: ProductConfiguration[] }, requestContext: Context): Promise<Product>

    • Parameters

      • product: Product

      • params: { configuration?: ProductConfiguration[] }

        • Optional configuration?: ProductConfiguration[]

      • requestContext: Context

      Returns Promise<Product>

• reviews: ProductReviewsModule

• search: { buildActiveDraftStatusFilter: (() => Query); buildActiveStatusFilter: (() => Query); countFilteredProducts: ((params: { productIds: string[]; productSelector: Query }) => Promise<number>); findFilteredProducts: ((params: { limit?: number; offset?: number; productIds: string[]; productSelector: Query; sort?: FindOptions["sort"] }) => Promise<Product[]>) }

  • buildActiveDraftStatusFilter: (() => Query)

    • • (): Query

      • Returns Query

  • buildActiveStatusFilter: (() => Query)

    • • (): Query

      • Returns Query

  • countFilteredProducts: ((params: { productIds: string[]; productSelector: Query }) => Promise<number>)

    • • (params: { productIds: string[]; productSelector: Query }): Promise<number>

      • Parameters

        • params: { productIds: string[]; productSelector: Query }

          • productIds: string[]

          • productSelector: Query

        Returns Promise<number>

  • findFilteredProducts: ((params: { limit?: number; offset?: number; productIds: string[]; productSelector: Query; sort?: FindOptions["sort"] }) => Promise<Product[]>)

    • • (params: { limit?: number; offset?: number; productIds: string[]; productSelector: Query; sort?: FindOptions["sort"] }): Promise<Product[]>

      • Parameters

        • params: { limit?: number; offset?: number; productIds: string[]; productSelector: Query; sort?: FindOptions["sort"] }

          • Optional limit?: number

          • Optional offset?: number

          • productIds: string[]

          • productSelector: Query

          • Optional sort?: FindOptions["sort"]

        Returns Promise<Product[]>

• texts: { deleteMany: ((productId: string, userId?: string) => Promise<number>); findLocalizedText: ((params: { locale?: string; productId: string }) => Promise<ProductText>); findTexts: ((query: Query, options?: FindOptions) => Promise<ProductText[]>); makeSlug: ((data: { productId: string; slug?: string; title: string }) => Promise<string>); searchTexts: (({ searchText: string }: any) => Promise<string[]>); updateTexts: ((productId: string, texts: Omit<ProductText, "productId" | "authorId">[], userId?: string) => Promise<ProductText[]>); upsertLocalizedText: ((productId: string, locale: string, text: Omit<ProductText, "productId" | "locale" | "authorId">, userId?: string) => Promise<ProductText>) }

  • deleteMany: ((productId: string, userId?: string) => Promise<number>)

    • • (productId: string, userId?: string): Promise<number>

      • Parameters

        • productId: string

        • Optional userId: string

        Returns Promise<number>

  • findLocalizedText: ((params: { locale?: string; productId: string }) => Promise<ProductText>)

    • • (params: { locale?: string; productId: string }): Promise<ProductText>

      • Parameters

        • params: { locale?: string; productId: string }

          • Optional locale?: string

          • productId: string

        Returns Promise<ProductText>

  • findTexts: ((query: Query, options?: FindOptions) => Promise<ProductText[]>)

    • • (query: Query, options?: FindOptions): Promise<ProductText[]>

      • Parameters

        • query: Query

        • Optional options: FindOptions

        Returns Promise<ProductText[]>

  • makeSlug: ((data: { productId: string; slug?: string; title: string }) => Promise<string>)

    • • (data: { productId: string; slug?: string; title: string }): Promise<string>

      • Parameters

        • data: { productId: string; slug?: string; title: string }

          • productId: string

          • Optional slug?: string

          • title: string

        Returns Promise<string>

  • searchTexts: (({ searchText: string }: any) => Promise<string[]>)

    • • ({ searchText: string }: any): Promise<string[]>

      • Parameters

        • { searchText: string }: any

        Returns Promise<string[]>

  • updateTexts: ((productId: string, texts: Omit<ProductText, "productId" | "authorId">[], userId?: string) => Promise<ProductText[]>)

    • • (productId: string, texts: Omit<ProductText, "productId" | "authorId">[], userId?: string): Promise<ProductText[]>

      • Parameters

        • productId: string

        • texts: Omit<ProductText, "productId" | "authorId">[]

        • Optional userId: string

        Returns Promise<ProductText[]>

  • upsertLocalizedText: ((productId: string, locale: string, text: Omit<ProductText, "productId" | "locale" | "authorId">, userId?: string) => Promise<ProductText>)

    • • (productId: string, locale: string, text: Omit<ProductText, "productId" | "locale" | "authorId">, userId?: string): Promise<ProductText>

      • Parameters

        • productId: string

        • locale: string

        • text: Omit<ProductText, "productId" | "locale" | "authorId">

        • Optional userId: string

        Returns Promise<ProductText>

• unpublish: ((product: Product, userId?: string) => Promise<boolean>)

  • • (product: Product, userId?: string): Promise<boolean>

    • Parameters

      • product: Product

      • Optional userId: string

      Returns Promise<boolean>

• update: ((productId: string, doc: Update<Product>, userId: string) => Promise<string>)

  • • (productId: string, doc: Update<Product>, userId: string): Promise<string>

    • Parameters

      • productId: string

      • doc: Update<Product>

      • userId: string

      Returns Promise<string>

• variations: ProductVariationsModule