@mercurjs/core 2.3.6-canary.1 → 2.3.6-canary.10

package/.medusa/server/src/workflows/payment/utils/split-order-payment-group.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCartPaymentVoid = exports.buildOrderPaymentCollectionLinks = exports.planCartPaymentSplit = exports.resolveSplitOrderCartId = exports.resolveOrderPaymentCollections = exports.hasSplitOrderCollections = exports.isOrderCanceled = exports.isPaymentCaptured = exports.cartOrderFields = exports.cartPaymentCollectionFields = exports.CART_PAYMENT_COLLECTION_KEY = exports.SPLIT_ORDER_COLLECTIONS_FLAG = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const split_order_payment_1 = require("./split-order-payment");
+/** Set on a cart's payment collection once it is split into its orders'. */
+exports.SPLIT_ORDER_COLLECTIONS_FLAG = "split_order_collections";
+/** Set on an order's payment collection, pointing at the cart's. */
+exports.CART_PAYMENT_COLLECTION_KEY = "cart_payment_collection_id";
+const PAYMENT_FIELDS = [
+    "id",
+    "provider_id",
+    "currency_code",
+    "amount",
+    "raw_amount",
+    "data",
+    "captured_at",
+    "canceled_at",
+    "captures.id",
+    "captures.amount",
+    "captures.raw_amount",
+    "refunds.id",
+    "refunds.amount",
+    "refunds.raw_amount",
+];
+const COLLECTION_FIELDS = [
+    "id",
+    "currency_code",
+    "metadata",
+    ...PAYMENT_FIELDS.map((field) => `payments.${field}`),
+];
+/** Fields to query on `cart_payment_collection` to plan a split or a void. */
+exports.cartPaymentCollectionFields = COLLECTION_FIELDS.map((field) => `payment_collection.${field}`);
+/** Fields to query on `order_cart` to plan a split or a void. */
+exports.cartOrderFields = [
+    "order.id",
+    "order.status",
+    "order.canceled_at",
+    "order.total",
+    ...COLLECTION_FIELDS.map((field) => `order.payment_collections.${field}`),
+];
+const amountOf = (movement) => movement.raw_amount ?? movement.amount;
+const sum = (movements) => (movements ?? []).reduce((acc, movement) => utils_1.MathBN.add(acc, amountOf(movement)), utils_1.MathBN.convert(0));
+const isPaymentCaptured = (payment) => !!payment.captured_at || (payment.captures ?? []).length > 0;
+exports.isPaymentCaptured = isPaymentCaptured;
+const isOrderCanceled = (order) => order.status === utils_1.OrderStatus.CANCELED || !!order.canceled_at;
+exports.isOrderCanceled = isOrderCanceled;
+const hasSplitOrderCollections = (paymentCollection) => paymentCollection?.metadata?.[exports.SPLIT_ORDER_COLLECTIONS_FLAG] === true;
+exports.hasSplitOrderCollections = hasSplitOrderCollections;
+/**
+ * The payment collections that pay for an order. Until the cart payment is
+ * captured that is the cart's shared collection; afterwards the order has its
+ * own. An order canceled before the capture never gets one and keeps showing
+ * the cart's.
+ */
+const resolveOrderPaymentCollections = (order) => {
+    const own = order.payment_collections ?? [];
+    const cartPaymentCollection = order.cart?.payment_collection;
+    if (!cartPaymentCollection) {
+        return own;
+    }
+    return (0, exports.hasSplitOrderCollections)(cartPaymentCollection) && own.length
+        ? own
+        : [cartPaymentCollection];
+};
+exports.resolveOrderPaymentCollections = resolveOrderPaymentCollections;
+/**
+ * Resolves the cart a payment or an order belongs to. A payment can be the
+ * cart's own or one created for an order when the cart payment was split.
+ */
+const resolveSplitOrderCartId = async (container, input) => {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    if ("order_id" in input) {
+        const { data: [orderCart], } = await query.graph({
+            entity: "order_cart",
+            fields: ["cart_id"],
+            filters: { order_id: input.order_id },
+        });
+        return orderCart?.cart_id;
+    }
+    const { data: [payment], } = await query.graph({
+        entity: "payment",
+        fields: ["id", "payment_collection.id", "payment_collection.metadata"],
+        filters: { id: input.payment_id },
+    });
+    const collection = payment?.payment_collection;
+    if (!collection) {
+        return undefined;
+    }
+    const { data: [cartLink], } = await query.graph({
+        entity: "cart_payment_collection",
+        fields: ["cart_id"],
+        filters: {
+            payment_collection_id: collection.metadata?.[exports.CART_PAYMENT_COLLECTION_KEY] ?? collection.id,
+        },
+    });
+    return cartLink?.cart_id;
+};
+exports.resolveSplitOrderCartId = resolveSplitOrderCartId;
+const getCartPayment = (collection) => (collection?.payments ?? []).find((payment) => !payment.canceled_at);
+const getOrderCollection = (order, cartCollectionId) => (order.payment_collections ?? []).find((collection) => collection.metadata?.[exports.CART_PAYMENT_COLLECTION_KEY] === cartCollectionId);
+const EMPTY_PLAN = {
+    collections: [],
+    payments: [],
+    captures: [],
+    recorded: [],
+    refunds: [],
+};
+/**
+ * Works out what is missing for every order of a cart to hold its share of
+ * what the cart payment has captured. Only ever plans the difference, so a
+ * cart that is already split yields an empty plan.
+ */
+const planCartPaymentSplit = (cartCollection, orders) => {
+    const cartPayment = getCartPayment(cartCollection);
+    if (!cartCollection || !cartPayment || !orders.length) {
+        return EMPTY_PLAN;
+    }
+    const captured = sum(cartPayment.captures);
+    if (!utils_1.MathBN.gt(captured, 0)) {
+        return EMPTY_PLAN;
+    }
+    const decimalDigits = (0, split_order_payment_1.getCurrencyDecimalDigits)(cartPayment.currency_code);
+    const weights = orders.map((order) => order.total);
+    // What each order is entitled to of the authorization, and of the part of
+    // it captured so far.
+    const shares = (0, split_order_payment_1.allocateProportionally)({
+        amount: amountOf(cartPayment),
+        weights,
+        decimalDigits,
+    });
+    const targets = (0, split_order_payment_1.allocateProportionally)({
+        amount: captured,
+        weights,
+        decimalDigits,
+    });
+    const plan = {
+        collections: [],
+        payments: [],
+        captures: [],
+        recorded: [],
+        refunds: [],
+    };
+    let attributed = utils_1.MathBN.convert(0);
+    orders.forEach((order, index) => {
+        const collection = getOrderCollection(order, cartCollection.id);
+        const payment = collection?.payments?.[0];
+        const recorded = sum(payment?.captures);
+        const missing = utils_1.MathBN.sub(targets[index], recorded);
+        attributed = utils_1.MathBN.add(attributed, recorded);
+        for (const capture of payment?.captures ?? []) {
+            plan.recorded.push({
+                order_id: order.id,
+                currency_code: cartPayment.currency_code,
+                capture_id: capture.id,
+                amount: amountOf(capture),
+            });
+        }
+        // An order canceled before the capture is not paid: its part of the
+        // charge stays unattributed and is refunded.
+        if ((0, exports.isOrderCanceled)(order) || !utils_1.MathBN.gt(missing, 0)) {
+            return;
+        }
+        if (!collection) {
+            plan.collections.push({
+                order_id: order.id,
+                currency_code: cartPayment.currency_code,
+                amount: shares[index],
+                metadata: { [exports.CART_PAYMENT_COLLECTION_KEY]: cartCollection.id },
+            });
+        }
+        if (!payment) {
+            plan.payments.push({
+                order_id: order.id,
+                payment_collection_id: collection?.id,
+                provider_id: cartPayment.provider_id,
+                currency_code: cartPayment.currency_code,
+                amount: shares[index],
+                data: cartPayment.data ?? {},
+            });
+        }
+        plan.captures.push({
+            order_id: order.id,
+            payment_id: payment?.id,
+            amount: missing,
+        });
+        attributed = utils_1.MathBN.add(attributed, missing);
+    });
+    const unattributed = utils_1.MathBN.sub(captured, attributed, sum(cartPayment.refunds));
+    if (utils_1.MathBN.gt(unattributed, 0)) {
+        plan.refunds.push({
+            payment_id: cartPayment.id,
+            amount: unattributed,
+            note: "Share of orders canceled before the payment was captured",
+        });
+    }
+    if (!(0, exports.hasSplitOrderCollections)(cartCollection)) {
+        plan.cart_payment_collection = {
+            id: cartCollection.id,
+            metadata: {
+                ...cartCollection.metadata,
+                [exports.SPLIT_ORDER_COLLECTIONS_FLAG]: true,
+            },
+        };
+    }
+    return plan;
+};
+exports.planCartPaymentSplit = planCartPaymentSplit;
+/** The links between the orders and the payment collections created for them. */
+const buildOrderPaymentCollectionLinks = (plan, createdCollections) => plan.collections.map((collection, index) => ({
+    [utils_1.Modules.ORDER]: { order_id: collection.order_id },
+    [utils_1.Modules.PAYMENT]: { payment_collection_id: createdCollections[index].id },
+}));
+exports.buildOrderPaymentCollectionLinks = buildOrderPaymentCollectionLinks;
+/**
+ * The cart payment to void: set once every order of the cart is canceled and
+ * nothing of the payment was captured.
+ */
+const planCartPaymentVoid = (cartCollection, orders) => {
+    const cartPayment = getCartPayment(cartCollection);
+    if (!cartCollection ||
+        !cartPayment ||
+        !orders.length ||
+        (0, exports.isPaymentCaptured)(cartPayment) ||
+        !orders.every(exports.isOrderCanceled)) {
+        return { payment_ids: [], payment_collection_ids: [] };
+    }
+    return {
+        payment_ids: [cartPayment.id],
+        payment_collection_ids: [cartCollection.id],
+    };
+};
+exports.planCartPaymentVoid = planCartPaymentVoid;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"split-order-payment-group.js","sourceRoot":"","sources":["../../../../../../src/workflows/payment/utils/split-order-payment-group.ts"],"names":[],"mappings":";;;AAKA,qDAKkC;AAElC,+DAG8B;AAE9B,4EAA4E;AAC/D,QAAA,4BAA4B,GAAG,yBAAyB,CAAA;AAErE,oEAAoE;AACvD,QAAA,2BAA2B,GAAG,4BAA4B,CAAA;AAoCvE,MAAM,cAAc,GAAG;IACrB,IAAI;IACJ,aAAa;IACb,eAAe;IACf,QAAQ;IACR,YAAY;IACZ,MAAM;IACN,aAAa;IACb,aAAa;IACb,aAAa;IACb,iBAAiB;IACjB,qBAAqB;IACrB,YAAY;IACZ,gBAAgB;IAChB,oBAAoB;CACrB,CAAA;AAED,MAAM,iBAAiB,GAAG;IACxB,IAAI;IACJ,eAAe;IACf,UAAU;IACV,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,KAAK,EAAE,CAAC;CACtD,CAAA;AAED,8EAA8E;AACjE,QAAA,2BAA2B,GAAG,iBAAiB,CAAC,GAAG,CAC9D,CAAC,KAAK,EAAE,EAAE,CAAC,sBAAsB,KAAK,EAAE,CACzC,CAAA;AAED,iEAAiE;AACpD,QAAA,eAAe,GAAG;IAC7B,UAAU;IACV,cAAc;IACd,mBAAmB;IACnB,aAAa;IACb,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,6BAA6B,KAAK,EAAE,CAAC;CAC1E,CAAA;AAED,MAAM,QAAQ,GAAG,CAAC,QAGjB,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAU,IAAI,QAAQ,CAAC,MAAM,CAAA;AAE5C,MAAM,GAAG,GAAG,CAAC,SAA+C,EAAE,EAAE,CAC9D,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,MAAM,CACtB,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,cAAM,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,EACtD,cAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAClB,CAAA;AAEI,MAAM,iBAAiB,GAAG,CAAC,OAA+B,EAAE,EAAE,CACnE,CAAC,CAAC,OAAO,CAAC,WAAW,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAA;AADjD,QAAA,iBAAiB,qBACgC;AAEvD,MAAM,eAAe,GAAG,CAAC,KAG/B,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,mBAAW,CAAC,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,WAAW,CAAA;AAHrD,QAAA,eAAe,mBAGsC;AAE3D,MAAM,wBAAwB,GAAG,CACtC,iBAAwE,EACxE,EAAE,CAAC,iBAAiB,EAAE,QAAQ,EAAE,CAAC,oCAA4B,CAAC,KAAK,IAAI,CAAA;AAF5D,QAAA,wBAAwB,4BAEoC;AAEzE;;;;;GAKG;AACI,MAAM,8BAA8B,GAAG,CAAC,KAK9C,EAAa,EAAE;IACd,MAAM,GAAG,GAAG,KAAK,CAAC,mBAAmB,IAAI,EAAE,CAAA;IAC3C,MAAM,qBAAqB,GAAG,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAA;IAE5D,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC3B,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,OAAO,IAAA,gCAAwB,EAAC,qBAAqB,CAAC,IAAI,GAAG,CAAC,MAAM;QAClE,CAAC,CAAC,GAAG;QACL,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAA;AAC7B,CAAC,CAAA;AAhBY,QAAA,8BAA8B,kCAgB1C;AAED;;;GAGG;AACI,MAAM,uBAAuB,GAAG,KAAK,EAC1C,SAA0B,EAC1B,KAAoD,EACvB,EAAE;IAC/B,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,iCAAyB,CAAC,KAAK,CAAC,CAAA;IAEhE,IAAI,UAAU,IAAI,KAAK,EAAE,CAAC;QACxB,MAAM,EACJ,IAAI,EAAE,CAAC,SAAS,CAAC,GAClB,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC;YACpB,MAAM,EAAE,YAAY;YACpB,MAAM,EAAE,CAAC,SAAS,CAAC;YACnB,OAAO,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE;SACtC,CAAC,CAAA;QACF,OAAO,SAAS,EAAE,OAAO,CAAA;IAC3B,CAAC;IAED,MAAM,EACJ,IAAI,EAAE,CAAC,OAAO,CAAC,GAChB,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC;QACpB,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,CAAC,IAAI,EAAE,uBAAuB,EAAE,6BAA6B,CAAC;QACtE,OAAO,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,UAAU,EAAE;KAClC,CAAC,CAAA;IAEF,MAAM,UAAU,GAAG,OAAO,EAAE,kBAEf,CAAA;IAEb,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,MAAM,EACJ,IAAI,EAAE,CAAC,QAAQ,CAAC,GACjB,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC;QACpB,MAAM,EAAE,yBAAyB;QACjC,MAAM,EAAE,CAAC,SAAS,CAAC;QACnB,OAAO,EAAE;YACP,qBAAqB,EAClB,UAAU,CAAC,QAAQ,EAAE,CAAC,mCAA2B,CAEpC,IAAI,UAAU,CAAC,EAAE;SAClC;KACF,CAAC,CAAA;IAEF,OAAO,QAAQ,EAAE,OAAO,CAAA;AAC1B,CAAC,CAAA;AA/CY,QAAA,uBAAuB,2BA+CnC;AAED,MAAM,cAAc,GAAG,CAAC,UAA6C,EAAE,EAAE,CACvE,CAAC,UAAU,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;AAEtE,MAAM,kBAAkB,GAAG,CACzB,KAA2B,EAC3B,gBAAwB,EACxB,EAAE,CACF,CAAC,KAAK,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,IAAI,CACpC,CAAC,UAAU,EAAE,EAAE,CACb,UAAU,CAAC,QAAQ,EAAE,CAAC,mCAA2B,CAAC,KAAK,gBAAgB,CAC1E,CAAA;AAmDH,MAAM,UAAU,GAAyB;IACvC,WAAW,EAAE,EAAE;IACf,QAAQ,EAAE,EAAE;IACZ,QAAQ,EAAE,EAAE;IACZ,QAAQ,EAAE,EAAE;IACZ,OAAO,EAAE,EAAE;CACZ,CAAA;AAED;;;;GAIG;AACI,MAAM,oBAAoB,GAAG,CAClC,cAA4D,EAC5D,MAA8B,EACR,EAAE;IACxB,MAAM,WAAW,GAAG,cAAc,CAAC,cAAc,CAAC,CAAA;IAElD,IAAI,CAAC,cAAc,IAAI,CAAC,WAAW,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACtD,OAAO,UAAU,CAAA;IACnB,CAAC;IAED,MAAM,QAAQ,GAAG,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAA;IAE1C,IAAI,CAAC,cAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC;QAC5B,OAAO,UAAU,CAAA;IACnB,CAAC;IAED,MAAM,aAAa,GAAG,IAAA,8CAAwB,EAAC,WAAW,CAAC,aAAa,CAAC,CAAA;IACzE,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAElD,0EAA0E;IAC1E,sBAAsB;IACtB,MAAM,MAAM,GAAG,IAAA,4CAAsB,EAAC;QACpC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC;QAC7B,OAAO;QACP,aAAa;KACd,CAAC,CAAA;IACF,MAAM,OAAO,GAAG,IAAA,4CAAsB,EAAC;QACrC,MAAM,EAAE,QAAQ;QAChB,OAAO;QACP,aAAa;KACd,CAAC,CAAA;IAEF,MAAM,IAAI,GAAyB;QACjC,WAAW,EAAE,EAAE;QACf,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE,EAAE;KACZ,CAAA;IACD,IAAI,UAAU,GAAG,cAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IAElC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QAC9B,MAAM,UAAU,GAAG,kBAAkB,CAAC,KAAK,EAAE,cAAc,CAAC,EAAE,CAAC,CAAA;QAC/D,MAAM,OAAO,GAAG,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAA;QACzC,MAAM,QAAQ,GAAG,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;QACvC,MAAM,OAAO,GAAG,cAAM,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAA;QAEpD,UAAU,GAAG,cAAM,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;QAE7C,KAAK,MAAM,OAAO,IAAI,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,CAAC;YAC9C,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;gBACjB,QAAQ,EAAE,KAAK,CAAC,EAAE;gBAClB,aAAa,EAAE,WAAW,CAAC,aAAa;gBACxC,UAAU,EAAE,OAAO,CAAC,EAAE;gBACtB,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC;aAC1B,CAAC,CAAA;QACJ,CAAC;QAED,oEAAoE;QACpE,6CAA6C;QAC7C,IAAI,IAAA,uBAAe,EAAC,KAAK,CAAC,IAAI,CAAC,cAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC;YACrD,OAAM;QACR,CAAC;QAED,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;gBACpB,QAAQ,EAAE,KAAK,CAAC,EAAE;gBAClB,aAAa,EAAE,WAAW,CAAC,aAAa;gBACxC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC;gBACrB,QAAQ,EAAE,EAAE,CAAC,mCAA2B,CAAC,EAAE,cAAc,CAAC,EAAE,EAAE;aAC/D,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;gBACjB,QAAQ,EAAE,KAAK,CAAC,EAAE;gBAClB,qBAAqB,EAAE,UAAU,EAAE,EAAE;gBACrC,WAAW,EAAE,WAAW,CAAC,WAAW;gBACpC,aAAa,EAAE,WAAW,CAAC,aAAa;gBACxC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC;gBACrB,IAAI,EAAE,WAAW,CAAC,IAAI,IAAI,EAAE;aAC7B,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,QAAQ,EAAE,KAAK,CAAC,EAAE;YAClB,UAAU,EAAE,OAAO,EAAE,EAAE;YACvB,MAAM,EAAE,OAAO;SAChB,CAAC,CAAA;QACF,UAAU,GAAG,cAAM,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;IAC9C,CAAC,CAAC,CAAA;IAEF,MAAM,YAAY,GAAG,cAAM,CAAC,GAAG,CAC7B,QAAQ,EACR,UAAU,EACV,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,CACzB,CAAA;IAED,IAAI,cAAM,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,CAAC,EAAE,CAAC;QAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,UAAU,EAAE,WAAW,CAAC,EAAE;YAC1B,MAAM,EAAE,YAAY;YACpB,IAAI,EAAE,0DAA0D;SACjE,CAAC,CAAA;IACJ,CAAC;IAED,IAAI,CAAC,IAAA,gCAAwB,EAAC,cAAc,CAAC,EAAE,CAAC;QAC9C,IAAI,CAAC,uBAAuB,GAAG;YAC7B,EAAE,EAAE,cAAc,CAAC,EAAE;YACrB,QAAQ,EAAE;gBACR,GAAG,cAAc,CAAC,QAAQ;gBAC1B,CAAC,oCAA4B,CAAC,EAAE,IAAI;aACrC;SACF,CAAA;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC,CAAA;AArHY,QAAA,oBAAoB,wBAqHhC;AAED,iFAAiF;AAC1E,MAAM,gCAAgC,GAAG,CAC9C,IAA0B,EAC1B,kBAAoC,EAClB,EAAE,CACpB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;IAC3C,CAAC,eAAO,CAAC,KAAK,CAAC,EAAE,EAAE,QAAQ,EAAE,UAAU,CAAC,QAAQ,EAAE;IAClD,CAAC,eAAO,CAAC,OAAO,CAAC,EAAE,EAAE,qBAAqB,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE;CAC3E,CAAC,CAAC,CAAA;AAPQ,QAAA,gCAAgC,oCAOxC;AAEL;;;GAGG;AACI,MAAM,mBAAmB,GAAG,CACjC,cAA4D,EAC5D,MAA8B,EAC+B,EAAE;IAC/D,MAAM,WAAW,GAAG,cAAc,CAAC,cAAc,CAAC,CAAA;IAElD,IACE,CAAC,cAAc;QACf,CAAC,WAAW;QACZ,CAAC,MAAM,CAAC,MAAM;QACd,IAAA,yBAAiB,EAAC,WAAW,CAAC;QAC9B,CAAC,MAAM,CAAC,KAAK,CAAC,uBAAe,CAAC,EAC9B,CAAC;QACD,OAAO,EAAE,WAAW,EAAE,EAAE,EAAE,sBAAsB,EAAE,EAAE,EAAE,CAAA;IACxD,CAAC;IAED,OAAO;QACL,WAAW,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC;QAC7B,sBAAsB,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC;KAC5C,CAAA;AACH,CAAC,CAAA;AApBY,QAAA,mBAAmB,uBAoB/B"}

