@mercurjs/core 2.2.0-canary.2 → 2.2.0-canary.21

package/.medusa/server/src/api/utils/filter-attributes-by-category-link.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterAttributesByCategoryLinkOrGlobal = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Replacement for `maybeApplyLinkFilter` on the
+ * `category_owning_attribute` link. When a category filter is present,
+ * the default helper restricts the result to attribute IDs linked to
+ * that category, which silently drops "global" attributes (those that
+ * have no category link at all). Marketplace operators and vendors
+ * expect a category-scoped attribute list to also surface global
+ * attributes, so this middleware composes:
+ *
+ *   id IN (attribute IDs linked to the requested category)
+ *   OR
+ *   id NOT IN (any attribute that has at least one category link)
+ *
+ * The second clause is what brings global attributes back in.
+ */
+const filterAttributesByCategoryLinkOrGlobal = async (req, _, next) => {
+    const filterableFields = req.filterableFields ?? {};
+    const categoryFilter = filterableFields.product_category_id;
+    if (!categoryFilter) {
+        return next();
+    }
+    delete filterableFields.product_category_id;
+    const categoryIds = Array.isArray(categoryFilter)
+        ? categoryFilter
+        : [categoryFilter];
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: linkedToCategory } = await query.graph({
+        entity: "category_owning_attribute",
+        fields: ["product_attribute_id"],
+        filters: { product_category_id: categoryIds },
+    });
+    const linkedToCategoryIds = Array.from(new Set(linkedToCategory.map((l) => l.product_attribute_id)));
+    const { data: anyLinked } = await query.graph({
+        entity: "category_owning_attribute",
+        fields: ["product_attribute_id"],
+    });
+    const anyLinkedIds = Array.from(new Set(anyLinked.map((l) => l.product_attribute_id)));
+    const orClause = [
+        { id: linkedToCategoryIds },
+        { id: { $nin: anyLinkedIds } },
+    ];
+    const existingId = filterableFields.id;
+    if (existingId !== undefined) {
+        filterableFields.$and = [{ id: existingId }, { $or: orClause }];
+        delete filterableFields.id;
+    }
+    else {
+        filterableFields.$or = orClause;
+    }
+    req.filterableFields = filterableFields;
+    return next();
+};
+exports.filterAttributesByCategoryLinkOrGlobal = filterAttributesByCategoryLinkOrGlobal;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/utils/format-product-attributes.d.ts

@@ -1,8 +1,54 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
 /**
- * Computes a unified `attributes` array on the product by merging
- * variant_attributes, custom_attributes, and attribute_values into
- * a single grouped structure with values nested under each attribute.
+ * Builds a unified `product.attributes` array on each product from the
+ * linked value ids (single-hop joiner) by issuing TWO bulk queries
+ * against the product-attribute module — one for every selected value
+ * across all input products, one for every attribute's full value set.
+ * Each entry per product surfaces:
  *
- * Mutates the product object in place.
+ *   - `values`: the values selected on this product (sorted by rank).
+ *   - `all_values`: the parent attribute's full value set so the edit
+ *     form can render the dropdown with `values` pre-selected.
+ *
+ * Always seeds `product.attributes = []` even when there's nothing to
+ * enrich, so downstream code can rely on the field existing. Cross-
+ * module chained populate (`attribute_values.attribute.values`) crashes
+ * Medusa's joiner here because the value side lives in another module —
+ * splitting the read avoids that path entirely.
+ *
+ * Mutates each product object in place.
+ */
+export declare function enrichProductAttributes(scope: MedusaContainer, products: any[]): Promise<void>;
+type ProductAttributeValueRow = {
+    id: string;
+    name: string;
+    attribute?: {
+        id: string;
+        name?: string;
+        handle?: string | null;
+        type?: string;
+        is_variant_axis?: boolean;
+    } | null;
+};
+type GroupedProductAttribute = {
+    id: string;
+    name?: string;
+    handle?: string | null;
+    type?: string;
+    is_variant_axis?: boolean;
+    values: {
+        id: string;
+        name: string;
+    }[];
+};
+/**
+ * Groups `product.attribute_values` (from a 2-hop graph fetch with
+ * `attribute_values.attribute.*`) into one entry per attribute, each
+ * carrying only the values selected on this product. Pass
+ * `options.attributeId` to narrow the result to a single attribute for
+ * detail endpoints.
  */
-export declare function formatProductAttributes(product: any): void;
+export declare function groupProductAttributeValues(attributeValues: ProductAttributeValueRow[] | undefined, options?: {
+    attributeId?: string;
+}): GroupedProductAttribute[];
+export {};

