@shushed/helpers 0.0.203-bug-erp-770-20251208112219 → 0.0.203-bug-erp-770-20251208155555

package/dist/cjs/src-public/bcOrder.js

@@ -0,0 +1,1275 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BCOrderHelper = void 0;
+exports.buildLineGrouping = buildLineGrouping;
+exports.transformMasterOrder = transformMasterOrder;
+exports.validateOrder = validateOrder;
+const order_schema_json_1 = __importDefault(require("../contracts/order.schema.json"));
+const runtime_1 = __importDefault(require("./runtime"));
+const validate_1 = __importDefault(require("./validate"));
+const GBP = "GBP";
+function toMinorUnits(amount) {
+    if (typeof amount !== "number" || !isFinite(amount))
+        return 0;
+    if (Math.abs(amount) > Number.MAX_SAFE_INTEGER / 100) {
+        return Math.round(Number((amount * 100).toPrecision(15)));
+    }
+    return Math.round(amount * 100);
+}
+function money(value) {
+    const v = toMinorUnits(value);
+    return {
+        value: v,
+        currency: GBP,
+        decimal_places: 2,
+        lcy_value: v,
+        lcy_currency: GBP,
+        lcy_decimal_places: 2,
+    };
+}
+function moneyFromMinor(minor) {
+    return {
+        value: Math.round(minor),
+        currency: GBP,
+        decimal_places: 2,
+        lcy_value: Math.round(minor),
+        lcy_currency: GBP,
+        lcy_decimal_places: 2,
+    };
+}
+function buildLineGrouping(payload) {
+    const group = {};
+    const makeKey = (orderNo, lineNo) => `${orderNo}:${lineNo}`;
+    (payload.sales || []).forEach((sale) => {
+        const orderNo = String(sale?.no || sale?.document_no || payload.no || "");
+        (sale.sale_lines || []).forEach((l) => {
+            if (String(l?.type || '').toLowerCase() !== 'item')
+                return;
+            const lineNo = Number(l?.line_no || 0);
+            if (!orderNo || !lineNo)
+                return;
+            const key = makeKey(orderNo, lineNo);
+            const entry = group[key] || { order_no: orderNo, order_line_no: lineNo };
+            entry.sale = { document_no: orderNo };
+            group[key] = entry;
+        });
+    });
+    (payload.invoices || []).forEach((inv) => {
+        const documentNo = String(inv?.no || inv?.document_no || "");
+        (inv.invoice_lines || []).forEach((l) => {
+            if (String(l?.type || '').toLowerCase() !== 'item')
+                return;
+            const orderNo = String(l?.order_no || inv?.order_no || payload.no || "");
+            const lineNo = Number(l?.order_line_no || l?.line_no || 0);
+            if (!orderNo || !lineNo)
+                return;
+            const key = makeKey(orderNo, lineNo);
+            const entry = group[key] || { order_no: orderNo, order_line_no: lineNo };
+            entry.invoice = { document_no: documentNo || orderNo };
+            group[key] = entry;
+        });
+    });
+    (payload.shipments || []).forEach((sh) => {
+        const documentNo = String(sh?.no || sh?.document_no || "");
+        (sh.shipment_lines || []).forEach((l) => {
+            const orderNo = String(l?.order_no || payload.no || "");
+            const lineNo = Number(l?.order_line_no || l?.line_no || 0);
+            if (!orderNo || !lineNo)
+                return;
+            const key = makeKey(orderNo, lineNo);
+            const entry = group[key] || { order_no: orderNo, order_line_no: lineNo };
+            entry.shipment = { document_no: documentNo || orderNo };
+            group[key] = entry;
+        });
+    });
+    (payload.credit_memos || []).forEach((cm) => {
+        const documentNo = String(cm?.no || cm?.document_no || "");
+        (cm.credit_memo_lines || []).forEach((l) => {
+            const orderNo = String(l?.order_no || payload.no || "");
+            const lineNo = Number(l?.order_line_no || l?.line_no || 0);
+            if (!orderNo || !lineNo)
+                return;
+            const key = makeKey(orderNo, lineNo);
+            const entry = group[key] || { order_no: orderNo, order_line_no: lineNo };
+            entry.credit_memo = { document_no: documentNo || orderNo };
+            group[key] = entry;
+        });
+    });
+    return group;
+}
+function transformMasterOrder(payload) {
+    const erp_order_id = payload.no || payload.system_id || "";
+    const sale0 = Array.isArray(payload.sales) && payload.sales.length > 0 ? payload.sales[0] : undefined;
+    const invoice0 = Array.isArray(payload.invoices) && payload.invoices.length > 0 ? payload.invoices[0] : undefined;
+    const normalizeDateForSort = (dateStr) => {
+        if (!dateStr || typeof dateStr !== 'string')
+            return '';
+        if (dateStr.includes('T'))
+            return dateStr;
+        if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr))
+            return `${dateStr}T00:00:00Z`;
+        try {
+            const date = new Date(dateStr);
+            if (!isNaN(date.getTime()))
+                return date.toISOString();
+        }
+        catch {
+        }
+        return dateStr;
+    };
+    const ordered_at_candidates = [];
+    if (sale0?.system_created_at)
+        ordered_at_candidates.push(normalizeDateForSort(String(sale0.system_created_at)));
+    if (Array.isArray(payload.invoices) && payload.invoices.length > 0) {
+        const invDates = payload.invoices
+            .map((i) => i.system_created_at)
+            .filter(Boolean)
+            .map((d) => normalizeDateForSort(String(d)));
+        ordered_at_candidates.push(...invDates);
+    }
+    if (payload.ordered_at)
+        ordered_at_candidates.push(normalizeDateForSort(String(payload.ordered_at)));
+    if (payload.created_at)
+        ordered_at_candidates.push(normalizeDateForSort(String(payload.created_at)));
+    const validDates = ordered_at_candidates.filter(d => d.length > 0);
+    const orderedAtRaw = validDates.length > 0
+        ? validDates.sort()[0]
+        : new Date().toISOString();
+    let ordered_at;
+    try {
+        const date = new Date(orderedAtRaw);
+        if (isNaN(date.getTime())) {
+            ordered_at = new Date().toISOString();
+        }
+        else {
+            ordered_at = date.toISOString();
+        }
+    }
+    catch {
+        ordered_at = new Date().toISOString();
+    }
+    const created_by_raw = sale0?.created_by ?? invoice0?.created_by ?? "";
+    const system_created_by = created_by_raw === "SITOO" ? "POS" : created_by_raw === "STOREFRONT" ? "ECOMMERCE" : "SYSTEM";
+    const is_gift = Boolean((sale0?.gift_message && String(sale0?.gift_message).trim().length > 0) ||
+        (payload.invoices?.some((i) => (i.gift_message || "").trim().length > 0)));
+    const invoiceLinesForReturn = payload.invoices?.flatMap((i) => i.invoice_lines || []) || [];
+    const salesLinesFallbackForReturn = (sale0?.sale_lines || []);
+    const sourceLinesForReturn = invoiceLinesForReturn.length > 0 ? invoiceLinesForReturn : salesLinesFallbackForReturn;
+    const skuByDescription = {};
+    sourceLinesForReturn.forEach((line) => {
+        if ((line?.type || "") !== "Item")
+            return;
+        const itemNo = String(line?.no || "");
+        const variant = String(line?.variant_code || "");
+        const desc = String(line?.description || "");
+        const sku = variant ? `${itemNo}-${variant}` : itemNo;
+        if (desc)
+            skuByDescription[desc] = sku;
+    });
+    const isItemish = (type, itemNo, desc) => {
+        const t = String(type || '').toLowerCase();
+        return t.includes('item') || itemNo.includes('-') || desc.includes(' - ');
+    };
+    const returnedQtyBySku = {};
+    (payload.credit_memos || []).forEach((cm) => {
+        (cm.credit_memo_lines || []).forEach((l) => {
+            const itemNo = String(l?.item_no || l?.no || '');
+            const desc = String(l?.description || '');
+            if (itemNo.toUpperCase() === 'X DELCHR' || itemNo.toUpperCase() === 'REFUND')
+                return;
+            if ((l?.quantity || 0) <= 0)
+                return;
+            const typeStr = String(l?.type || '').toLowerCase();
+            const isTypeItem = typeStr.includes('item');
+            if (isTypeItem) {
+                const variant = String(l?.variant_code || '');
+                const sku = variant ? `${itemNo}-${variant}` : itemNo;
+                returnedQtyBySku[sku] = (returnedQtyBySku[sku] || 0) + (l.quantity || 0);
+            }
+            else if (desc && skuByDescription[desc]) {
+                const sku = skuByDescription[desc];
+                returnedQtyBySku[sku] = (returnedQtyBySku[sku] || 0) + (l.quantity || 0);
+            }
+        });
+    });
+    (payload.sales || []).forEach((sale) => {
+        const docTypeRaw = String(sale?.document_type || sale?.documentType || '');
+        if (!docTypeRaw.toLowerCase().includes('return'))
+            return;
+        (sale.sale_lines || []).forEach((l) => {
+            const itemNo = String(l?.item_no || l?.no || '');
+            const desc = String(l?.description || '');
+            if (itemNo.toUpperCase() === 'X DELCHR' || itemNo.toUpperCase() === 'REFUND')
+                return;
+            if ((l?.quantity || 0) <= 0)
+                return;
+            if (!isItemish(l?.type, itemNo, desc))
+                return;
+            const variant = String(l?.variant_code || '');
+            const sku = variant ? `${itemNo}-${variant}` : itemNo;
+            returnedQtyBySku[sku] = (returnedQtyBySku[sku] || 0) + (l.quantity || 0);
+        });
+    });
+    const invoiceLines = payload.invoices?.flatMap((i) => i.invoice_lines || []) || [];
+    const salesLinesFallback = (sale0?.sale_lines || []).map((l) => ({
+        type: l.type || "Item",
+        no: l.no,
+        variant_code: l.variant_code,
+        quantity: l.quantity,
+        amount: l.amount,
+        amount_including_vat: l.amount_including_vat,
+        price_update_reason: l.price_update_reason,
+        salesforce_promotion_id: l.salesforce_promotion_id,
+        line_discount_amount: l.line_discount_amount,
+        line_discount_percent: l.line_discount_percent,
+        unit_cost_lcy: l.unit_cost_lcy,
+        unit_price: l.unit_price,
+        vat_percent: l.vat_percent,
+        order_line_no: l.line_no,
+    }));
+    const sourceLines = invoiceLines.length > 0 ? invoiceLines : salesLinesFallback;
+    const headerPricesInclVat = invoiceLines.length > 0
+        ? Boolean(invoice0?.prices_including_vat)
+        : Boolean(sale0?.prices_including_vat);
+    const shippedQtyBySku = {};
+    (payload.shipments || []).forEach((s) => {
+        (s.shipment_lines || []).forEach((l) => {
+            const itemNo = String(l?.item_no || l?.no || "");
+            if (itemNo.toUpperCase() === 'X DELCHR')
+                return;
+            const desc = String(l?.description || '');
+            const looksProduct = itemNo.includes('-') || desc.includes(' - ');
+            const qty = Number(l?.quantity || 0);
+            if (!looksProduct)
+                return;
+            if (qty <= 0)
+                return;
+            const variant = String(l?.variant_code || "");
+            const sku = variant ? `${itemNo}-${variant}` : itemNo;
+            shippedQtyBySku[sku] = (shippedQtyBySku[sku] || 0) + qty;
+        });
+    });
+    const shippedRemainingBySku = { ...shippedQtyBySku };
+    const returnedTotalBySkuCapped = {};
+    Object.keys(returnedQtyBySku).forEach((k) => {
+        const totalReturned = Number(returnedQtyBySku[k] || 0);
+        const totalShipped = Number(shippedQtyBySku[k] || 0);
+        returnedTotalBySkuCapped[k] = totalShipped ? Math.min(totalReturned, totalShipped) : totalReturned;
+    });
+    const returnedRemainingBySku = { ...returnedTotalBySkuCapped };
+    const itemsList = [];
+    sourceLines
+        .filter((line) => line.type === "Item")
+        .forEach((line) => {
+        const itemNo = line.no || "";
+        const variant = line.variant_code || "";
+        const quantity = Number(line.quantity || 0);
+        const sku = variant ? `${itemNo}-${variant}` : itemNo;
+        const parts = itemNo.split("-");
+        const style_id = parts.length >= 2 && parts[0] ? parts[0] : null;
+        const colour_id = parts.length >= 2 && parts[1] ? parts[1] : null;
+        const product_id = (() => {
+            const s = String(itemNo || "");
+            if (!s)
+                return null;
+            const parts = s.split("-");
+            return parts.length >= 2 ? `${parts[0]}-${parts[1]}` : s;
+        })();
+        const netTotal = Number(line.amount || 0);
+        const grossTotal = Number(line.amount_including_vat || 0);
+        const unitPriceRaw = Number(line.unit_price || 0);
+        const vatPercent = Number(line.vat_percent || 0);
+        let vatRate = 0;
+        if (vatPercent > 0) {
+            vatRate = vatPercent / 100;
+        }
+        else if (netTotal > 0 && grossTotal > 0) {
+            vatRate = Math.max(0, (grossTotal - netTotal) / netTotal);
+        }
+        let unitNet = 0;
+        let unitGross = 0;
+        if (unitPriceRaw > 0) {
+            if (headerPricesInclVat) {
+                unitGross = unitPriceRaw;
+                unitNet = vatRate > 0 ? (unitGross / (1 + vatRate)) : unitGross;
+            }
+            else {
+                unitNet = unitPriceRaw;
+                unitGross = vatRate > 0 ? (unitNet * (1 + vatRate)) : unitNet;
+            }
+        }
+        else {
+            unitNet = quantity > 0
+                ? (netTotal > 0
+                    ? netTotal / quantity
+                    : (grossTotal > 0 && vatRate > 0 ? (grossTotal / (1 + vatRate)) / quantity : 0))
+                : 0;
+            unitGross = quantity > 0
+                ? (grossTotal > 0
+                    ? grossTotal / quantity
+                    : (netTotal > 0 && vatRate > 0 ? (netTotal * (1 + vatRate)) / quantity : 0))
+                : 0;
+        }
+        const discountCode = (line.salesforce_promotion_id && line.salesforce_promotion_id.trim().length > 0)
+            ? line.salesforce_promotion_id.trim()
+            : null;
+        let unit_price_status = "rrp";
+        const reason = (line.price_update_reason || "").toUpperCase();
+        if (reason === "PERM")
+            unit_price_status = "perm";
+        else if (reason === "RRP")
+            unit_price_status = "rrp";
+        else if (reason === "POS")
+            unit_price_status = "pos";
+        const discountPercent = Number(line.line_discount_percent || 0);
+        const discountAmountRaw = Number(line.line_discount_amount || 0);
+        let discountNet = 0;
+        let discountGross = 0;
+        if (discountAmountRaw > 0) {
+            if (headerPricesInclVat) {
+                discountGross = discountAmountRaw;
+                discountNet = vatRate > 0 ? (discountGross / (1 + vatRate)) : discountGross;
+            }
+            else {
+                discountNet = discountAmountRaw;
+                discountGross = vatRate > 0 ? (discountNet * (1 + vatRate)) : discountNet;
+            }
+        }
+        else if (discountPercent > 0) {
+            if (netTotal > 0)
+                discountNet = (netTotal * discountPercent) / 100;
+            if (grossTotal > 0)
+                discountGross = (grossTotal * discountPercent) / 100;
+            if (grossTotal === 0 && discountNet > 0 && vatRate > 0)
+                discountGross = discountNet * (1 + vatRate);
+            if (netTotal === 0 && discountGross > 0 && vatRate > 0)
+                discountNet = discountGross / (1 + vatRate);
+        }
+        const take = Math.min(shippedRemainingBySku[sku] || 0, quantity);
+        const remaining = quantity - take;
+        const baseFields = {
+            sku,
+            linked_style_id: null,
+            colour_id,
+            style_id: (style_id || null),
+            unit_price_status,
+            unit_price_net: money(unitNet),
+            unit_price_gross: money(unitGross),
+            cost_net: money(line.unit_cost_lcy || 0),
+            size_name: (variant || undefined),
+            preorder_date: null,
+            discount_code: discountCode,
+            order_line_no: line.order_line_no || null,
+            product_id,
+        };
+        const pushItem = (qty, returnedQtyForLine) => {
+            itemsList.push({
+                ...baseFields,
+                quantity: qty,
+                returned_quantity: Math.max(0, Number(returnedQtyForLine || 0)),
+                amount_net: money(unitNet * qty),
+                amount_gross: money(unitGross * qty),
+                discount_amount_net: money(discountNet * (qty / Math.max(1, quantity))),
+                discount_amount_gross: money(discountGross * (qty / Math.max(1, quantity))),
+                discount_amount_percent: line.line_discount_percent || 0,
+            });
+        };
+        if (take > 0) {
+            const retForShipped = Math.min(Math.max(0, returnedRemainingBySku[sku] || 0), take);
+            pushItem(take, retForShipped);
+            shippedRemainingBySku[sku] = Math.max(0, (shippedRemainingBySku[sku] || 0) - take);
+            if (retForShipped > 0) {
+                returnedRemainingBySku[sku] = Math.max(0, (returnedRemainingBySku[sku] || 0) - retForShipped);
+            }
+        }
+        if (remaining > 0) {
+            pushItem(remaining, 0);
+        }
+    });
+    const itemsMap = {};
+    itemsList.forEach((it) => {
+        if (!itemsMap[it.sku])
+            itemsMap[it.sku] = [];
+        itemsMap[it.sku].push(it);
+    });
+    const invoicedLineNos = new Set((payload.invoices || []).flatMap((inv) => (inv?.invoice_lines || []).map((l) => Number(l?.order_line_no || -1))));
+    const isDeliveryItem = (line) => {
+        const desc = String(line?.description || '').trim().toLowerCase();
+        return desc === 'delivery';
+    };
+    let invoicesNetMinor = 0;
+    let invoicesGrossMinor = 0;
+    (payload.invoices || []).forEach((inv) => {
+        (inv.invoice_lines || []).forEach((line) => {
+            if (!isDeliveryItem(line)) {
+                invoicesNetMinor += toMinorUnits(Number(line?.amount || line?.amount_excl_vat || 0));
+                invoicesGrossMinor += toMinorUnits(Number(line?.amount_including_vat || line?.amount_incl_vat || 0));
+            }
+        });
+    });
+    if (invoicesGrossMinor === 0 && (payload.invoices || []).length > 0) {
+        invoicesNetMinor = toMinorUnits((payload.invoices || []).reduce((acc, inv) => acc + (inv.amount_excl_vat || 0), 0));
+        invoicesGrossMinor = toMinorUnits((payload.invoices || []).reduce((acc, inv) => acc + (inv.amount_incl_vat || 0), 0));
+    }
+    if (invoicesGrossMinor === 0 && invoicedLineNos.size > 0 && sale0?.sale_lines) {
+        const invoicedSaleLines = (sale0?.sale_lines || []).filter((l) => {
+            if (isDeliveryItem(l))
+                return false;
+            if (String(l?.type || '').toLowerCase() !== 'item')
+                return false;
+            const lineNo = Number(l?.line_no || -1);
+            return invoicedLineNos.has(lineNo);
+        });
+        invoicesNetMinor = toMinorUnits(invoicedSaleLines.reduce((acc, l) => acc + (Number(l?.amount || 0)), 0));
+        invoicesGrossMinor = toMinorUnits(invoicedSaleLines.reduce((acc, l) => acc + (Number(l?.amount_including_vat || 0)), 0));
+    }
+    let nonInvSalesNetMinor = 0;
+    let nonInvSalesGrossMinor = 0;
+    if (sale0?.sale_lines && sale0.sale_lines.length > 0) {
+        const allSaleLines = (sale0.sale_lines || []).filter((l) => {
+            if (isDeliveryItem(l))
+                return false;
+            if (String(l?.type || '').toLowerCase() !== 'item')
+                return false;
+            return true;
+        });
+        const totalSaleNetMinor = toMinorUnits(allSaleLines.reduce((acc, l) => acc + (Number(l?.amount || 0)), 0));
+        const totalSaleGrossMinor = toMinorUnits(allSaleLines.reduce((acc, l) => acc + (Number(l?.amount_including_vat || 0)), 0));
+        if (invoicesGrossMinor > 0) {
+            nonInvSalesNetMinor = Math.max(0, totalSaleNetMinor - invoicesNetMinor);
+            nonInvSalesGrossMinor = Math.max(0, totalSaleGrossMinor - invoicesGrossMinor);
+        }
+        else {
+            nonInvSalesNetMinor = totalSaleNetMinor;
+            nonInvSalesGrossMinor = totalSaleGrossMinor;
+        }
+    }
+    else if (sale0 && (sale0.amount_excl_vat || sale0.amount_incl_vat)) {
+        const saleNetMinor = toMinorUnits(sale0.amount_excl_vat || 0);
+        const saleGrossMinor = toMinorUnits(sale0.amount_incl_vat || 0);
+        if (invoicesGrossMinor > 0) {
+            nonInvSalesNetMinor = Math.max(0, saleNetMinor - invoicesNetMinor);
+            nonInvSalesGrossMinor = Math.max(0, saleGrossMinor - invoicesGrossMinor);
+        }
+        else {
+            nonInvSalesNetMinor = saleNetMinor;
+            nonInvSalesGrossMinor = saleGrossMinor;
+        }
+    }
+    else {
+        const nonInvoicedSales = (sale0?.sale_lines || []).filter((l) => {
+            if (isDeliveryItem(l))
+                return false;
+            if (String(l?.type || '').toLowerCase() !== 'item')
+                return false;
+            const lineNo = Number(l?.line_no || -1);
+            return !invoicedLineNos.has(lineNo);
+        });
+        nonInvSalesNetMinor = toMinorUnits(nonInvoicedSales.reduce((acc, l) => acc + (Number(l?.amount || 0)), 0));
+        nonInvSalesGrossMinor = toMinorUnits(nonInvoicedSales.reduce((acc, l) => acc + (Number(l?.amount_including_vat || 0)), 0));
+    }
+    const returnsNetMinor = toMinorUnits((payload.credit_memos || []).reduce((acc, cm) => acc + (cm.amount_excl_vat || 0), 0));
+    const returnsGrossMinor = toMinorUnits((payload.credit_memos || []).reduce((acc, cm) => acc + (cm.amount_incl_vat || 0), 0));
+    const totalNetMinor = invoicesNetMinor + nonInvSalesNetMinor;
+    const totalGrossMinor = invoicesGrossMinor + nonInvSalesGrossMinor;
+    const total = {
+        amount_net: moneyFromMinor(totalNetMinor),
+        amount_gross: moneyFromMinor(totalGrossMinor),
+        discount_amount_net: money(0),
+        discount_amount_gross: money(0),
+        discount_amount_percent: 0,
+    };
+    const return_total = (payload.credit_memos && payload.credit_memos.length > 0)
+        ? {
+            amount_net: moneyFromMinor(returnsNetMinor),
+            amount_gross: moneyFromMinor(returnsGrossMinor),
+            discount_amount_net: money(0),
+            discount_amount_gross: money(0),
+            discount_amount_percent: 0,
+        }
+        : undefined;
+    const net_total = {
+        amount_net: moneyFromMinor(Math.max(0, totalNetMinor - returnsNetMinor)),
+        amount_gross: moneyFromMinor(Math.max(0, totalGrossMinor - returnsGrossMinor)),
+        discount_amount_net: money(0),
+        discount_amount_gross: money(0),
+        discount_amount_percent: 0,
+    };
+    const normalizeDateTime = (dateMaybe, fallbackIso) => {
+        const source = (typeof dateMaybe === "string" && dateMaybe.length > 0)
+            ? dateMaybe
+            : fallbackIso;
+        const d = new Date(source.includes("T") ? source : `${source}T00:00:00Z`);
+        return isNaN(d.getTime()) ? new Date().toISOString() : d.toISOString();
+    };
+    const mappedShipments = (payload.shipments || []).map((s) => {
+        const rawLines = (s.shipment_lines || [])
+            .filter((l) => (l?.quantity ?? 0) > 0)
+            .filter((l) => String(l?.item_no || '').toUpperCase() !== 'X DELCHR')
+            .filter((l) => {
+            const itemNo = String(l?.item_no || '');
+            const desc = String(l?.description || '');
+            const looksProduct = itemNo.includes('-') || desc.includes(' - ');
+            return looksProduct;
+        });
+        const qtyBySku = new Map();
+        rawLines.forEach((l) => {
+            const itemNo = String(l?.item_no || '');
+            const variant = String(l?.variant_code || '');
+            const sku = variant ? `${itemNo}-${variant}` : itemNo;
+            const q = Number(l?.quantity || 0);
+            qtyBySku.set(sku, (qtyBySku.get(sku) || 0) + q);
+        });
+        const skus = Array.from(qtyBySku.keys()).sort();
+        const shipmentLines = skus.map((sku, idx) => ({
+            lineNumber: idx + 1,
+            sku,
+            quantity: Math.max(1, qtyBySku.get(sku) || 0),
+        }));
+        const statusVal = shipmentLines.length > 0 ? "SHIPPED" : "PENDING";
+        return {
+            erp_id: s.no || s.system_id || "",
+            shipped_at: normalizeDateTime(s.shipment_date, ordered_at),
+            status: statusVal,
+            type: statusVal === "SHIPPED" ? "SHIPPED-OUTBOUND" : undefined,
+            shipped_by: "TORQUE",
+            items: shipmentLines,
+            amount_net: money(0),
+            amount_gross: money(0),
+            discount_amount_net: money(0),
+            discount_amount_gross: money(0),
+            discount_amount_percent: 0,
+        };
+    });
+    const returnShipments = (payload.credit_memos || [])
+        .filter((cm) => {
+        const lines = cm?.credit_memo_lines || [];
+        return lines.some((l) => {
+            const itemNo = String(l?.item_no || l?.no || "");
+            const upper = itemNo.toUpperCase();
+            if (upper === 'X DELCHR' || upper === 'REFUND')
+                return false;
+            const looksProduct = itemNo.includes('-');
+            return (l?.quantity || 0) > 0 && looksProduct;
+        });
+    })
+        .map((cm, idx) => {
+        const rawLines = (cm.credit_memo_lines || [])
+            .filter((l) => (l?.quantity || 0) > 0)
+            .filter((l) => {
+            const itemNo = String(l?.item_no || l?.no || '');
+            const upper = itemNo.toUpperCase();
+            if (upper === 'X DELCHR' || upper === 'REFUND')
+                return false;
+            return itemNo.includes('-');
+        });
+        const qtyBySku = new Map();
+        rawLines.forEach((l) => {
+            const itemNo = String(l?.item_no || l?.no || '');
+            const variant = String(l?.variant_code || '');
+            const sku = variant ? `${itemNo}-${variant}` : itemNo;
+            const q = Number(l?.quantity || 0);
+            qtyBySku.set(sku, (qtyBySku.get(sku) || 0) + q);
+        });
+        const skus = Array.from(qtyBySku.keys()).sort();
+        const lines = skus.map((sku, i) => ({
+            lineNumber: i + 1,
+            sku,
+            quantity: Math.max(1, qtyBySku.get(sku) || 0),
+            returnReasonCode: "R1",
+            returnReason: "Return",
+        }));
+        return {
+            erp_id: cm.no || cm.system_id || `${erp_order_id}-RET-${idx + 1}`,
+            shipped_at: normalizeDateTime(cm.shipment_date, ordered_at),
+            status: "RECEIVED",
+            type: "SHIPPED-RETURN",
+            shipped_by: "CUSTOMER",
+            items: lines,
+            amount_net: money(0),
+            amount_gross: money(0),
+            discount_amount_net: money(0),
+            discount_amount_gross: money(0),
+            discount_amount_percent: 0,
+        };
+    });
+    const shipments = (mappedShipments.length || returnShipments.length)
+        ? [...mappedShipments, ...returnShipments]
+        : [];
+    const shipping_method = (payload.shipments?.[0]?.shipping_agent_service_code) || null;
+    const merchReturnGrossFromCreditMemos = (payload.credit_memos || []).reduce((acc, cm) => {
+        const lines = cm?.credit_memo_lines || [];
+        let hasQualifying = false;
+        const sum = lines.reduce((s, l) => {
+            const itemNo = String(l?.item_no || l?.no || "");
+            const desc = String(l?.description || "");
+            const looksProduct = itemNo.includes('-') || desc.includes(' - ');
+            const typeStr = String(l?.type || "").toLowerCase();
+            const isItemish = typeStr.includes('item') || looksProduct;
+            const isRefund = itemNo.toUpperCase() === 'REFUND';
+            if ((l?.quantity || 0) > 0 && isItemish && !isRefund && !isDeliveryItem(l)) {
+                hasQualifying = true;
+                return s + (l?.amount_including_vat || 0);
+            }
+            return s;
+        }, 0);
+        if (!hasQualifying)
+            return acc;
+        if (cm?.amount_incl_vat != null && cm.amount_incl_vat > 0) {
+            return acc + cm.amount_incl_vat;
+        }
+        return acc + sum;
+    }, 0);
+    const merchReturnGrossFromReturnSales = (payload.sales || []).reduce((acc, sale) => {
+        const docTypeRaw = String(sale?.document_type || sale?.documentType || "");
+        const isReturnOrder = docTypeRaw.toLowerCase().includes('return');
+        if (!isReturnOrder)
+            return acc;
+        if (sale?.amount_incl_vat != null && sale.amount_incl_vat > 0) {
+            return acc + sale.amount_incl_vat;
+        }
+        const lines = sale?.sale_lines || [];
+        let hasQualifying = false;
+        const sum = lines.reduce((s, l) => {
+            const itemNo = String(l?.item_no || l?.no || "");
+            const desc = String(l?.description || "");
+            const looksProduct = itemNo.includes('-') || desc.includes(' - ');
+            const typeStr = String(l?.type || "").toLowerCase();
+            const isItemish = typeStr.includes('item') || looksProduct;
+            const isRefund = itemNo.toUpperCase() === 'REFUND';
+            if ((l?.quantity || 0) > 0 && isItemish && !isRefund && !isDeliveryItem(l)) {
+                hasQualifying = true;
+                return s + (l?.amount_including_vat || 0);
+            }
+            return s;
+        }, 0);
+        return acc + (sum > 0 ? sum : (hasQualifying ? (sale?.amount_incl_vat || sale?.amount_including_vat || 0) : 0));
+    }, 0);
+    const merchReturnGross = merchReturnGrossFromCreditMemos + merchReturnGrossFromReturnSales;
+    const hasMerchReturn = merchReturnGross > 0;
+    const totalOrderGrossMinor = totalGrossMinor;
+    const sourceLineMap = new Map();
+    sourceLines.forEach((line) => {
+        const lineNo = Number(line.order_line_no || line.line_no || -1);
+        if (lineNo > 0) {
+            sourceLineMap.set(lineNo, line);
+        }
+    });
+    (sale0?.sale_lines || []).forEach((line) => {
+        const lineNo = Number(line.line_no || -1);
+        if (lineNo > 0) {
+            const existing = sourceLineMap.get(lineNo);
+            if (!existing || (!existing.amount_including_vat && !existing.amount_incl_vat)) {
+                sourceLineMap.set(lineNo, {
+                    ...line,
+                    order_line_no: line.line_no,
+                    amount_including_vat: line.amount_including_vat,
+                    amount_incl_vat: line.amount_including_vat,
+                });
+            }
+        }
+    });
+    const sourceLineBySku = new Map();
+    sourceLines.forEach((line) => {
+        if (line.type === "Item") {
+            const itemNo = String(line.no || "");
+            const variant = String(line.variant_code || "");
+            const sku = variant ? `${itemNo}-${variant}` : itemNo;
+            if (!sourceLineBySku.has(sku)) {
+                sourceLineBySku.set(sku, line);
+            }
+        }
+    });
+    (sale0?.sale_lines || []).forEach((line) => {
+        if (line.type === "Item") {
+            const itemNo = String(line.no || "");
+            const variant = String(line.variant_code || "");
+            const sku = variant ? `${itemNo}-${variant}` : itemNo;
+            const existing = sourceLineBySku.get(sku);
+            if (!existing || (!existing.amount_including_vat && !existing.amount_incl_vat)) {
+                sourceLineBySku.set(sku, {
+                    ...line,
+                    order_line_no: line.line_no,
+                    amount_including_vat: line.amount_including_vat,
+                    amount_incl_vat: line.amount_including_vat,
+                });
+            }
+        }
+    });
+    const shippedGrossDecimal = (payload.shipments || []).reduce((acc, s) => {
+        if (s.amount_incl_vat != null && s.amount_incl_vat > 0) {
+            return acc + (s.amount_incl_vat || 0);
+        }
+        const lineAmounts = (s.shipment_lines || []).reduce((lineAcc, l) => {
+            if (isDeliveryItem(l))
+                return lineAcc;
+            const orderLineNo = Number(l?.order_line_no || -1);
+            let sourceLine = orderLineNo > 0 ? sourceLineMap.get(orderLineNo) : null;
+            if (!sourceLine) {
+                const itemNo = String(l?.item_no || l?.no || "").toUpperCase();
+                const variant = String(l?.variant_code || "");
+                const sku = variant ? `${itemNo}-${variant}` : itemNo;
+                sourceLine = sourceLineBySku.get(sku);
+            }
+            if (sourceLine) {
+                const sourceQty = Number(sourceLine.quantity || 0);
+                const sourceGross = Number(sourceLine.amount_including_vat || sourceLine.amount_incl_vat || 0);
+                const shippedQty = Number(l?.quantity || 0);
+                if (sourceQty > 0 && sourceGross > 0) {
+                    const unitPrice = sourceGross / sourceQty;
+                    return lineAcc + (unitPrice * shippedQty);
+                }
+            }
+            return lineAcc + (l?.amount_including_vat || l?.amount_incl_vat || 0);
+        }, 0);
+        return acc + lineAmounts;
+    }, 0);
+    const shippedGrossMinor = toMinorUnits(shippedGrossDecimal);
+    let status = "PROCESSED";
+    if (hasMerchReturn) {
+        const totalOrderGrossDecimal = totalOrderGrossMinor / 100;
+        status = totalOrderGrossDecimal > 0 && merchReturnGross >= totalOrderGrossDecimal ? "RETURNED" : "PARTIALLY-RETURNED";
+    }
+    else if (shippedGrossMinor > 0 && totalOrderGrossMinor > 0) {
+        status = shippedGrossMinor >= totalOrderGrossMinor ? "SHIPPED" : "PARTIALLY-SHIPPED";
+    }
+    const sfcc_order_id = (sale0?.created_by === "STOREFRONT")
+        ? (sale0?.no || null)
+        : ((invoice0?.created_by === "STOREFRONT") ? (invoice0?.order_no || null) : null);
+    const billing_from = invoice0 || sale0 || null;
+    const shipping_from = invoice0 || sale0 || null;
+    const mapPaymentMethod = (code, card) => {
+        const c = String(code || '').toUpperCase();
+        const processorId = String(card?.processor_id || '').toUpperCase();
+        const giftCertId = String(card?.gift_certificate_id || '').trim();
+        const cardType = String(card?.type || '').trim().toLowerCase();
+        if (giftCertId.length > 0)
+            return 'GIFT-CARD';
+        if (cardType === 'gift certificate')
+            return 'GIFT-CARD';
+        if (processorId.includes('GIFT_CERTIFICATE') || processorId.includes('GIFT-CERTIFICATE'))
+            return 'GIFT-CARD';
+        if (/(GVOUCHER|VOUCHER|GIFT|EGIFT)/.test(c))
+            return 'GIFT-CARD';
+        if (c.includes('APPLE'))
+            return 'APPLE-PAY';
+        if ((c.includes('PAYPAL') || processorId === 'PAYPAL') && giftCertId.length === 0) {
+            return 'PAYPAL';
+        }
+        if (c.includes('MOTO'))
+            return 'MOTO';
+        if (c.includes('ADYEN') && cardType === 'credit card' && giftCertId.length === 0) {
+            return 'CREDIT-CARD';
+        }
+        const serviceType = String(card?.service_type || '').toUpperCase();
+        if (serviceType.includes('VOUCHER') && giftCertId.length === 0 && processorId !== 'PAYPAL') {
+            return 'GIFT-CARD';
+        }
+        if (card?.card_number)
+            return 'CREDIT-CARD';
+        return 'OTHER';
+    };
+    const cardPays = (payload.card_payments || []).map((c) => ({
+        created_at: c.created_at,
+        amount: c.mount || c.amount,
+        type: c.type || 'Payment',
+        payment_method_code: String(c.service_type || ''),
+        transaction_id: c.transaction_id,
+        card_number: c.card_number,
+        psp_reference: c.psp_reference,
+        gift_certificate_id: c.gift_certificate_id,
+        service_type: c.service_type,
+        processor_id: c.processor_id,
+        created_by: invoice0?.created_by || sale0?.created_by,
+        source: 'card_payment',
+        order_no: c.order_no,
+        captured: c.captured,
+    }));
+    const normalPays = (payload.payments || []).map((p) => ({
+        created_at: p.created_at,
+        amount: p.amount,
+        type: p.type,
+        payment_method_code: p.payment_method_code,
+        transaction_id: p.transaction_id,
+        card_number: undefined,
+        psp_reference: p.psp_reference,
+        payment_gateway_token: p.payment_gateway_token,
+        payment_number: p.payment_number,
+        payment_refund_number: p.payment_refund_number,
+        original_payment_refund_id: p.original_payment_refund_id,
+        created_by: p.created_by || invoice0?.created_by || sale0?.created_by,
+        source: 'payment',
+        order_no: p.master_order_no,
+        ledger_entry_no: p.ledger_entry_no,
+    }));
+    const flat = [...cardPays, ...normalPays];
+    const groupsMap = new Map();
+    flat.forEach((p) => {
+        try {
+            const isRefund = String(p.type || '').toLowerCase() === 'refund';
+            const logicalType = isRefund ? 'REFUND' : 'CHARGE';
+            let keyBase;
+            const unifiedId = p.transaction_id || p.payment_gateway_token;
+            if (unifiedId) {
+                keyBase = unifiedId;
+            }
+            else if (p.payment_number) {
+                keyBase = `PN:${p.payment_number}`;
+            }
+            else if (!isRefund) {
+                const paymentType = String(p.type || '').toUpperCase();
+                const amount = Number(p.amount || 0);
+                const paymentMethod = String(p.payment_method_code || '').toUpperCase().trim();
+                const orderNo = p.order_no || erp_order_id;
+                if (paymentType === 'CAPTURE' || paymentType === 'AUTHORISATION') {
+                    keyBase = `CHARGE-${orderNo}-${amount}-${paymentMethod}`;
+                }
+                else if (p.gift_certificate_id) {
+                    keyBase = `GIFT:${p.gift_certificate_id}`;
+                }
+                else {
+                    const orderNo = p.order_no || erp_order_id;
+                    const paymentMethod = String(p.payment_method_code || '').toUpperCase().trim();
+                    keyBase = `${orderNo}-${amount}-${paymentMethod}`;
+                }
+            }
+            else {
+                if (p.payment_refund_number) {
+                    keyBase = `PRN:${p.payment_refund_number}`;
+                }
+                else {
+                    const orderNo = p.order_no || erp_order_id;
+                    const amount = Number(p.amount || 0);
+                    const paymentMethod = String(p.payment_method_code || '').toUpperCase().trim();
+                    keyBase = `${orderNo}-${amount}-${paymentMethod}`;
+                }
+            }
+            const key = `${logicalType}:${keyBase}`;
+            const g = groupsMap.get(key) || { entries: [], type: logicalType, key };
+            g.entries.push(p);
+            groupsMap.set(key, g);
+        }
+        catch (error) {
+            console.error(`Error processing payment entry:`, {
+                error: error instanceof Error ? error.message : String(error),
+                payment_type: p?.type,
+                amount: p?.amount,
+                order_no: p?.order_no || erp_order_id,
+                transaction_id: p?.transaction_id,
+                payment_gateway_token: p?.payment_gateway_token,
+            });
+        }
+    });
+    const allPaymentEntriesByOrder = new Map();
+    flat.forEach(p => {
+        const orderNo = p.order_no || erp_order_id;
+        const amount = Number(p.amount || 0);
+        const key = `${orderNo}-${amount}`;
+        if (!allPaymentEntriesByOrder.has(key)) {
+            allPaymentEntriesByOrder.set(key, []);
+        }
+        allPaymentEntriesByOrder.get(key).push(p);
+    });
+    const cardPaymentsByToken = new Map();
+    cardPays.forEach(cp => {
+        if (cp.transaction_id) {
+            cardPaymentsByToken.set(cp.transaction_id, cp);
+        }
+    });
+    const paymentsByOriginalRefundId = new Map();
+    const paymentsByPaymentNumber = new Map();
+    const paymentsByPaymentRefundNumber = new Map();
+    normalPays.forEach(p => {
+        const isRefund = String(p.type || '').toLowerCase() === 'refund';
+        if (!isRefund) {
+            if (p.original_payment_refund_id) {
+                paymentsByOriginalRefundId.set(p.original_payment_refund_id, p);
+            }
+            if (p.payment_number) {
+                paymentsByPaymentNumber.set(p.payment_number, p);
+            }
+            if (p.payment_refund_number) {
+                paymentsByPaymentRefundNumber.set(p.payment_refund_number, p);
+            }
+        }
+    });
+    const payments = Array.from(groupsMap.values()).map((g) => {
+        const sortedEntries = [...g.entries].sort((a, b) => {
+            if (a.source === 'card_payment' && b.source !== 'card_payment')
+                return -1;
+            if (b.source === 'card_payment' && a.source !== 'card_payment')
+                return 1;
+            if (a.source === 'payment' && b.source === 'payment') {
+                const aType = String(a.type || '').toUpperCase();
+                const bType = String(b.type || '').toUpperCase();
+                if (aType === 'AUTHORISATION' && bType !== 'AUTHORISATION')
+                    return -1;
+                if (bType === 'AUTHORISATION' && aType !== 'AUTHORISATION')
+                    return 1;
+                if (aType === 'CAPTURE' && bType !== 'CAPTURE' && bType !== 'AUTHORISATION')
+                    return -1;
+                if (bType === 'CAPTURE' && aType !== 'CAPTURE' && aType !== 'AUTHORISATION')
+                    return 1;
+            }
+            return 0;
+        });
+        const created_at = g.entries
+            .map(e => e.created_at)
+            .filter(Boolean)
+            .map(d => new Date(d).toISOString())
+            .sort()[0] || ordered_at;
+        const amountInclVat = Math.max(...g.entries.map(e => Number(e.amount || 0)), 0);
+        const amount = money(amountInclVat);
+        const primary = sortedEntries[0] || {};
+        const paymentEntryForMethod = sortedEntries.find(e => e.source === 'payment' && e.payment_method_code);
+        const paymentMethodCode = paymentEntryForMethod?.payment_method_code || primary.payment_method_code;
+        let cardPaymentEntryForMethod = sortedEntries.find(e => e.source === 'card_payment');
+        const groupCardData = {
+            card_number: cardPaymentEntryForMethod?.card_number || sortedEntries.find(e => e.card_number)?.card_number,
+            transaction_id: cardPaymentEntryForMethod?.transaction_id || sortedEntries.find(e => e.transaction_id)?.transaction_id,
+            service_type: cardPaymentEntryForMethod?.service_type || sortedEntries.find(e => e.service_type)?.service_type,
+            processor_id: cardPaymentEntryForMethod?.processor_id || sortedEntries.find(e => e.processor_id)?.processor_id,
+            gift_certificate_id: cardPaymentEntryForMethod?.gift_certificate_id || sortedEntries.find(e => e.gift_certificate_id)?.gift_certificate_id,
+            type: cardPaymentEntryForMethod?.type || sortedEntries.find(e => e.type && e.source === 'card_payment')?.type,
+        };
+        let pm;
+        if (cardPaymentEntryForMethod?.type && String(cardPaymentEntryForMethod.type).trim().toLowerCase() === 'apple pay') {
+            pm = 'APPLE-PAY';
+        }
+        else {
+            pm = mapPaymentMethod(paymentMethodCode, groupCardData);
+        }
+        let cardPaymentEntryForTransaction = sortedEntries.find(e => e.source === 'card_payment' && e.transaction_id);
+        if (!cardPaymentEntryForTransaction && primary.payment_gateway_token) {
+            cardPaymentEntryForTransaction = cardPaymentsByToken.get(primary.payment_gateway_token);
+        }
+        if (!cardPaymentEntryForTransaction && g.type === 'REFUND') {
+            let originalPayment;
+            const refundEntryWithPaymentNumber = sortedEntries.find(e => e.payment_number && String(e.payment_number).trim().length > 0);
+            if (refundEntryWithPaymentNumber?.payment_number) {
+                originalPayment = paymentsByPaymentNumber.get(refundEntryWithPaymentNumber.payment_number);
+            }
+            if (!originalPayment) {
+                const refundEntryWithOriginalId = sortedEntries.find(e => e.original_payment_refund_id);
+                if (refundEntryWithOriginalId?.original_payment_refund_id) {
+                    originalPayment = Array.from(normalPays).find(p => p.ledger_entry_no === refundEntryWithOriginalId.original_payment_refund_id &&
+                        String(p.type || '').toLowerCase() !== 'refund');
+                }
+            }
+            if (!originalPayment) {
+                const refundEntryWithRefundNumber = sortedEntries.find(e => e.payment_refund_number && String(e.payment_refund_number).trim().length > 0);
+                if (refundEntryWithRefundNumber?.payment_refund_number) {
+                    originalPayment = paymentsByPaymentRefundNumber.get(refundEntryWithRefundNumber.payment_refund_number);
+                }
+            }
+            if (originalPayment?.payment_gateway_token) {
+                cardPaymentEntryForTransaction = cardPaymentsByToken.get(originalPayment.payment_gateway_token);
+                if (!cardPaymentEntryForMethod && cardPaymentEntryForTransaction) {
+                    cardPaymentEntryForMethod = cardPaymentEntryForTransaction;
+                    if (cardPaymentEntryForMethod?.type && String(cardPaymentEntryForMethod.type).trim().toLowerCase() === 'apple pay') {
+                        pm = 'APPLE-PAY';
+                    }
+                    else {
+                        const refundCardData = {
+                            card_number: cardPaymentEntryForMethod?.card_number,
+                            transaction_id: cardPaymentEntryForMethod?.transaction_id,
+                            service_type: cardPaymentEntryForMethod?.service_type,
+                            processor_id: cardPaymentEntryForMethod?.processor_id,
+                            gift_certificate_id: cardPaymentEntryForMethod?.gift_certificate_id,
+                            type: cardPaymentEntryForMethod?.type,
+                        };
+                        pm = mapPaymentMethod(paymentMethodCode, refundCardData);
+                    }
+                }
+            }
+        }
+        let transaction_id = null;
+        if (g.type === 'REFUND' && !cardPaymentEntryForTransaction && !primary.transaction_id && !primary.payment_gateway_token) {
+            let originalPaymentForTransaction;
+            const refundEntryWithPaymentNumber = sortedEntries.find(e => e.payment_number && String(e.payment_number).trim().length > 0);
+            if (refundEntryWithPaymentNumber?.payment_number) {
+                originalPaymentForTransaction = paymentsByPaymentNumber.get(refundEntryWithPaymentNumber.payment_number);
+            }
+            if (!originalPaymentForTransaction && primary.original_payment_refund_id) {
+                originalPaymentForTransaction = Array.from(normalPays).find(p => p.ledger_entry_no === primary.original_payment_refund_id &&
+                    String(p.type || '').toLowerCase() !== 'refund');
+            }
+            if (!originalPaymentForTransaction && primary.payment_refund_number) {
+                const refundEntryWithRefundNumber = sortedEntries.find(e => e.payment_refund_number && String(e.payment_refund_number).trim().length > 0);
+                if (refundEntryWithRefundNumber?.payment_refund_number) {
+                    originalPaymentForTransaction = paymentsByPaymentRefundNumber.get(refundEntryWithRefundNumber.payment_refund_number);
+                }
+            }
+            if (originalPaymentForTransaction?.payment_gateway_token) {
+                const originalCardPayment = cardPaymentsByToken.get(originalPaymentForTransaction.payment_gateway_token);
+                transaction_id = originalCardPayment?.transaction_id || null;
+            }
+        }
+        else {
+            transaction_id = cardPaymentEntryForTransaction?.transaction_id || primary.transaction_id || null;
+        }
+        const psp_reference = transaction_id;
+        const paymentCreatedByRaw = invoice0?.created_by || primary.created_by || sale0?.created_by || "";
+        const paymentCreatedByUpper = String(paymentCreatedByRaw).toUpperCase();
+        const isEmail = typeof paymentCreatedByRaw === 'string' && paymentCreatedByRaw.includes('@');
+        const validEnumValues = ['CUSTOMER', 'SYSTEM', 'CENTRA', 'SITOO', 'STOREFRONT', 'MOTO'];
+        const isValidEnum = validEnumValues.includes(paymentCreatedByUpper);
+        const created_by = isEmail
+            ? paymentCreatedByRaw
+            : isValidEnum
+                ? paymentCreatedByUpper
+                : 'MOTO';
+        const journey_label = null;
+        let card_number = sortedEntries.find(e => e.source === 'card_payment' && e.card_number)?.card_number
+            || primary.card_number
+            || null;
+        if (!card_number && g.type === 'REFUND' && cardPaymentEntryForTransaction) {
+            card_number = cardPaymentEntryForTransaction.card_number || null;
+        }
+        let cardPaymentForBrand = sortedEntries.find(e => e.source === 'card_payment' && e.service_type);
+        if (!cardPaymentForBrand && g.type === 'REFUND' && cardPaymentEntryForTransaction) {
+            cardPaymentForBrand = cardPaymentEntryForTransaction;
+        }
+        const card_brand = cardPaymentForBrand?.service_type
+            ? String(cardPaymentForBrand.service_type).trim() || null
+            : null;
+        let status = 'CAPTURED';
+        const isVoucher = pm === 'GIFT-CARD' ||
+            sortedEntries.some(e => e.gift_certificate_id) ||
+            sortedEntries.some(e => /(GVOUCHER|VOUCHER|GIFT|EGIFT)/.test(String(e.payment_method_code || '').toUpperCase())) ||
+            sortedEntries.some(e => String(e.service_type || '').toUpperCase().includes('VOUCHER'));
+        const cardPaymentEntry = sortedEntries.find(e => e.source === 'card_payment');
+        if (isVoucher) {
+            let paymentEntry = g.entries.find(e => e.source === 'payment' &&
+                (String(e.type || '').toUpperCase() === 'PAYMENT' || String(e.type || '').toUpperCase() === 'CAPTURE'));
+            let paymentType = paymentEntry ? String(paymentEntry.type || '').toUpperCase() : '';
+            if (!paymentEntry && g.entries.length > 0) {
+                const firstEntry = g.entries[0];
+                const orderNo = firstEntry.order_no || erp_order_id;
+                const amount = Number(firstEntry.amount || 0);
+                const lookupKey = `${orderNo}-${amount}`;
+                const relatedEntries = allPaymentEntriesByOrder.get(lookupKey) || [];
+                paymentEntry = relatedEntries.find(e => e.source === 'payment' &&
+                    (String(e.type || '').toUpperCase() === 'PAYMENT' || String(e.type || '').toUpperCase() === 'CAPTURE'));
+                paymentType = paymentEntry ? String(paymentEntry.type || '').toUpperCase() : '';
+            }
+            if (paymentType === 'PAYMENT' || paymentType === 'CAPTURE') {
+                status = 'CAPTURED';
+            }
+            else {
+                status = 'FAILED';
+            }
+        }
+        else {
+            if (cardPaymentEntry?.captured === true) {
+                status = 'CAPTURED';
+            }
+            else if (cardPaymentEntry?.captured === false) {
+                status = 'FAILED';
+            }
+            else {
+                const paymentType = String(primary.type || '').toUpperCase();
+                if (paymentType === 'CAPTURE' || paymentType === 'PAYMENT') {
+                    status = 'CAPTURED';
+                }
+                else {
+                    status = 'CAPTURED';
+                }
+            }
+        }
+        return {
+            type: g.type,
+            created_at,
+            payment_method: pm,
+            transaction_id,
+            card_number,
+            card_holder: null,
+            card_token: null,
+            expiration_month: null,
+            expiration_year: null,
+            journey_label,
+            psp_reference,
+            card_brand,
+            status,
+            amount,
+            created_by,
+        };
+    });
+    const shipmentsWithItems = shipments.filter((s) => s.items && s.items.length > 0);
+    shipmentsWithItems.forEach((shipment) => {
+        let shipmentNetMinor = 0;
+        let shipmentGrossMinor = 0;
+        let shipmentDiscountNetMinor = 0;
+        let shipmentDiscountGrossMinor = 0;
+        let maxDiscountPercent = 0;
+        (shipment.items || []).forEach((shipItem) => {
+            const sku = shipItem.sku;
+            const shipQty = Number(shipItem.quantity || 0);
+            const matchingItems = itemsList.filter((item) => item.sku === sku);
+            let remainingQty = shipQty;
+            for (const item of matchingItems) {
+                if (remainingQty <= 0)
+                    break;
+                const itemQty = Number(item.quantity || 0);
+                if (itemQty > 0) {
+                    const takeQty = Math.min(remainingQty, itemQty);
+                    const ratio = takeQty / itemQty;
+                    shipmentNetMinor += item.amount_net.value * ratio;
+                    shipmentGrossMinor += item.amount_gross.value * ratio;
+                    shipmentDiscountNetMinor += item.discount_amount_net.value * ratio;
+                    shipmentDiscountGrossMinor += item.discount_amount_gross.value * ratio;
+                    maxDiscountPercent = Math.max(maxDiscountPercent, item.discount_amount_percent || 0);
+                    remainingQty -= takeQty;
+                }
+            }
+        });
+        shipment.amount_net = moneyFromMinor(shipmentNetMinor);
+        shipment.amount_gross = moneyFromMinor(shipmentGrossMinor);
+        shipment.discount_amount_net = moneyFromMinor(shipmentDiscountNetMinor);
+        shipment.discount_amount_gross = moneyFromMinor(shipmentDiscountGrossMinor);
+        shipment.discount_amount_percent = maxDiscountPercent;
+    });
+    let totalDiscountNetMinor = 0;
+    let totalDiscountGrossMinor = 0;
+    let maxTotalDiscountPercent = 0;
+    itemsList.forEach((item) => {
+        totalDiscountNetMinor += item.discount_amount_net.value;
+        totalDiscountGrossMinor += item.discount_amount_gross.value;
+        maxTotalDiscountPercent = Math.max(maxTotalDiscountPercent, item.discount_amount_percent || 0);
+    });
+    total.discount_amount_net = moneyFromMinor(totalDiscountNetMinor);
+    total.discount_amount_gross = moneyFromMinor(totalDiscountGrossMinor);
+    total.discount_amount_percent = maxTotalDiscountPercent;
+    net_total.discount_amount_net = moneyFromMinor(totalDiscountNetMinor);
+    net_total.discount_amount_gross = moneyFromMinor(totalDiscountGrossMinor);
+    net_total.discount_amount_percent = maxTotalDiscountPercent;
+    const result = {
+        status,
+        erp_order_id,
+        centra_order_id: null,
+        sfcc_order_id,
+        globale_order_id: (() => {
+            const v = (invoice0?.globale_order_id ?? sale0?.globale_order_id ?? null);
+            if (typeof v !== 'string')
+                return v;
+            const s = v.trim();
+            return s.length > 0 ? s : null;
+        })(),
+        sitoo_order_id: null,
+        system_created_by,
+        ordered_at,
+        is_gift,
+        is_pos: created_by_raw === "SITOO",
+        billing_address: billing_from ? (() => {
+            const billToName = billing_from.bill_to_name || "";
+            const firstName = billing_from.bill_to_first_name || (billToName ? billToName.split(' ')[0] : "");
+            const lastName = billing_from.bill_to_surname || (billToName ? billToName.split(' ').slice(1).join(' ') : "");
+            return {
+                first_name: firstName,
+                last_name: lastName,
+                address1: billing_from.bill_to_address || "",
+                address2: billing_from.bill_to_address_2 || null,
+                city: billing_from.bill_to_city || "",
+                post_code: billing_from.bill_to_post_code || null,
+                country_code: billing_from.bill_to_country_region_code || "",
+                phone: billing_from.sell_to_phone_no || null,
+                created_at: (typeof billing_from.system_created_at === 'string' && billing_from.system_created_at) || undefined,
+            };
+        })() : null,
+        shipping_address: shipping_from ? (() => {
+            const shipToName = shipping_from.ship_to_name || "";
+            const firstName = shipping_from.ship_to_first_name || (shipToName ? shipToName.split(' ')[0] : "");
+            const lastName = shipping_from.ship_to_surname || (shipToName ? shipToName.split(' ').slice(1).join(' ') : "");
+            return {
+                first_name: firstName,
+                last_name: lastName,
+                address1: shipping_from.ship_to_address || "",
+                address2: shipping_from.ship_to_address_2 || null,
+                city: shipping_from.ship_to_city || "",
+                post_code: shipping_from.ship_to_post_code || null,
+                country_code: shipping_from.ship_to_country_region_code || "",
+                phone: shipping_from.ship_to_phone_no || null,
+                created_at: (typeof shipping_from.system_created_at === 'string' && shipping_from.system_created_at) || undefined,
+            };
+        })() : null,
+        customer: (() => {
+            const normalizeEmailOrNull = (v) => {
+                const s = String(v || "").trim().toLowerCase();
+                if (!s)
+                    return null;
+                return /.+@.+\..+/.test(s) ? s : null;
+            };
+            const c = payload.customer;
+            if (!c)
+                return undefined;
+            const mapped = {
+                first_name: c.first_name || "",
+                last_name: c.surname || "",
+                email: normalizeEmailOrNull(c.email),
+            };
+            if (c.no || payload.customer_no)
+                mapped.bc_customer_id = String(c.no || payload.customer_no);
+            const buildAddr = (src) => src ? {
+                first_name: src.bill_to_first_name || src.ship_to_first_name || "",
+                last_name: src.bill_to_surname || src.ship_to_surname || "",
+                address1: (src.bill_to_address || src.ship_to_address || ""),
+                address2: (src.bill_to_address_2 || src.ship_to_address_2 || null),
+                city: (src.bill_to_city || src.ship_to_city || ""),
+                post_code: (src.bill_to_post_code || src.ship_to_post_code || null),
+                country_code: (src.bill_to_country_region_code || src.ship_to_country_region_code || ""),
+                phone: (src.sell_to_phone_no || src.ship_to_phone_no || null),
+                created_at: (typeof src.system_created_at === 'string' && src.system_created_at) || undefined,
+            } : null;
+            const custBilling = buildAddr(billing_from);
+            const custShipping = buildAddr(shipping_from);
+            const addresses = [custBilling, custShipping].filter(Boolean);
+            if (addresses.length > 0)
+                mapped.addresses = addresses;
+            if (custShipping)
+                mapped.default_shipping_address = custShipping;
+            const addrPhone = (custShipping?.phone || custBilling?.phone || null);
+            const custPhone = (typeof c.phone_no === 'string' && c.phone_no.trim().length > 0) ? c.phone_no : null;
+            mapped.phone = custPhone || addrPhone || null;
+            const chosenAddr = custShipping || custBilling;
+            const custCreatedAt = (typeof c.system_created_at === 'string' && c.system_created_at) || null;
+            const addrCreatedAt = (chosenAddr && typeof chosenAddr.created_at === 'string') ? chosenAddr.created_at : null;
+            if (custCreatedAt)
+                mapped.registered_at = custCreatedAt;
+            else if (addrCreatedAt)
+                mapped.registered_at = addrCreatedAt;
+            return mapped;
+        })(),
+        items: itemsList,
+        total,
+        return_total,
+        net_total,
+        shipping_method,
+    };
+    if (payments.length > 0) {
+        result.payments = payments;
+    }
+    if (shipmentsWithItems.length > 0) {
+        result.shipments = shipmentsWithItems;
+    }
+    return result;
+}
+function validateOrder(order) {
+    const log = { log: () => { }, error: () => { } };
+    (0, validate_1.default)(order, order_schema_json_1.default, { log });
+}
+class BCOrderHelper extends runtime_1.default {
+    constructor(opts) {
+        super(opts);
+    }
+    transformMasterOrder(payload) {
+        return transformMasterOrder(payload);
+    }
+    validateOrder(order) {
+        return validateOrder(order);
+    }
+}
+exports.BCOrderHelper = BCOrderHelper;
+exports.default = BCOrderHelper;