package/.medusa/server/src/workflows/payment/utils/split-order-payment.d.ts

@@ -0,0 +1,15 @@
+import { BigNumberInput } from "@medusajs/framework/types";
+import { MathBN } from "@medusajs/framework/utils";
+type BigNumberValue = ReturnType<typeof MathBN.convert>;
+export declare const getCurrencyDecimalDigits: (currencyCode?: string | null) => number;
+/**
+ * Splits `amount` across `weights` proportionally. Shares are rounded down to
+ * the currency precision and the remainder is handed out one minor unit at a
+ * time to the largest fractions, so the shares always sum exactly to `amount`.
+ */
+export declare const allocateProportionally: ({ amount, weights, decimalDigits, }: {
+    amount: BigNumberInput;
+    weights: BigNumberInput[];
+    decimalDigits: number;
+}) => BigNumberValue[];
+export {};

package/.medusa/server/src/workflows/payment/utils/split-order-payment.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allocateProportionally = exports.getCurrencyDecimalDigits = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const DEFAULT_DECIMAL_DIGITS = 2;
+const getCurrencyDecimalDigits = (currencyCode) => {
+    const currency = utils_1.defaultCurrencies[(currencyCode ?? "").toUpperCase()];
+    return currency?.decimal_digits ?? DEFAULT_DECIMAL_DIGITS;
+};
+exports.getCurrencyDecimalDigits = getCurrencyDecimalDigits;
+const floorTo = (value, decimalDigits) => {
+    const rounded = utils_1.MathBN.convert(value, decimalDigits);
+    if (utils_1.MathBN.lte(rounded, value)) {
+        return rounded;
+    }
+    return utils_1.MathBN.sub(rounded, utils_1.MathBN.div(1, utils_1.MathBN.convert(10).pow(decimalDigits)));
+};
+/**
+ * Splits `amount` across `weights` proportionally. Shares are rounded down to
+ * the currency precision and the remainder is handed out one minor unit at a
+ * time to the largest fractions, so the shares always sum exactly to `amount`.
+ */
+const allocateProportionally = ({ amount, weights, decimalDigits, }) => {
+    if (!weights.length) {
+        return [];
+    }
+    const total = utils_1.MathBN.convert(amount);
+    const positiveWeights = weights.map((weight) => utils_1.MathBN.max(utils_1.MathBN.convert(weight), 0));
+    const weightSum = positiveWeights.reduce((acc, weight) => utils_1.MathBN.add(acc, weight), utils_1.MathBN.convert(0));
+    const effectiveWeights = utils_1.MathBN.gt(weightSum, 0)
+        ? positiveWeights
+        : positiveWeights.map(() => utils_1.MathBN.convert(1));
+    const effectiveSum = utils_1.MathBN.gt(weightSum, 0)
+        ? weightSum
+        : utils_1.MathBN.convert(effectiveWeights.length);
+    const unit = utils_1.MathBN.div(1, utils_1.MathBN.convert(10).pow(decimalDigits));
+    const exact = effectiveWeights.map((weight) => utils_1.MathBN.div(utils_1.MathBN.mult(total, weight), effectiveSum));
+    const shares = exact.map((share) => floorTo(share, decimalDigits));
+    let leftover = utils_1.MathBN.sub(total, shares.reduce((acc, share) => utils_1.MathBN.add(acc, share), utils_1.MathBN.convert(0)));
+    const byLargestFraction = exact
+        .map((share, index) => ({
+        index,
+        fraction: utils_1.MathBN.sub(share, shares[index]),
+    }))
+        .sort((a, b) => utils_1.MathBN.eq(a.fraction, b.fraction)
+        ? a.index - b.index
+        : utils_1.MathBN.gt(a.fraction, b.fraction)
+            ? -1
+            : 1);
+    for (const { index } of byLargestFraction) {
+        if (utils_1.MathBN.lt(leftover, unit)) {
+            break;
+        }
+        shares[index] = utils_1.MathBN.add(shares[index], unit);
+        leftover = utils_1.MathBN.sub(leftover, unit);
+    }
+    // Only reachable when `amount` itself is finer than the currency precision.
+    if (utils_1.MathBN.gt(leftover, 0)) {
+        const { index } = byLargestFraction[0];
+        shares[index] = utils_1.MathBN.add(shares[index], leftover);
+    }
+    return shares;
+};
+exports.allocateProportionally = allocateProportionally;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BsaXQtb3JkZXItcGF5bWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3MvcGF5bWVudC91dGlscy9zcGxpdC1vcmRlci1wYXltZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLHFEQUFxRTtBQUlyRSxNQUFNLHNCQUFzQixHQUFHLENBQUMsQ0FBQTtBQUV6QixNQUFNLHdCQUF3QixHQUFHLENBQUMsWUFBNEIsRUFBRSxFQUFFO0lBQ3ZFLE1BQU0sUUFBUSxHQUFHLHlCQUFpQixDQUFDLENBQUMsWUFBWSxJQUFJLEVBQUUsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUE7SUFDdEUsT0FBTyxRQUFRLEVBQUUsY0FBYyxJQUFJLHNCQUFzQixDQUFBO0FBQzNELENBQUMsQ0FBQTtBQUhZLFFBQUEsd0JBQXdCLDRCQUdwQztBQUVELE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBcUIsRUFBRSxhQUFxQixFQUFFLEVBQUU7SUFDL0QsTUFBTSxPQUFPLEdBQUcsY0FBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsYUFBYSxDQUFDLENBQUE7SUFDcEQsSUFBSSxjQUFNLENBQUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQy9CLE9BQU8sT0FBTyxDQUFBO0lBQ2hCLENBQUM7SUFDRCxPQUFPLGNBQU0sQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLGNBQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLGNBQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQUNsRixDQUFDLENBQUE7QUFFRDs7OztHQUlHO0FBQ0ksTUFBTSxzQkFBc0IsR0FBRyxDQUFDLEVBQ3JDLE1BQU0sRUFDTixPQUFPLEVBQ1AsYUFBYSxHQUtkLEVBQW9CLEVBQUU7SUFDckIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNwQixPQUFPLEVBQUUsQ0FBQTtJQUNYLENBQUM7SUFFRCxNQUFNLEtBQUssR0FBRyxjQUFNLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBQ3BDLE1BQU0sZUFBZSxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUM3QyxjQUFNLENBQUMsR0FBRyxDQUFDLGNBQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQ3RDLENBQUE7SUFDRCxNQUFNLFNBQVMsR0FBRyxlQUFlLENBQUMsTUFBTSxDQUN0QyxDQUFDLEdBQUcsRUFBRSxNQUFNLEVBQUUsRUFBRSxDQUFDLGNBQU0sQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxFQUN4QyxjQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUNsQixDQUFBO0lBQ0QsTUFBTSxnQkFBZ0IsR0FBRyxjQUFNLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7UUFDOUMsQ0FBQyxDQUFDLGVBQWU7UUFDakIsQ0FBQyxDQUFDLGVBQWUsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsY0FBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ2hELE1BQU0sWUFBWSxHQUFHLGNBQU0sQ0FBQyxFQUFFLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FBQztRQUMxQyxDQUFDLENBQUMsU0FBUztRQUNYLENBQUMsQ0FBQyxjQUFNLENBQUMsT0FBTyxDQUFDLGdCQUFnQixDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBRTNDLE1BQU0sSUFBSSxHQUFHLGNBQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLGNBQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUE7SUFDakUsTUFBTSxLQUFLLEdBQUcsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FDNUMsY0FBTSxDQUFDLEdBQUcsQ0FBQyxjQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsRUFBRSxZQUFZLENBQUMsQ0FDckQsQ0FBQTtJQUNELE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsYUFBYSxDQUFDLENBQUMsQ0FBQTtJQUVsRSxJQUFJLFFBQVEsR0FBRyxjQUFNLENBQUMsR0FBRyxDQUN2QixLQUFLLEVBQ0wsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDLGNBQU0sQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxFQUFFLGNBQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FDekUsQ0FBQTtJQUVELE1BQU0saUJBQWlCLEdBQUcsS0FBSztTQUM1QixHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3RCLEtBQUs7UUFDTCxRQUFRLEVBQUUsY0FBTSxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO0tBQzNDLENBQUMsQ0FBQztTQUNGLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUNiLGNBQU0sQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsUUFBUSxDQUFDO1FBQy9CLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxLQUFLO1FBQ25CLENBQUMsQ0FBQyxjQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDLFFBQVEsQ0FBQztZQUNuQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ0osQ0FBQyxDQUFDLENBQUMsQ0FDTixDQUFBO0lBRUgsS0FBSyxNQUFNLEVBQUUsS0FBSyxFQUFFLElBQUksaUJBQWlCLEVBQUUsQ0FBQztRQUMxQyxJQUFJLGNBQU0sQ0FBQyxFQUFFLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDOUIsTUFBSztRQUNQLENBQUM7UUFDRCxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsY0FBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUE7UUFDL0MsUUFBUSxHQUFHLGNBQU0sQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFBO0lBQ3ZDLENBQUM7SUFFRCw0RUFBNEU7SUFDNUUsSUFBSSxjQUFNLENBQUMsRUFBRSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQzNCLE1BQU0sRUFBRSxLQUFLLEVBQUUsR0FBRyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUN0QyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsY0FBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsUUFBUSxDQUFDLENBQUE7SUFDckQsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFBO0FBQ2YsQ0FBQyxDQUFBO0FBbkVZLFFBQUEsc0JBQXNCLDBCQW1FbEMifQ==