package/.medusa/server/src/api/utils/format-product-attributes.js

@@ -1,44 +1,189 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatProductAttributes = formatProductAttributes;
+exports.enrichProductAttributes = enrichProductAttributes;
+exports.groupProductAttributeValues = groupProductAttributeValues;
+const utils_1 = require("@medusajs/framework/utils");
 /**
- * Computes a unified `attributes` array on the product by merging
- * variant_attributes, custom_attributes, and attribute_values into
- * a single grouped structure with values nested under each attribute.
+ * Builds a unified `product.attributes` array on each product from the
+ * linked value ids (single-hop joiner) by issuing TWO bulk queries
+ * against the product-attribute module — one for every selected value
+ * across all input products, one for every attribute's full value set.
+ * Each entry per product surfaces:
  *
- * Mutates the product object in place.
+ *   - `values`: the values selected on this product (sorted by rank).
+ *   - `all_values`: the parent attribute's full value set so the edit
+ *     form can render the dropdown with `values` pre-selected.
+ *
+ * Always seeds `product.attributes = []` even when there's nothing to
+ * enrich, so downstream code can rely on the field existing. Cross-
+ * module chained populate (`attribute_values.attribute.values`) crashes
+ * Medusa's joiner here because the value side lives in another module —
+ * splitting the read avoids that path entirely.
+ *
+ * Mutates each product object in place.
  */
