@mercurjs/core 2.1.6 → 2.2.0-canary.11

package/.medusa/server/src/workflows/product/steps/resolve-attribute-refs.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAttributeRefsStep = exports.resolveAttributeRefsStepId = exports.isInlineRef = exports.isExistingRef = void 0;
+exports.buildInlinePlan = buildInlinePlan;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const types_1 = require("@mercurjs/types");
+const isExistingRef = (r) => r.attribute_id !== undefined;
+exports.isExistingRef = isExistingRef;
+const isInlineRef = (r) => r.name !== undefined;
+exports.isInlineRef = isInlineRef;
+exports.resolveAttributeRefsStepId = "mercur-resolve-attribute-refs";
+exports.resolveAttributeRefsStep = (0, workflows_sdk_1.createStep)(exports.resolveAttributeRefsStepId, async (input, { container }) => {
+    const attributeIds = new Set();
+    for (const g of input.groups) {
+        for (const r of [
+            ...(g.variant_attributes ?? []),
+            ...(g.product_attributes ?? []),
+        ]) {
+            if ((0, exports.isExistingRef)(r))
+                attributeIds.add(r.attribute_id);
+        }
+    }
+    let attrsById = new Map();
+    if (attributeIds.size) {
+        const service = container.resolve(types_1.MercurModules.PRODUCT_ATTRIBUTE);
+        const attrs = await service.listProductAttributes({ id: Array.from(attributeIds) }, {
+            relations: ["values"],
+            select: ["id", "name", "type", "is_variant_axis"],
+        });
+        attrsById = new Map(attrs.map((a) => [
+            a.id,
+            {
+                id: a.id,
+                name: a.name,
+                type: a.type,
+                is_variant_axis: !!a.is_variant_axis,
+                values: (a.values ?? []).map((v) => ({ id: v.id, name: v.name })),
+            },
+        ]));
+    }
+    const resolveExisting = (ref) => {
+        const attr = attrsById.get(ref.attribute_id);
+        if (!attr) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Product attribute ${ref.attribute_id} not found`);
+        }
+        const idToName = new Map(attr.values.map((v) => [v.id, v.name]));
+        const nameToId = new Map(attr.values.map((v) => [v.name, v.id]));
+        const value_ids = [];
+        const value_names = [];
+        for (const id of ref.value_ids ?? []) {
+            const name = idToName.get(id);
+            if (!name) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Product attribute value ${id} not found on attribute ${ref.attribute_id}`);
+            }
+            value_ids.push(id);
+            value_names.push(name);
+        }
+        for (const name of ref.values ?? []) {
+            const id = nameToId.get(name);
+            // Select-type values must already exist; text/unit values are
+            // free-form and resolved elsewhere — skip silently here.
+            if (!id)
+                continue;
+            if (!value_ids.includes(id)) {
+                value_ids.push(id);
+                value_names.push(name);
+            }
+        }
+        return {
+            attribute_id: ref.attribute_id,
+            attribute_name: attr.name,
+            attribute_type: attr.type,
+            is_variant_axis: attr.is_variant_axis,
+            value_ids,
+            value_names,
+        };
+    };
+    const perGroup = input.groups.map((g) => {
+        const out = {
+            existing_variant: [],
+            inline_variant: [],
+            existing_product: [],
+            inline_product: [],
+        };
+        for (const r of g.variant_attributes ?? []) {
+            if ((0, exports.isExistingRef)(r))
+                out.existing_variant.push(resolveExisting(r));
+            else if ((0, exports.isInlineRef)(r))
+                out.inline_variant.push({
+                    name: r.name,
+                    type: r.type,
+                    is_variant_axis: true,
+                    values: r.values ?? [],
+                    is_filterable: r.is_filterable,
+                    is_required: r.is_required,
+                    description: r.description,
+                    metadata: r.metadata,
+                });
+        }
+        for (const r of g.product_attributes ?? []) {
+            if ((0, exports.isExistingRef)(r))
+                out.existing_product.push(resolveExisting(r));
+            else if ((0, exports.isInlineRef)(r))
+                out.inline_product.push({
+                    name: r.name,
+                    type: r.type,
+                    is_variant_axis: r.is_variant_axis ?? false,
+                    values: r.values ?? [],
+                    is_filterable: r.is_filterable,
+                    is_required: r.is_required,
+                    description: r.description,
+                    metadata: r.metadata,
+                });
+        }
+        return out;
+    });
+    return new workflows_sdk_1.StepResponse(perGroup);
+});
+/**
+ * Flattens inline refs across resolved groups into the deterministic
+ * `InlinePlanEntry[]` shape consumed by the create / update wrappers.
+ * Order: per group → inline variant refs → inline product refs. Both
+ * wrappers recompute the plan the same way, so the resulting indices
+ * align with the flat outputs of `createProductAttributesStep` /
+ * `createProductAttributeValuesStep`.
+ */
+/**
+ * Drops empty entries and de-duplicates value names per ref. The
+ * underlying `ProductAttributeValue` uniqueness index is on
+ * `(attribute_id, handle)`, but two values with the same `name` are
+ * legal at the DB level — the UI form, however, treats names as the
+ * user-facing identity. Deduping here keeps the materialised set in
+ * line with what the form expects to round-trip.
+ */
+const dedupeValueNames = (values) => {
+    const seen = new Set();
+    const out = [];
+    for (const v of values) {
+        const trimmed = v?.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+};
+function buildInlinePlan(groups, productIdAt) {
+    const plan = [];
+    groups.forEach((r, idx) => {
+        const product_id = productIdAt(idx);
+        if (!product_id)
+            return;
+        for (const ref of r.inline_variant) {
+            plan.push({
+                name: ref.name,
+                type: ref.type,
+                is_variant_axis: true,
+                is_filterable: ref.is_filterable ?? false,
+                is_required: ref.is_required ?? false,
+                description: ref.description ?? null,
+                metadata: ref.metadata ?? null,
+                product_id,
+                _group_idx: idx,
+                _value_names: dedupeValueNames(ref.values),
+            });
+        }
+        for (const ref of r.inline_product) {
+            plan.push({
+                name: ref.name,
+                type: ref.type,
+                is_variant_axis: ref.is_variant_axis,
+                is_filterable: ref.is_filterable ?? false,
+                is_required: ref.is_required ?? false,
+                description: ref.description ?? null,
+                metadata: ref.metadata ?? null,
+                product_id,
+                _group_idx: idx,
+                _value_names: dedupeValueNames(ref.values),
+            });
+        }
+    });
+    return plan;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve-attribute-refs.js","sourceRoot":"","sources":["../../../../../../src/workflows/product/steps/resolve-attribute-refs.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/workflows/product/steps/validate-products-status.d.ts

@@ -0,0 +1,19 @@
+import { ProductStatus } from "@medusajs/framework/utils";
+type ValidateProductsStatusStepInput = {
+    products: Array<{
+        id: string;
+        status: string;
+    }>;
+    expected_status: ProductStatus | ProductStatus[];
+};
+export declare const validateProductsStatusStepId = "validate-products-status";
+/**
+ * Guard that all input products are in one of the expected statuses.
+ * Used by the publish-approval workflows (`confirmProductsWorkflow`,
+ * `rejectProductWorkflow`, `requestProductChangeWorkflow`) which all
+ * require `proposed` as the only eligible state. Existence is
+ * presumed validated upstream by `useQueryGraphStep` with
+ * `throwIfKeyNotFound: true`.
+ */
+export declare const validateProductsStatusStep: import("@medusajs/framework/workflows-sdk").StepFunction<ValidateProductsStatusStepInput, undefined>;
+export {};

package/.medusa/server/src/workflows/product/steps/validate-products-status.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProductsStatusStep = exports.validateProductsStatusStepId = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+exports.validateProductsStatusStepId = "validate-products-status";
+/**
+ * Guard that all input products are in one of the expected statuses.
+ * Used by the publish-approval workflows (`confirmProductsWorkflow`,
+ * `rejectProductWorkflow`, `requestProductChangeWorkflow`) which all
+ * require `proposed` as the only eligible state. Existence is
+ * presumed validated upstream by `useQueryGraphStep` with
+ * `throwIfKeyNotFound: true`.
+ */
+exports.validateProductsStatusStep = (0, workflows_sdk_1.createStep)(exports.validateProductsStatusStepId, async ({ products, expected_status }) => {
+    const allowed = Array.isArray(expected_status)
+        ? new Set(expected_status)
+        : new Set([expected_status]);
+    const invalid = products.filter((p) => !allowed.has(p.status));
+    if (invalid.length) {
+        const expected = [...allowed].join(", ");
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Product(s) [${invalid
+            .map((p) => `${p.id} (status: ${p.status})`)
+            .join(", ")}] are not in an eligible status. Expected one of: ${expected}.`);
+    }
+    return new workflows_sdk_1.StepResponse(void 0);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtcHJvZHVjdHMtc3RhdHVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL3dvcmtmbG93cy9wcm9kdWN0L3N0ZXBzL3ZhbGlkYXRlLXByb2R1Y3RzLXN0YXR1cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxREFBc0U7QUFDdEUscUVBQTRFO0FBTy9ELFFBQUEsNEJBQTRCLEdBQUcsMEJBQTBCLENBQUE7QUFFdEU7Ozs7Ozs7R0FPRztBQUNVLFFBQUEsMEJBQTBCLEdBQUcsSUFBQSwwQkFBVSxFQUNsRCxvQ0FBNEIsRUFDNUIsS0FBSyxFQUFFLEVBQUUsUUFBUSxFQUFFLGVBQWUsRUFBbUMsRUFBRSxFQUFFO0lBQ3ZFLE1BQU0sT0FBTyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDO1FBQzVDLENBQUMsQ0FBQyxJQUFJLEdBQUcsQ0FBUyxlQUFlLENBQUM7UUFDbEMsQ0FBQyxDQUFDLElBQUksR0FBRyxDQUFTLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQTtJQUV0QyxNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUE7SUFFOUQsSUFBSSxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDbkIsTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUN4QyxNQUFNLElBQUksbUJBQVcsQ0FDbkIsbUJBQVcsQ0FBQyxLQUFLLENBQUMsV0FBVyxFQUM3QixlQUFlLE9BQU87YUFDbkIsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLGFBQWEsQ0FBQyxDQUFDLE1BQU0sR0FBRyxDQUFDO2FBQzNDLElBQUksQ0FBQyxJQUFJLENBQUMscURBQXFELFFBQVEsR0FBRyxDQUM5RSxDQUFBO0lBQ0gsQ0FBQztJQUVELE9BQU8sSUFBSSw0QkFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUE7QUFDakMsQ0FBQyxDQUNGLENBQUEifQ==

package/.medusa/server/src/workflows/product/steps/validate-seller-product-permissions.d.ts

@@ -0,0 +1,6 @@
+type ValidateSellerProductPermissionsInput = {
+    seller_id: string;
+    category_ids?: string[];
+};
+export declare const validateSellerProductPermissionsStep: import("@medusajs/framework/workflows-sdk").StepFunction<ValidateSellerProductPermissionsInput, undefined>;
+export {};

package/.medusa/server/src/workflows/product/steps/validate-seller-product-permissions.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSellerProductPermissionsStep = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+exports.validateSellerProductPermissionsStep = (0, workflows_sdk_1.createStep)("validate-seller-product-permissions", async ({ seller_id, category_ids, }, { container }) => {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    // Category restriction (blacklist): if a category-seller link exists for
+    // (category_id, seller_id), the seller is BLOCKED from that category.
+    if (category_ids && category_ids.length > 0) {
+        const uniqueCategoryIds = [...new Set(category_ids)];
+        const { data: categories } = await query.graph({
+            entity: "product_category",
+            fields: ["id", "sellers.id"],
+            filters: { id: uniqueCategoryIds },
+        });
+        const blockedIds = categories
+            .filter((c) => (c.sellers ?? []).some((s) => s.id === seller_id))
+            .map((c) => c.id);
+        if (blockedIds.length > 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Seller is restricted from categories: ${blockedIds.join(", ")}`);
+        }
+    }
+    return new workflows_sdk_1.StepResponse(void 0);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtc2VsbGVyLXByb2R1Y3QtcGVybWlzc2lvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3Byb2R1Y3Qvc3RlcHMvdmFsaWRhdGUtc2VsbGVyLXByb2R1Y3QtcGVybWlzc2lvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EscURBR2tDO0FBQ2xDLHFFQUE0RTtBQU8vRCxRQUFBLG9DQUFvQyxHQUFHLElBQUEsMEJBQVUsRUFDNUQscUNBQXFDLEVBQ3JDLEtBQUssRUFDSCxFQUNFLFNBQVMsRUFDVCxZQUFZLEdBQzBCLEVBQ3hDLEVBQUUsU0FBUyxFQUFFLEVBQ2IsRUFBRTtJQUNGLE1BQU0sS0FBSyxHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQVEsaUNBQXlCLENBQUMsS0FBSyxDQUFDLENBQUE7SUFFdkUseUVBQXlFO0lBQ3pFLHNFQUFzRTtJQUN0RSxJQUFJLFlBQVksSUFBSSxZQUFZLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQzVDLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUE7UUFFcEQsTUFBTSxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsR0FBRyxNQUFNLEtBQUssQ0FBQyxLQUFLLENBQUM7WUFDN0MsTUFBTSxFQUFFLGtCQUFrQjtZQUMxQixNQUFNLEVBQUUsQ0FBQyxJQUFJLEVBQUUsWUFBWSxDQUFDO1lBQzVCLE9BQU8sRUFBRSxFQUFFLEVBQUUsRUFBRSxpQkFBaUIsRUFBRTtTQUNuQyxDQUFDLENBQUE7UUFFRixNQUFNLFVBQVUsR0FBRyxVQUFVO2FBQzFCLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQ1osQ0FBQyxDQUFDLENBQUMsT0FBTyxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxTQUFTLENBQUMsQ0FDbEQ7YUFDQSxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQTtRQUVuQixJQUFJLFVBQVUsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDMUIsTUFBTSxJQUFJLG1CQUFXLENBQ25CLG1CQUFXLENBQUMsS0FBSyxDQUFDLFdBQVcsRUFDN0IseUNBQXlDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FDakUsQ0FBQTtRQUNILENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxJQUFJLDRCQUFZLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQTtBQUNqQyxDQUFDLENBQ0YsQ0FBQSJ9

package/.medusa/server/src/workflows/product/workflows/confirm-products.d.ts

@@ -0,0 +1,27 @@
+export declare const confirmProductsWorkflowId = "mercur-confirm-products";
+type ConfirmProductsWorkflowInput = {
+    product_ids: string[];
+    actor_id?: string;
+    /**
+     * Operator-only note persisted onto `ProductChange.internal_note`
+     * for each confirmed product. Optional.
+     */
+    internal_note?: string;
+};
+/**
+ * Admin-side "publish a vendor submission". Mirrors the audit-trail
+ * pattern used by `createProductsWorkflow`:
+ *
+ *   1. Load + validate the products are `proposed`.
+ *   2. Record one CONFIRMED `ProductChange` per product with a
+ *      pre-applied `STATUS_CHANGE` action (delegated to
+ *      `recordProductAuditChangeWorkflow`). The change is the audit
+ *      row — no admin queue.
+ *   3. Apply the actual product status update.
+ *   4. Emit `product.published` so notifications / search reindex.
+ */
+export declare const confirmProductsWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<ConfirmProductsWorkflowInput, undefined, [import("@medusajs/framework/workflows-sdk").Hook<"productsConfirmed", {
+    product_ids: string[];
+    internal_note: string | undefined;
+}, unknown>]>;
+export {};

package/.medusa/server/src/workflows/product/workflows/confirm-products.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirmProductsWorkflow = exports.confirmProductsWorkflowId = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_1 = require("@medusajs/framework/utils");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const types_1 = require("@mercurjs/types");
+const events_1 = require("../events");
+const validate_products_status_1 = require("../steps/validate-products-status");
+const record_product_audit_change_1 = require("../../product-edit/workflows/record-product-audit-change");
+exports.confirmProductsWorkflowId = "mercur-confirm-products";
+/**
+ * Admin-side "publish a vendor submission". Mirrors the audit-trail
+ * pattern used by `createProductsWorkflow`:
+ *
+ *   1. Load + validate the products are `proposed`.
+ *   2. Record one CONFIRMED `ProductChange` per product with a
+ *      pre-applied `STATUS_CHANGE` action (delegated to
+ *      `recordProductAuditChangeWorkflow`). The change is the audit
+ *      row — no admin queue.
+ *   3. Apply the actual product status update.
+ *   4. Emit `product.published` so notifications / search reindex.
+ */
+exports.confirmProductsWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.confirmProductsWorkflowId, function (input) {
+    const { data: products } = (0, core_flows_1.useQueryGraphStep)({
+        entity: "product",
+        fields: ["id", "status"],
+        filters: { id: input.product_ids },
+        options: { throwIfKeyNotFound: true },
+    }).config({ name: "get-products" });
+    (0, validate_products_status_1.validateProductsStatusStep)({
+        products,
+        expected_status: utils_1.ProductStatus.PROPOSED,
+    });
+    record_product_audit_change_1.recordProductAuditChangeWorkflow.runAsStep({
+        input: (0, workflows_sdk_1.transform)({ products, input }, ({ products, input }) => ({
+            actor_id: input.actor_id,
+            changes: products.map((product) => ({
+                product_id: product.id,
+                internal_note: input.internal_note,
+                actions: [
+                    {
+                        product_id: product.id,
+                        action: types_1.ProductChangeActionType.STATUS_CHANGE,
+                        details: { status: utils_1.ProductStatus.PUBLISHED },
+                    },
+                ],
+            })),
+        })),
+    });
+    (0, core_flows_1.updateProductsStep)((0, workflows_sdk_1.transform)({ input }, ({ input }) => ({
+        selector: { id: input.product_ids },
+        update: { status: utils_1.ProductStatus.PUBLISHED },
+    })));
+    (0, core_flows_1.emitEventStep)({
+        eventName: events_1.ProductWorkflowEvents.PUBLISHED,
+        data: (0, workflows_sdk_1.transform)({ input }, ({ input }) => input.product_ids.map((id) => ({
+            id,
+            internal_note: input.internal_note,
+        }))),
+    });
+    const productsConfirmed = (0, workflows_sdk_1.createHook)("productsConfirmed", {
+        product_ids: input.product_ids,
+        internal_note: input.internal_note,
+    });
+    return new workflows_sdk_1.WorkflowResponse(void 0, { hooks: [productsConfirmed] });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/product/workflows/create-products.d.ts

@@ -0,0 +1,59 @@
+import { type ReturnWorkflow } from "@medusajs/framework/workflows-sdk";
+import { AdditionalData, ProductTypes } from "@medusajs/framework/types";
+import { CreateProductDTO } from "@mercurjs/types";
+import { type AttributeRef } from "../steps";
+type ProductOptionInput = {
+    title: string;
+    values: string[];
+};
+/** Per-product input on the create wrapper. */
+export type CreateProductWorkflowInput = Omit<CreateProductDTO, "variant_attributes" | "product_attributes" | "variants"> & {
+    variant_attributes?: AttributeRef[];
+    product_attributes?: AttributeRef[];
+    seller_ids?: string[];
+    options?: ProductOptionInput[];
+    variants?: Array<Record<string, unknown> & {
+        options?: Record<string, string>;
+        attribute_values?: Record<string, string | string[]> | string[];
+    }>;
+};
+export type CreateProductsWorkflowInput = {
+    products: CreateProductWorkflowInput[];
+    /**
+     * Marketplace add-on: seller ids to authorize for **every** created
+     * product. For per-product seller authorization, set `seller_ids` on
+     * the individual product entry instead.
+     */
+    seller_ids?: string[];
+} & AdditionalData;
+export declare const createProductsWorkflowId = "mercur-create-products";
+/**
+ * Marketplace wrapper over stock `createProductsWorkflow`.
+ *
+ * On top of stock it:
+ *   1. Resolves `variant_attributes` / `product_attributes` (existing
+ *      attribute lookups, value name ↔ id resolution) via
+ *      `resolveAttributeRefsStep`.
+ *   2. Synthesizes stock `options[]` from variant-axis attributes (both
+ *      existing and inline) — UI doesn't have to emit a parallel
+ *      `options` field.
+ *   3. Renames `variants[].attribute_values` (the Mercur extension —
+ *      `{Size: "S"}` name map) to `variants[].options` so stock variant
+ *      generation works unchanged.
+ *   4. Strips marketplace-only fields before delegating to stock.
+ *   5. Pins every variant's `manage_inventory` to `false` (marketplace
+ *      invariant — vendor variants never participate in inventory
+ *      bookkeeping).
+ *   6. Synthesizes a default option + variant for simple products so
+ *      stock's variant validator does not throw.
+ *   7. After stock returns, materialises inline-custom attributes via
+ *      `createProductAttributesStep` + their values via
+ *      `createProductAttributeValuesStep` (both scoped to the created
+ *      product through the `product_id` FK).
+ *   8. Writes `product_attribute_value_link` rows for every chosen
+ *      value (existing + inline) using stock `createRemoteLinkStep`,
+ *      so the edit form can pre-select them.
+ *   9. Writes `product_seller` link rows for the requested seller_ids.
+ */
+export declare const createProductsWorkflow: ReturnWorkflow<CreateProductsWorkflowInput, ProductTypes.ProductDTO[], unknown[]>;
+export {};