package/.medusa/server/src/workflows/payment/workflows/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./process-payment";
 export * from "./payment-hooks";
+export * from "./split-order-payments";

package/.medusa/server/src/workflows/payment/workflows/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./process-payment"), exports);
 __exportStar(require("./payment-hooks"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3BheW1lbnQvd29ya2Zsb3dzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxvREFBaUM7QUFDakMsa0RBQStCIn0=
+__exportStar(require("./split-order-payments"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3BheW1lbnQvd29ya2Zsb3dzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxvREFBaUM7QUFDakMsa0RBQStCO0FBQy9CLHlEQUFzQyJ9

package/.medusa/server/src/workflows/payment/workflows/split-order-payments.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The cart whose payment to split.
+ */
+export type SplitCapturedCartPaymentWorkflowInput = {
+    /**
+     * The ID of the cart.
+     */
+    cart_id: string;
+};
+export declare const splitCapturedCartPaymentWorkflowId = "split-captured-cart-payment";
+/**
+ * This workflow splits a captured cart payment between the orders of the
+ * cart. Every order gets a payment collection of its own, linked to the order,
+ * with a captured payment for the order's share on the cart payment's provider
+ * and pointing at the same charge, so Medusa's refund and cancel workflows
+ * apply to the order. What was charged for orders canceled before the capture
+ * is refunded against the cart payment.
+ *
+ * The workflow only adds what is missing: it does nothing until the cart
+ * payment has a capture, and nothing when run again for the same capture.
+ *
+ * @example
+ * const { result } = await splitCapturedCartPaymentWorkflow(container)
+ * .run({
+ *   input: {
+ *     cart_id: "cart_123",
+ *   }
+ * })
+ *
+ * @summary
+ *
+ * Split a captured cart payment into a payment per order.
+ */
+export declare const splitCapturedCartPaymentWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<SplitCapturedCartPaymentWorkflowInput, import("@medusajs/types").PaymentDTO[], []>;
+/**
+ * The cart whose payment to void.
+ */
+export type VoidCanceledCartPaymentWorkflowInput = {
+    /**
+     * The ID of the cart.
+     */
+    cart_id: string;
+};
+export declare const voidCanceledCartPaymentWorkflowId = "void-canceled-cart-payment";
+/**
+ * This workflow voids a cart's payment once every order of the cart is
+ * canceled. Until it is captured, the authorization is shared by the cart's
+ * orders, so canceling a single order leaves it in place. The workflow does
+ * nothing while an order is still open or once the payment is captured.
+ *
+ * @example
+ * const { result } = await voidCanceledCartPaymentWorkflow(container)
+ * .run({
+ *   input: {
+ *     cart_id: "cart_123",
+ *   }
+ * })
+ *
+ * @summary
+ *
+ * Void a cart's payment when all of its orders are canceled.
+ */
+export declare const voidCanceledCartPaymentWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<VoidCanceledCartPaymentWorkflowInput, {
+    payment_ids: string[];
+    payment_collection_ids: string[];
+}, []>;

package/.medusa/server/src/workflows/payment/workflows/split-order-payments.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.voidCanceledCartPaymentWorkflow = exports.voidCanceledCartPaymentWorkflowId = exports.splitCapturedCartPaymentWorkflow = exports.splitCapturedCartPaymentWorkflowId = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const create_order_payments_1 = require("../steps/create-order-payments");
+const record_payment_captures_1 = require("../steps/record-payment-captures");
+const utils_2 = require("../utils");
+const LOCK_TIMEOUT_SECONDS = 30;
+const LOCK_TTL_SECONDS = 120;
+const toOrders = (links) => links.flatMap((link) => link.order ?? []);
+exports.splitCapturedCartPaymentWorkflowId = "split-captured-cart-payment";
+/**
+ * This workflow splits a captured cart payment between the orders of the
+ * cart. Every order gets a payment collection of its own, linked to the order,
+ * with a captured payment for the order's share on the cart payment's provider
+ * and pointing at the same charge, so Medusa's refund and cancel workflows
+ * apply to the order. What was charged for orders canceled before the capture
+ * is refunded against the cart payment.
+ *
+ * The workflow only adds what is missing: it does nothing until the cart
+ * payment has a capture, and nothing when run again for the same capture.
+ *
+ * @example
+ * const { result } = await splitCapturedCartPaymentWorkflow(container)
+ * .run({
+ *   input: {
+ *     cart_id: "cart_123",
+ *   }
+ * })
+ *
+ * @summary
+ *
+ * Split a captured cart payment into a payment per order.
+ */
+exports.splitCapturedCartPaymentWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.splitCapturedCartPaymentWorkflowId, (input) => {
+    // Not the cart id itself: checkout holds that lock while it runs this
+    // workflow as a step.
+    const lockKey = (0, workflows_sdk_1.transform)({ input }, ({ input }) => `split-order-payment:${input.cart_id}`);
+    (0, core_flows_1.acquireLockStep)({
+        key: lockKey,
+        timeout: LOCK_TIMEOUT_SECONDS,
+        ttl: LOCK_TTL_SECONDS,
+    });
+    const cartPaymentQuery = (0, core_flows_1.useQueryGraphStep)({
+        entity: "cart_payment_collection",
+        fields: utils_2.cartPaymentCollectionFields,
+        filters: { cart_id: input.cart_id },
+    }).config({ name: "get-cart-payment-collection" });
+    const cartOrdersQuery = (0, core_flows_1.useQueryGraphStep)({
+        entity: "order_cart",
+        fields: utils_2.cartOrderFields,
+        filters: { cart_id: input.cart_id },
+    }).config({ name: "get-cart-orders" });
+    const plan = (0, workflows_sdk_1.transform)({ cartPaymentQuery, cartOrdersQuery }, ({ cartPaymentQuery, cartOrdersQuery }) => (0, utils_2.planCartPaymentSplit)(cartPaymentQuery.data[0]
+        ?.payment_collection, toOrders(cartOrdersQuery.data)));
+    const collections = (0, core_flows_1.createPaymentCollectionsStep)(plan.collections);
+    const links = (0, workflows_sdk_1.transform)({ plan, collections }, ({ plan, collections }) => (0, utils_2.buildOrderPaymentCollectionLinks)(plan, collections));
+    (0, core_flows_1.createRemoteLinkStep)(links).config({
+        name: "link-order-payment-collections",
+    });
+    const paymentsToCreate = (0, workflows_sdk_1.transform)({ plan, collections }, ({ plan, collections }) => {
+        const createdByOrder = new Map(plan.collections.map((collection, index) => [
+            collection.order_id,
+            collections[index].id,
+        ]));
+        return plan.payments.map(({ order_id, ...payment }) => ({
+            ...payment,
+            payment_collection_id: payment.payment_collection_id ??
+                createdByOrder.get(order_id),
+        }));
+    });
+    const payments = (0, create_order_payments_1.createOrderPaymentsStep)(paymentsToCreate);
+    const capturesToRecord = (0, workflows_sdk_1.transform)({ plan, payments }, ({ plan, payments }) => {
+        const createdByOrder = new Map(plan.payments.map((payment, index) => [
+            payment.order_id,
+            payments[index].id,
+        ]));
+        return plan.captures.map((capture) => ({
+            payment_id: capture.payment_id ??
+                createdByOrder.get(capture.order_id),
+            amount: capture.amount,
+        }));
+    });
+    const capturedPayments = (0, record_payment_captures_1.recordPaymentCapturesStep)(capturesToRecord);
+    const orderTransactions = (0, workflows_sdk_1.transform)({ plan, capturedPayments }, ({ plan, capturedPayments }) => [
+        ...plan.recorded.map((capture) => ({
+            order_id: capture.order_id,
+            amount: capture.amount,
+            currency_code: capture.currency_code,
+            reference: "capture",
+            reference_id: capture.capture_id,
+        })),
+        ...capturedPayments.flatMap((payment, index) => (payment.captures ?? []).map((capture) => ({
+            order_id: plan.captures[index].order_id,
+            amount: capture.raw_amount ?? capture.amount,
+            currency_code: payment.currency_code,
+            reference: "capture",
+            reference_id: capture.id,
+        }))),
+    ]);
+    (0, core_flows_1.addOrderTransactionStep)(orderTransactions);
+    (0, workflows_sdk_1.when)("flag-cart-payment-collection", { plan }, ({ plan }) => {
+        return !!plan.cart_payment_collection;
+    }).then(() => {
+        (0, core_flows_1.updatePaymentCollectionStep)({
+            selector: { id: plan.cart_payment_collection.id },
+            update: { metadata: plan.cart_payment_collection.metadata },
+        });
+    });
+    (0, core_flows_1.refundPaymentsStep)(plan.refunds);
+    const capturedEvents = (0, workflows_sdk_1.transform)({ capturedPayments }, ({ capturedPayments }) => capturedPayments.map((payment) => ({ id: payment.id })));
+    (0, core_flows_1.emitEventStep)({
+        eventName: utils_1.PaymentEvents.CAPTURED,
+        data: capturedEvents,
+    });
+    (0, core_flows_1.releaseLockStep)({ key: lockKey });
+    return new workflows_sdk_1.WorkflowResponse(capturedPayments);
+});
+exports.voidCanceledCartPaymentWorkflowId = "void-canceled-cart-payment";
+/**
+ * This workflow voids a cart's payment once every order of the cart is
+ * canceled. Until it is captured, the authorization is shared by the cart's
+ * orders, so canceling a single order leaves it in place. The workflow does
+ * nothing while an order is still open or once the payment is captured.
+ *
+ * @example
+ * const { result } = await voidCanceledCartPaymentWorkflow(container)
+ * .run({
+ *   input: {
+ *     cart_id: "cart_123",
+ *   }
+ * })
+ *
+ * @summary
+ *
+ * Void a cart's payment when all of its orders are canceled.
+ */
+exports.voidCanceledCartPaymentWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.voidCanceledCartPaymentWorkflowId, (input) => {
+    const cartPaymentQuery = (0, core_flows_1.useQueryGraphStep)({
+        entity: "cart_payment_collection",
+        fields: utils_2.cartPaymentCollectionFields,
+        filters: { cart_id: input.cart_id },
+    }).config({ name: "get-cart-payment-collection" });
+    const cartOrdersQuery = (0, core_flows_1.useQueryGraphStep)({
+        entity: "order_cart",
+        fields: utils_2.cartOrderFields,
+        filters: { cart_id: input.cart_id },
+    }).config({ name: "get-cart-orders" });
+    const plan = (0, workflows_sdk_1.transform)({ cartPaymentQuery, cartOrdersQuery }, ({ cartPaymentQuery, cartOrdersQuery }) => (0, utils_2.planCartPaymentVoid)(cartPaymentQuery.data[0]
+        ?.payment_collection, toOrders(cartOrdersQuery.data)));
+    (0, core_flows_1.cancelPaymentStep)({ paymentIds: plan.payment_ids });
+    (0, workflows_sdk_1.when)("cancel-cart-payment-collection", { plan }, ({ plan }) => {
+        return plan.payment_collection_ids.length > 0;
+    }).then(() => {
+        (0, core_flows_1.updatePaymentCollectionStep)({
+            selector: { id: plan.payment_collection_ids },
+            update: { status: utils_1.PaymentCollectionStatus.CANCELED },
+        });
+    });
+    return new workflows_sdk_1.WorkflowResponse(plan);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BsaXQtb3JkZXItcGF5bWVudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3BheW1lbnQvd29ya2Zsb3dzL3NwbGl0LW9yZGVyLXBheW1lbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFEQUFrRjtBQUNsRixxRUFLMEM7QUFDMUMsNERBV29DO0FBRXBDLDBFQUF3RTtBQUN4RSw4RUFBNEU7QUFDNUUsb0NBUWlCO0FBWWpCLE1BQU0sb0JBQW9CLEdBQUcsRUFBRSxDQUFBO0FBQy9CLE1BQU0sZ0JBQWdCLEdBQUcsR0FBRyxDQUFBO0FBUTVCLE1BQU0sUUFBUSxHQUFHLENBQUMsS0FBc0IsRUFBRSxFQUFFLENBQzFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLElBQUksRUFBRSxDQUFDLENBQUE7QUFFOUIsUUFBQSxrQ0FBa0MsR0FBRyw2QkFBNkIsQ0FBQTtBQUMvRTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUNVLFFBQUEsZ0NBQWdDLEdBQUcsSUFBQSw4QkFBYyxFQUM1RCwwQ0FBa0MsRUFDbEMsQ0FBQyxLQUE0QyxFQUFFLEVBQUU7SUFDL0Msc0VBQXNFO0lBQ3RFLHNCQUFzQjtJQUN0QixNQUFNLE9BQU8sR0FBRyxJQUFBLHlCQUFTLEVBQ3ZCLEVBQUUsS0FBSyxFQUFFLEVBQ1QsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsQ0FBQyx1QkFBdUIsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUN0RCxDQUFBO0lBRUQsSUFBQSw0QkFBZSxFQUFDO1FBQ2QsR0FBRyxFQUFFLE9BQU87UUFDWixPQUFPLEVBQUUsb0JBQW9CO1FBQzdCLEdBQUcsRUFBRSxnQkFBZ0I7S0FDdEIsQ0FBQyxDQUFBO0lBRUYsTUFBTSxnQkFBZ0IsR0FBRyxJQUFBLDhCQUFpQixFQUFDO1FBQ3pDLE1BQU0sRUFBRSx5QkFBeUI7UUFDakMsTUFBTSxFQUFFLG1DQUEyQjtRQUNuQyxPQUFPLEVBQUUsRUFBRSxPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU8sRUFBRTtLQUNwQyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsSUFBSSxFQUFFLDZCQUE2QixFQUFFLENBQUMsQ0FBQTtJQUVsRCxNQUFNLGVBQWUsR0FBRyxJQUFBLDhCQUFpQixFQUFDO1FBQ3hDLE1BQU0sRUFBRSxZQUFZO1FBQ3BCLE1BQU0sRUFBRSx1QkFBZTtRQUN2QixPQUFPLEVBQUUsRUFBRSxPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU8sRUFBRTtLQUNwQyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsSUFBSSxFQUFFLGlCQUFpQixFQUFFLENBQUMsQ0FBQTtJQUV0QyxNQUFNLElBQUksR0FBRyxJQUFBLHlCQUFTLEVBQ3BCLEVBQUUsZ0JBQWdCLEVBQUUsZUFBZSxFQUFFLEVBQ3JDLENBQUMsRUFBRSxnQkFBZ0IsRUFBRSxlQUFlLEVBQUUsRUFBRSxFQUFFLENBQ3hDLElBQUEsNEJBQW9CLEVBQ2pCLGdCQUFnQixDQUFDLElBQUksQ0FBQyxDQUFDLENBQTJDO1FBQ2pFLEVBQUUsa0JBQWtCLEVBQ3RCLFFBQVEsQ0FBQyxlQUFlLENBQUMsSUFBdUIsQ0FBQyxDQUNsRCxDQUNKLENBQUE7SUFFRCxNQUFNLFdBQVcsR0FBRyxJQUFBLHlDQUE0QixFQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQTtJQUVsRSxNQUFNLEtBQUssR0FBRyxJQUFBLHlCQUFTLEVBQUMsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsRUFBRSxFQUFFLENBQ3ZFLElBQUEsd0NBQWdDLEVBQUMsSUFBSSxFQUFFLFdBQVcsQ0FBQyxDQUNwRCxDQUFBO0lBRUQsSUFBQSxpQ0FBb0IsRUFBQyxLQUFLLENBQUMsQ0FBQyxNQUFNLENBQUM7UUFDakMsSUFBSSxFQUFFLGdDQUFnQztLQUN2QyxDQUFDLENBQUE7SUFFRixNQUFNLGdCQUFnQixHQUFHLElBQUEseUJBQVMsRUFDaEMsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLEVBQ3JCLENBQUMsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLEVBQUUsRUFBRTtRQUN4QixNQUFNLGNBQWMsR0FBRyxJQUFJLEdBQUcsQ0FDNUIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxVQUFVLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQztZQUMxQyxVQUFVLENBQUMsUUFBUTtZQUNuQixXQUFXLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRTtTQUN0QixDQUFDLENBQ0gsQ0FBQTtRQUVELE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLFFBQVEsRUFBRSxHQUFHLE9BQU8sRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1lBQ3RELEdBQUcsT0FBTztZQUNWLHFCQUFxQixFQUNuQixPQUFPLENBQUMscUJBQXFCO2dCQUM1QixjQUFjLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBWTtTQUMzQyxDQUFDLENBQUMsQ0FBQTtJQUNMLENBQUMsQ0FDRixDQUFBO0lBRUQsTUFBTSxRQUFRLEdBQUcsSUFBQSwrQ0FBdUIsRUFBQyxnQkFBZ0IsQ0FBQyxDQUFBO0lBRTFELE1BQU0sZ0JBQWdCLEdBQUcsSUFBQSx5QkFBUyxFQUNoQyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsRUFDbEIsQ0FBQyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFO1FBQ3JCLE1BQU0sY0FBYyxHQUFHLElBQUksR0FBRyxDQUM1QixJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDO1lBQ3BDLE9BQU8sQ0FBQyxRQUFRO1lBQ2hCLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFO1NBQ25CLENBQUMsQ0FDSCxDQUFBO1FBRUQsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQztZQUNyQyxVQUFVLEVBQ1IsT0FBTyxDQUFDLFVBQVU7Z0JBQ2pCLGNBQWMsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBWTtZQUNsRCxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU07U0FDdkIsQ0FBQyxDQUFDLENBQUE7SUFDTCxDQUFDLENBQ0YsQ0FBQTtJQUVELE1BQU0sZ0JBQWdCLEdBQUcsSUFBQSxtREFBeUIsRUFBQyxnQkFBZ0IsQ0FBQyxDQUFBO0lBRXBFLE1BQU0saUJBQWlCLEdBQUcsSUFBQSx5QkFBUyxFQUNqQyxFQUFFLElBQUksRUFBRSxnQkFBZ0IsRUFBRSxFQUMxQixDQUFDLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFLEVBQUUsRUFBRSxDQUFDO1FBQzlCLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLENBQUM7WUFDakMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxRQUFRO1lBQzFCLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTTtZQUN0QixhQUFhLEVBQUUsT0FBTyxDQUFDLGFBQWE7WUFDcEMsU0FBUyxFQUFFLFNBQVM7WUFDcEIsWUFBWSxFQUFFLE9BQU8sQ0FBQyxVQUFVO1NBQ2pDLENBQUMsQ0FBQztRQUNILEdBQUcsZ0JBQWdCLENBQUMsT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEtBQUssRUFBRSxFQUFFLENBQzdDLENBQUMsT0FBTyxDQUFDLFFBQVEsSUFBSSxFQUFFLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLENBQUM7WUFDekMsUUFBUSxFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUMsUUFBUTtZQUN2QyxNQUFNLEVBQUUsT0FBTyxDQUFDLFVBQVUsSUFBSSxPQUFPLENBQUMsTUFBTTtZQUM1QyxhQUFhLEVBQUUsT0FBTyxDQUFDLGFBQWE7WUFDcEMsU0FBUyxFQUFFLFNBQVM7WUFDcEIsWUFBWSxFQUFFLE9BQU8sQ0FBQyxFQUFFO1NBQ3pCLENBQUMsQ0FBQyxDQUNKO0tBQ0YsQ0FDRixDQUFBO0lBRUQsSUFBQSxvQ0FBdUIsRUFBQyxpQkFBaUIsQ0FBQyxDQUFBO0lBRTFDLElBQUEsb0JBQUksRUFBQyw4QkFBOEIsRUFBRSxFQUFFLElBQUksRUFBRSxFQUFFLENBQUMsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFO1FBQzFELE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyx1QkFBdUIsQ0FBQTtJQUN2QyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFO1FBQ1gsSUFBQSx3Q0FBMkIsRUFBQztZQUMxQixRQUFRLEVBQUUsRUFBRSxFQUFFLEVBQUUsSUFBSSxDQUFDLHVCQUF3QixDQUFDLEVBQUUsRUFBRTtZQUNsRCxNQUFNLEVBQUUsRUFBRSxRQUFRLEVBQUUsSUFBSSxDQUFDLHVCQUF3QixDQUFDLFFBQVEsRUFBRTtTQUM3RCxDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtJQUVGLElBQUEsK0JBQWtCLEVBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFBO0lBRWhDLE1BQU0sY0FBYyxHQUFHLElBQUEseUJBQVMsRUFDOUIsRUFBRSxnQkFBZ0IsRUFBRSxFQUNwQixDQUFDLEVBQUUsZ0JBQWdCLEVBQUUsRUFBRSxFQUFFLENBQ3ZCLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxPQUFPLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUMxRCxDQUFBO0lBRUQsSUFBQSwwQkFBYSxFQUFDO1FBQ1osU0FBUyxFQUFFLHFCQUFhLENBQUMsUUFBUTtRQUNqQyxJQUFJLEVBQUUsY0FBYztLQUNyQixDQUFDLENBQUE7SUFFRixJQUFBLDRCQUFlLEVBQUMsRUFBRSxHQUFHLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQTtJQUVqQyxPQUFPLElBQUksZ0NBQWdCLENBQUMsZ0JBQWdCLENBQUMsQ0FBQTtBQUMvQyxDQUFDLENBQ0YsQ0FBQTtBQVlZLFFBQUEsaUNBQWlDLEdBQUcsNEJBQTRCLENBQUE7QUFDN0U7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBQ1UsUUFBQSwrQkFBK0IsR0FBRyxJQUFBLDhCQUFjLEVBQzNELHlDQUFpQyxFQUNqQyxDQUFDLEtBQTJDLEVBQUUsRUFBRTtJQUM5QyxNQUFNLGdCQUFnQixHQUFHLElBQUEsOEJBQWlCLEVBQUM7UUFDekMsTUFBTSxFQUFFLHlCQUF5QjtRQUNqQyxNQUFNLEVBQUUsbUNBQTJCO1FBQ25DLE9BQU8sRUFBRSxFQUFFLE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTyxFQUFFO0tBQ3BDLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxJQUFJLEVBQUUsNkJBQTZCLEVBQUUsQ0FBQyxDQUFBO0lBRWxELE1BQU0sZUFBZSxHQUFHLElBQUEsOEJBQWlCLEVBQUM7UUFDeEMsTUFBTSxFQUFFLFlBQVk7UUFDcEIsTUFBTSxFQUFFLHVCQUFlO1FBQ3ZCLE9BQU8sRUFBRSxFQUFFLE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTyxFQUFFO0tBQ3BDLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxJQUFJLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyxDQUFBO0lBRXRDLE1BQU0sSUFBSSxHQUFHLElBQUEseUJBQVMsRUFDcEIsRUFBRSxnQkFBZ0IsRUFBRSxlQUFlLEVBQUUsRUFDckMsQ0FBQyxFQUFFLGdCQUFnQixFQUFFLGVBQWUsRUFBRSxFQUFFLEVBQUUsQ0FDeEMsSUFBQSwyQkFBbUIsRUFDaEIsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBMkM7UUFDakUsRUFBRSxrQkFBa0IsRUFDdEIsUUFBUSxDQUFDLGVBQWUsQ0FBQyxJQUF1QixDQUFDLENBQ2xELENBQ0osQ0FBQTtJQUVELElBQUEsOEJBQWlCLEVBQUMsRUFBRSxVQUFVLEVBQUUsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUE7SUFFbkQsSUFBQSxvQkFBSSxFQUFDLGdDQUFnQyxFQUFFLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUU7UUFDNUQsT0FBTyxJQUFJLENBQUMsc0JBQXNCLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQTtJQUMvQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFO1FBQ1gsSUFBQSx3Q0FBMkIsRUFBQztZQUMxQixRQUFRLEVBQUUsRUFBRSxFQUFFLEVBQUUsSUFBSSxDQUFDLHNCQUFzQixFQUFFO1lBQzdDLE1BQU0sRUFBRSxFQUFFLE1BQU0sRUFBRSwrQkFBdUIsQ0FBQyxRQUFRLEVBQUU7U0FDckQsQ0FBQyxDQUFBO0lBQ0osQ0FBQyxDQUFDLENBQUE7SUFFRixPQUFPLElBQUksZ0NBQWdCLENBQUMsSUFBSSxDQUFDLENBQUE7QUFDbkMsQ0FBQyxDQUNGLENBQUEifQ==

package/.medusa/server/src/workflows/payout/workflows/create-payout.d.ts

@@ -2,5 +2,8 @@ type CreatePayoutWorkflowInput = {
     order_id: string;
 };
 export declare const createPayoutWorkflowId = "create-payout";
-export declare const createPayoutWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<CreatePayoutWorkflowInput, import("@mercurjs/types").PayoutDTO, []>;
+export declare const createPayoutWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<CreatePayoutWorkflowInput, import("@mercurjs/types").PayoutDTO, [import("@medusajs/framework/workflows-sdk").Hook<"payoutCreated", {
+    order_id: string;
+    payout_id: string;
+}, unknown>]>;
 export {};

package/.medusa/server/src/workflows/payout/workflows/create-payout.js

@@ -78,6 +78,10 @@ exports.createPayoutWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.creat
             },
         },
     ]);
-    return new workflows_sdk_1.WorkflowResponse(payout);
+    const payoutCreated = (0, workflows_sdk_1.createHook)("payoutCreated", {
+        order_id: input.order_id,
+        payout_id: payout.id,
+    });
+    return new workflows_sdk_1.WorkflowResponse(payout, { hooks: [payoutCreated] });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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