-function formatProductAttributes(product) {
-    const hasAttrData = product.variant_attributes ||
-        product.custom_attributes ||
-        product.attribute_values;
-    if (!hasAttrData)
+async function enrichProductAttributes(scope, products) {
+    if (!products?.length)
         return;
-    const attrsById = new Map();
-    for (const attr of product.variant_attributes ?? []) {
-        attrsById.set(attr.id, { ...attr, values: [...(attr.values ?? [])] });
-    }
-    for (const attr of product.custom_attributes ?? []) {
-        if (!attrsById.has(attr.id)) {
-            attrsById.set(attr.id, {
-                ...attr,
-                values: [...(attr.values ?? [])],
-            });
+    // Guarantee the field is present even if the product carries no
+    // attribute joiner data.
+    for (const product of products) {
+        if (product && !product.attributes)
+            product.attributes = [];
+    }
+    // Collect linked value ids and product-scoped attribute ids across
+    // the whole batch so we issue one query per module entity instead of
+    // N (where N = list size).
+    const linkedValueIds = new Set();
+    const inlineAttributeIds = new Set();
+    for (const product of products) {
+        for (const v of (product?.attribute_values ?? [])) {
+            if (typeof v?.id === "string")
+                linkedValueIds.add(v.id);
         }
+        for (const a of (product?.scoped_attributes ?? [])) {
+            if (typeof a?.id === "string")
+                inlineAttributeIds.add(a.id);
+        }
+    }
+    if (!linkedValueIds.size && !inlineAttributeIds.size)
+        return;
+    const query = scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: selectedValues } = linkedValueIds.size
+        ? await query.graph({
+            entity: "product_attribute_value",
+            fields: ["id", "name", "rank", "attribute_id"],
+            filters: { id: Array.from(linkedValueIds) },
+        })
+        : {
+            data: [],
+        };
+    const selectedValueById = new Map();
+    for (const v of selectedValues) {
+        selectedValueById.set(v.id, v);
     }
-    for (const val of product.attribute_values ?? []) {
-        if (!val.attribute)
+    const attributeIds = new Set(inlineAttributeIds);
+    for (const v of selectedValues) {
+        if (v.attribute_id)
+            attributeIds.add(v.attribute_id);
+    }
+    if (!attributeIds.size)
+        return;
+    const { data: attributes } = await query.graph({
+        entity: "product_attribute",
+        fields: [
+            "id",
+            "name",
+            "handle",
+            "type",
+            "is_variant_axis",
+            "is_required",
+            "rank",
+            "product_id",
+        ],
+        filters: { id: Array.from(attributeIds) },
+    });
+    const { data: allValues } = await query.graph({
+        entity: "product_attribute_value",
+        fields: ["id", "name", "rank", "attribute_id"],
+        filters: { attribute_id: Array.from(attributeIds) },
+    });
+    const attrTemplateById = new Map();
+    for (const attr of attributes) {
+        attrTemplateById.set(attr.id, {
+            id: attr.id,
+            name: attr.name,
+            handle: attr.handle ?? null,
+            type: attr.type,
+            is_variant_axis: !!attr.is_variant_axis,
+            is_required: !!attr.is_required,
+            rank: attr.rank,
+            all_values: [],
+        });
+    }
+    for (const v of allValues) {
+        if (!v.attribute_id)
             continue;
-        const attrId = val.attribute.id ?? val.attribute_id;
-        if (!attrId || attrsById.has(attrId))
+        const tmpl = attrTemplateById.get(v.attribute_id);
+        if (!tmpl)
             continue;
-        attrsById.set(attrId, { ...val.attribute, values: [] });
+        tmpl.all_values.push({ id: v.id, name: v.name, rank: v.rank });
     }
-    const productValueIds = new Set((product.attribute_values ?? []).map((v) => v.id));
-    for (const attr of attrsById.values()) {
-        attr.values = (attr.values ?? []).filter((v) => productValueIds.has(v.id));
-        attr.values.sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+    for (const tmpl of attrTemplateById.values()) {
+        tmpl.all_values.sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+    }
+    for (const product of products) {
+        if (!product)
+            continue;
+        const productValueIds = (product.attribute_values ?? [])
+            .map((v) => v?.id)
+            .filter((id) => typeof id === "string");
+        const productScopedAttrIds = (product.scoped_attributes ?? [])
+            .map((a) => a?.id)
+            .filter((id) => typeof id === "string");
+        const attrsForProduct = new Map();
+        for (const aid of productScopedAttrIds) {
+            const tmpl = attrTemplateById.get(aid);
+            if (tmpl)
+                attrsForProduct.set(aid, {
+                    ...tmpl,
+                    all_values: [...tmpl.all_values],
+                    values: [],
+                });
+        }
+        for (const vid of productValueIds) {
+            const v = selectedValueById.get(vid);
+            if (!v?.attribute_id)
+                continue;
+            let attr = attrsForProduct.get(v.attribute_id);
+            if (!attr) {
+                const tmpl = attrTemplateById.get(v.attribute_id);
+                if (!tmpl)
+                    continue;
+                attr = {
+                    ...tmpl,
+                    all_values: [...tmpl.all_values],
+                    values: [],
+                };
+                attrsForProduct.set(v.attribute_id, attr);
+            }
+            attr.values.push({ id: v.id, name: v.name, rank: v.rank });
+        }
+        for (const attr of attrsForProduct.values()) {
+            attr.values.sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+        }
+        product.attributes = [...attrsForProduct.values()].sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+    }
+}
+/**
+ * Groups `product.attribute_values` (from a 2-hop graph fetch with
+ * `attribute_values.attribute.*`) into one entry per attribute, each
+ * carrying only the values selected on this product. Pass
+ * `options.attributeId` to narrow the result to a single attribute for
+ * detail endpoints.
+ */
+function groupProductAttributeValues(attributeValues, options) {
+    const byId = new Map();
+    for (const v of attributeValues ?? []) {
+        const attr = v.attribute;
+        if (!attr?.id)
+            continue;
+        if (options?.attributeId && attr.id !== options.attributeId)
+            continue;
+        let grouped = byId.get(attr.id);
+        if (!grouped) {
+            grouped = {
+                id: attr.id,
+                name: attr.name,
+                handle: attr.handle ?? null,
+                type: attr.type,
+                is_variant_axis: !!attr.is_variant_axis,
+                values: [],
+            };
+            byId.set(attr.id, grouped);
+        }
+        grouped.values.push({ id: v.id, name: v.name });
     }
-    product.attributes = [...attrsById.values()].sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+    return Array.from(byId.values());
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format-product-attributes.js","sourceRoot":"","sources":["../../../../../src/api/utils/format-product-attributes.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/api/utils/index.d.ts

@@ -4,3 +4,5 @@ export * from "./ensure-seller-middleware";
 export * from "./filter-by-seller-id";
 export * from "./vendor-cors-middleware";
 export * from "./format-product-attributes";
+export * from "./filter-attributes-by-category-link";
+export * from "./offers";

package/.medusa/server/src/api/utils/index.js

@@ -20,4 +20,6 @@ __exportStar(require("./ensure-seller-middleware"), exports);
 __exportStar(require("./filter-by-seller-id"), exports);
 __exportStar(require("./vendor-cors-middleware"), exports);
 __exportStar(require("./format-product-attributes"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBpL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxvREFBaUM7QUFDakMsZ0VBQTZDO0FBQzdDLDZEQUEwQztBQUMxQyx3REFBcUM7QUFDckMsMkRBQXdDO0FBQ3hDLDhEQUEyQyJ9
+__exportStar(require("./filter-attributes-by-category-link"), exports);
+__exportStar(require("./offers"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBpL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxvREFBaUM7QUFDakMsZ0VBQTZDO0FBQzdDLDZEQUEwQztBQUMxQyx3REFBcUM7QUFDckMsMkRBQXdDO0FBQ3hDLDhEQUEyQztBQUMzQyx1RUFBb0Q7QUFDcEQsMkNBQXdCIn0=

package/.medusa/server/src/api/utils/offers.d.ts

@@ -0,0 +1,48 @@
+import { AuthenticatedMedusaRequest, MedusaNextFunction, MedusaResponse } from "@medusajs/framework/http";
+import type { MedusaContainer } from "@medusajs/framework/types";
+type WrappableVariant = {
+    id: string;
+    offers?: unknown[];
+};
+type WrappableProduct = {
+    variants?: WrappableVariant[] | null;
+};
+/**
+ * Attaches offers under each variant of the given products, in place
+ * (`variant.offers = [...]`). The `offer ↔ variant` link is shared across
+ * sellers, so a raw graph traversal would surface every seller's offers on
+ * a master variant — this fetches them with one bounded query over the
+ * page's variant ids and keys them onto the matching variants. Mirrors
+ * Medusa's `wrapProductsWithTaxPrices` post-query enrichment pattern.
+ *
+ * Pass `sellerId` to scope the attach to a single seller (the vendor
+ * Offers surface, where a competitor's offers must never leak). Omit it
+ * for the platform-wide admin surface, which attaches **every** seller's
+ * offers (each carrying `offer.seller`). Variants with no offer get
+ * `offers: []`.
+ */
+export declare const wrapProductVariantsWithOffers: (scope: MedusaContainer, products: WrappableProduct[], sellerId?: string) => Promise<void>;
+type OfferAwareRequest = AuthenticatedMedusaRequest & {
+    seller_context?: {
+        seller_id?: string;
+    };
+};
+/**
+ * Scopes a product list to products carrying at least one offer, when
+ * `?has_offer=true`. Shared by the vendor and admin Offers lists, which
+ * back their product-grained rows with the product endpoint:
+ *
+ * - **Vendor** — `req.seller_context.seller_id` is always set, so the scope
+ *   is the active seller's offered products (a competitor's offered product
+ *   never appears).
+ * - **Admin** — no seller context; the optional `seller_id` query param is
+ *   the Offers **Store** filter (consumed here so it scopes the offer's
+ *   store, not product ownership). Absent it, the scope is every offered
+ *   product across the marketplace.
+ *
+ * Either way it resolves the offered variant ids and constrains the product
+ * query to products carrying one of them. The `has_offer` pseudo-filter is
+ * consumed and removed so it never reaches the product graph read.
+ */
+export declare const applyOfferedProductsFilter: (req: OfferAwareRequest, _res: MedusaResponse, next: MedusaNextFunction) => Promise<void>;
+export {};

package/.medusa/server/src/api/utils/offers.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyOfferedProductsFilter = exports.wrapProductVariantsWithOffers = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Field set pulled for each offer attached by
+ * `wrapProductVariantsWithOffers`. Carries the offer identity + seller +
+ * shipping profile + price ladder + inventory-item links (with per-location
+ * stock). `seller.*` lets the admin (platform-wide) Store column resolve;
+ * it is harmless for the seller-scoped vendor reads.
+ */
+const OFFER_WRAP_FIELDS = [
+    "id",
+    "seller_id",
+    "variant_id",
+    "shipping_profile_id",
+    "sku",
+    "ean",
+    "upc",
+    "created_at",
+    "updated_at",
+    "seller.id",
+    "seller.name",
+    "seller.handle",
+    "shipping_profile.id",
+    "shipping_profile.name",
+    "prices.id",
+    "prices.amount",
+    "prices.currency_code",
+    "prices.min_quantity",
+    "prices.max_quantity",
+    "inventory_item_link.id",
+    "inventory_item_link.required_quantity",
+    "inventory_item_link.inventory_item_id",
+    "inventory_item_link.inventory_item.id",
+    "inventory_item_link.inventory_item.sku",
+    "inventory_item_link.inventory_item.title",
+    "inventory_item_link.inventory_item.location_levels.id",
+    "inventory_item_link.inventory_item.location_levels.location_id",
+    "inventory_item_link.inventory_item.location_levels.stocked_quantity",
+];
+/**
+ * Attaches offers under each variant of the given products, in place
+ * (`variant.offers = [...]`). The `offer ↔ variant` link is shared across
+ * sellers, so a raw graph traversal would surface every seller's offers on
+ * a master variant — this fetches them with one bounded query over the
+ * page's variant ids and keys them onto the matching variants. Mirrors
+ * Medusa's `wrapProductsWithTaxPrices` post-query enrichment pattern.
+ *
+ * Pass `sellerId` to scope the attach to a single seller (the vendor
+ * Offers surface, where a competitor's offers must never leak). Omit it
+ * for the platform-wide admin surface, which attaches **every** seller's
+ * offers (each carrying `offer.seller`). Variants with no offer get
+ * `offers: []`.
+ */
+const wrapProductVariantsWithOffers = async (scope, products, sellerId) => {
+    const variantIds = Array.from(new Set(products.flatMap((p) => (p.variants ?? []).map((v) => v.id))));
+    if (!variantIds.length) {
+        return;
+    }
+    const query = scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: offers } = await query.graph({
+        entity: "offer",
+        fields: OFFER_WRAP_FIELDS,
+        filters: {
+            variant_id: variantIds,
+            ...(sellerId ? { seller_id: sellerId } : {}),
+        },
+    });
+    const offersByVariant = new Map();
+    for (const offer of offers) {
+        const existing = offersByVariant.get(offer.variant_id);
+        if (existing) {
+            existing.push(offer);
+        }
+        else {
+            offersByVariant.set(offer.variant_id, [offer]);
+        }
+    }
+    for (const product of products) {
+        for (const variant of product.variants ?? []) {
+            variant.offers = offersByVariant.get(variant.id) ?? [];
+        }
+    }
+};
+exports.wrapProductVariantsWithOffers = wrapProductVariantsWithOffers;
+/**
+ * Scopes a product list to products carrying at least one offer, when
+ * `?has_offer=true`. Shared by the vendor and admin Offers lists, which
+ * back their product-grained rows with the product endpoint:
+ *
+ * - **Vendor** — `req.seller_context.seller_id` is always set, so the scope
+ *   is the active seller's offered products (a competitor's offered product
+ *   never appears).
+ * - **Admin** — no seller context; the optional `seller_id` query param is
+ *   the Offers **Store** filter (consumed here so it scopes the offer's
+ *   store, not product ownership). Absent it, the scope is every offered
+ *   product across the marketplace.
+ *
+ * Either way it resolves the offered variant ids and constrains the product
+ * query to products carrying one of them. The `has_offer` pseudo-filter is
+ * consumed and removed so it never reaches the product graph read.
+ */
+const applyOfferedProductsFilter = async (req, _res, next) => {
+    req.filterableFields ??= {};
+    const hasOffer = req.filterableFields.has_offer;
+    delete req.filterableFields.has_offer;
+    if (hasOffer !== true) {
+        return next();
+    }
+    // Vendor: the active seller. Admin: the optional store filter (consumed
+    // here so `seller_id` scopes the offer's store, not product ownership).
+    const contextSellerId = req.seller_context?.seller_id;
+    const sellerId = contextSellerId ?? req.filterableFields.seller_id;
+    if (!contextSellerId) {
+        delete req.filterableFields.seller_id;
+    }
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: offers } = await query.graph({
+        entity: "offer",
+        fields: ["variant_id"],
+        filters: sellerId ? { seller_id: sellerId } : {},
+    });
+    const variantIds = Array.from(new Set(offers
+        .map((offer) => offer.variant_id)
+        .filter((id) => Boolean(id))));
+    const existingAnd = req.filterableFields.$and ?? [];
+    req.filterableFields.$and = [
+        ...existingAnd,
+        // No offers → match nothing (empty list) rather than the whole catalogue.
+        { variants: { id: variantIds.length ? variantIds : ["__none__"] } },
+    ];
+    return next();
+};
+exports.applyOfferedProductsFilter = applyOfferedProductsFilter;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/utils/order-commission-lines.d.ts

@@ -0,0 +1,18 @@
+import { MedusaContainer } from "@medusajs/framework/types";
+import { CommissionLineDTO } from "@mercurjs/types";
+/**
+ * Returns an order's commission lines — both item-anchored and
+ * shipping-anchored — by reading the `commission_line` entity directly.
+ *
+ * The order→commission links resolve for items but not shipping methods
+ * (and the two cannot be co-resolved in one graph query), so commission is
+ * always read from the commission module by the order's item + shipping ids.
+ *
+ * When `sellerId` is provided (vendor surface) the order's ownership is
+ * verified through the order↔seller link; a non-owned / missing order yields
+ * `found: false`.
+ */
+export declare const getOrderCommissionLines: (scope: MedusaContainer, orderId: string, sellerId?: string) => Promise<{
+    found: boolean;
+    commission_lines: CommissionLineDTO[];
+}>;