@aptos-scp/scp-component-store-selling-features-domain-model 1.0.0

package/lib/domain/model/TenderType.js

@@ -0,0 +1,1317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+const I18n = require("i18n-js");
+const scp_component_business_core_1 = require("@aptos-scp/scp-component-business-core");
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const scp_component_store_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const scp_types_commerce_devices_1 = require("@aptos-scp/scp-types-commerce-devices");
+const scp_types_commerce_transaction_1 = require("@aptos-scp/scp-types-commerce-transaction");
+const ITendersConfig_1 = require("./configuration/ITendersConfig");
+const Constants_1 = require("./Constants");
+const ItemLine_1 = require("./item/ItemLine");
+const utility_1 = require("../utility");
+const TenderHandlingSession_1 = require("./TenderHandlingSession");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.tendertype");
+const mapTenderTypeToI18nCode = new Map([
+    [scp_types_commerce_devices_1.TenderType.Credit, "tenderTypeCredit"],
+    [scp_types_commerce_devices_1.TenderType.Debit, "tenderTypeDebit"],
+    [scp_types_commerce_devices_1.TenderType.Cash, "tenderTypeCash"],
+    [scp_types_commerce_devices_1.TenderType.PaymentDevice, "tenderTypePaymentDevice"],
+    [scp_types_commerce_devices_1.TenderType.Gift, "tenderTypeGift"],
+    [scp_types_commerce_devices_1.TenderType.ValueCertificate, "tenderTypeValueCertificate"],
+    [scp_types_commerce_devices_1.TenderType.Wallet, "tenderTypeWallet"],
+    [scp_types_commerce_devices_1.TenderType.Unknown, "tenderTypeUnknown"],
+]);
+//
+// Policies for each tender specifying when to capture a signature for the tender.
+// Not meaningful for TenderAuthCategory.None
+//
+var TenderSignatureCapturePolicy;
+(function (TenderSignatureCapturePolicy) {
+    TenderSignatureCapturePolicy["AuthResponseOnly"] = "AuthResponseOnly";
+    TenderSignatureCapturePolicy["ConfigurationOnly"] = "ConfigurationOnly";
+    TenderSignatureCapturePolicy["AuthResponseOrConfiguration"] = "AuthResponseOrConfiguration";
+})(TenderSignatureCapturePolicy = exports.TenderSignatureCapturePolicy || (exports.TenderSignatureCapturePolicy = {}));
+class TenderType {
+    constructor(id, tenderName, tenderTypeName, tenderAuthCategory, additionalTenderAuthCategories, cardType, signatureCapturePolicy, signatureCaptureFloorLimit, printDeclineTenderDetails, printDeclineTenderReceipt, printStoreTenderReceipt, allowPostVoid, allowCallForAuthorization, allowRefund, pluralTenderName, fiscalCode, fiscalType, tenderLabel, actions, overTenderRule, subType, customCardType, promptOnPartialApproval, pinRules, subscriptionEntryMethods, changeBehavior, isForeignTender, currencyCode, eligibleForTaxLottery, printVoidTenderDetails, printVoidTenderReceipt, cashoutThreshold) {
+        this._id = id;
+        this._tenderName = tenderName;
+        this._tenderTypeName = tenderTypeName;
+        this._tenderAuthCategory = tenderAuthCategory;
+        this._additionalTenderAuthCategories = additionalTenderAuthCategories;
+        this._cardType = cardType;
+        this._signatureCapturePolicy = signatureCapturePolicy;
+        this._signatureCaptureFloorLimit = signatureCaptureFloorLimit;
+        this._printDeclineTenderDetails = printDeclineTenderDetails;
+        this._printDeclineTenderReceipt = printDeclineTenderReceipt;
+        this._printStoreTenderReceipt = printStoreTenderReceipt;
+        this._allowPostVoid = allowPostVoid;
+        this._allowCallForAuthorization = allowCallForAuthorization;
+        this._allowRefund = allowRefund;
+        this._pluralTenderName = pluralTenderName;
+        this._fiscalCode = fiscalCode;
+        this._fiscalType = fiscalType;
+        this._tenderLabel = tenderLabel;
+        this._actions = actions;
+        this._overTenderRule = overTenderRule;
+        this._subType = subType;
+        this._customCardType = customCardType;
+        this._promptOnPartialApproval = promptOnPartialApproval;
+        this._pinRules = pinRules;
+        this._subscriptionEntryMethods = subscriptionEntryMethods;
+        this._changeBehavior = changeBehavior;
+        this._isForeignTender = isForeignTender;
+        this._currencyCode = currencyCode;
+        this._eligibleForTaxLottery = eligibleForTaxLottery;
+        this._printVoidTenderDetails = printVoidTenderDetails;
+        this._printVoidTenderReceipt = printVoidTenderReceipt;
+        this._cashoutThreshold = cashoutThreshold;
+    }
+    static getActiveConfiguredTenders(container, accountingCurrency) {
+        return TenderType.getActiveTenders(container, accountingCurrency, false, false, false, false);
+    }
+    static getActiveRefundConfiguredTenders(container, accountingCurrency, withTransaction, withOfflineTransaction) {
+        return TenderType.getActiveTenders(container, accountingCurrency, true, withTransaction, false, false, withOfflineTransaction);
+    }
+    static getActiveSuggestedRefundTenders(container, accountingCurrency, withMappedTender) {
+        return TenderType.getActiveTenders(container, accountingCurrency, true, true, true, withMappedTender);
+    }
+    static getActiveConfiguredTenderGroups(container, accountingCurrency, activeTenders) {
+        return TenderType.getActiveTenderGroupings(container, accountingCurrency, false, false, activeTenders);
+    }
+    static getActiveRefundConfiguredTenderGroups(container, accountingCurrency, withTransaction, activeTenders, originalTransactionsDetails, withOfflineTransaction) {
+        return TenderType.getActiveTenderGroupings(container, accountingCurrency, true, withTransaction, activeTenders, originalTransactionsDetails, withOfflineTransaction);
+    }
+    static getOriginalRefundableTenders(container, accountingCurrency, originalTransactionsDetails, balanceDue, itemTypes, orderTypes, isRefund, productAttributeTypes) {
+        var _a, _b, _c, _d;
+        const configurationManager = container.get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager);
+        const suggestedRefundTenders = TenderType.getActiveSuggestedRefundTenders(container, accountingCurrency);
+        let originalRefundableTenders = [];
+        let originalReferencedTenders = [];
+        const originalUnreferencedAndMappedTenders = [];
+        (_a = originalTransactionsDetails) === null || _a === void 0 ? void 0 : _a.forEach((origTranDetail) => {
+            var _a;
+            if ((_a = origTranDetail.originalTenders) === null || _a === void 0 ? void 0 : _a.length) {
+                origTranDetail.originalTenders.forEach((originalTender) => {
+                    var _a, _b;
+                    if (originalTender.refundAllowed) {
+                        const configuredTransactionReferenceTender = (_a = suggestedRefundTenders) === null || _a === void 0 ? void 0 : _a.find((tender) => tender.id === originalTender.tenderId);
+                        if (configuredTransactionReferenceTender) {
+                            if (originalTender.showReference) {
+                                originalReferencedTenders.push(originalTender);
+                            }
+                            else if (originalTender.tenderAuthCategory !== Constants_1.TenderAuthCategory.LoyaltyVoucherService) {
+                                combineOriginalUnreferencedAndMappedTenders(originalTender, originalUnreferencedAndMappedTenders);
+                            }
+                        }
+                        const configuredMappedTenders = getConfiguredMappedTenders(originalTender, configurationManager, origTranDetail.originalTransactionId, originalTransactionsDetails, balanceDue);
+                        (_b = configuredMappedTenders) === null || _b === void 0 ? void 0 : _b.forEach((mappedTender) => {
+                            combineOriginalUnreferencedAndMappedTenders(mappedTender, originalUnreferencedAndMappedTenders);
+                        });
+                    }
+                });
+            }
+        });
+        originalReferencedTenders = sortOriginalTenders(originalReferencedTenders);
+        originalRefundableTenders = [...originalReferencedTenders, ...originalUnreferencedAndMappedTenders];
+        originalRefundableTenders.forEach((tender) => {
+            tender.refundableAmount = getOriginalTenderRefundableAmount(tender, balanceDue, originalTransactionsDetails);
+        });
+        //Check if original tender is restricted by item/order type
+        if ((((_b = itemTypes) === null || _b === void 0 ? void 0 : _b.length) > 0 || ((_c = orderTypes) === null || _c === void 0 ? void 0 : _c.length) > 0 || ((_d = productAttributeTypes) === null || _d === void 0 ? void 0 : _d.length) > 0) && !isRefund) {
+            originalRefundableTenders = getRefundableTendersByPaymentRestrictions(originalRefundableTenders, itemTypes, container, orderTypes, productAttributeTypes);
+        }
+        return originalRefundableTenders;
+    }
+    static getDefaultConfiguredTenderType(container, accountingCurrency) {
+        const configurationManager = container.get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager);
+        const configuredTenders = configurationManager.getTendersValues().tenderDefinitions;
+        const defaultTenderId = configurationManager.getTendersValues().defaultTenderId;
+        const defaultConfiguredTender = configuredTenders.find((configuredTender) => configuredTender.tenderId === defaultTenderId);
+        return new TenderType(defaultConfiguredTender.tenderId, defaultConfiguredTender.tenderName, defaultConfiguredTender.tenderType, Constants_1.TenderAuthCategory[defaultConfiguredTender.tenderAuthCategory], scp_types_commerce_devices_1.CardType[defaultConfiguredTender.cardType], TenderSignatureCapturePolicy[defaultConfiguredTender.signatureCapturePolicy], defaultConfiguredTender.additionalTenderAuthCategories, defaultConfiguredTender.hasOwnProperty("signatureCaptureFloorLimit")
+            ? new scp_component_business_core_1.Money(defaultConfiguredTender.signatureCaptureFloorLimit, accountingCurrency)
+            : undefined, defaultConfiguredTender.printDeclineTenderDetails, defaultConfiguredTender.printDeclineTenderReceipt, defaultConfiguredTender.printStoreTenderReceipt, defaultConfiguredTender.allowPostVoid, defaultConfiguredTender.allowCallForAuthorization !== false, defaultConfiguredTender.allowRefund, defaultConfiguredTender.pluralTenderName, defaultConfiguredTender.fiscalCode, defaultConfiguredTender.fiscalType, defaultConfiguredTender.tenderLabel, defaultConfiguredTender.actions, defaultConfiguredTender.overTenderRule, defaultConfiguredTender.subType, defaultConfiguredTender.pinRules, defaultConfiguredTender.subscriptionEntryMethods, defaultConfiguredTender.changeBehavior, defaultConfiguredTender.isForeignTender, defaultConfiguredTender.currencyCode, defaultConfiguredTender.eligibleForTaxLottery, defaultConfiguredTender.printVoidTenderDetails, defaultConfiguredTender.printVoidTenderReceipt);
+    }
+    static createFromJsonObject(tenderTypeFromJson) {
+        let tenderType = undefined;
+        if (tenderTypeFromJson) {
+            tenderType = new TenderType(tenderTypeFromJson._id, tenderTypeFromJson._tenderName, tenderTypeFromJson._tenderTypeName, Constants_1.TenderAuthCategory[tenderTypeFromJson._tenderAuthCategory], tenderTypeFromJson._additionalTenderAuthCategories, scp_types_commerce_devices_1.CardType[tenderTypeFromJson._cardType], TenderSignatureCapturePolicy[tenderTypeFromJson._signatureCapturePolicy], tenderTypeFromJson._signatureCaptureFloorLimit
+                ? new scp_component_business_core_1.Money(tenderTypeFromJson._signatureCaptureFloorLimit)
+                : undefined, tenderTypeFromJson._printDeclineTenderDetails, tenderTypeFromJson._printDeclineTenderReceipt, tenderTypeFromJson._printStoreTenderReceipt, tenderTypeFromJson._allowPostVoid, tenderTypeFromJson._allowCallForAuthorization, tenderTypeFromJson._allowRefund, tenderTypeFromJson._pluralTenderName, tenderTypeFromJson._fiscalCode, tenderTypeFromJson._fiscalType, tenderTypeFromJson._tenderLabel, tenderTypeFromJson._actions, tenderTypeFromJson._overTenderRule, tenderTypeFromJson._subType, tenderTypeFromJson._customCardType, tenderTypeFromJson._promptOnPartialApproval, tenderTypeFromJson._pinRules, tenderTypeFromJson._subscriptionEntryMethods, tenderTypeFromJson._changeBehavior, tenderTypeFromJson._isForeignTender, tenderTypeFromJson._currencyCode, tenderTypeFromJson._eligibleForTaxLottery, tenderTypeFromJson._printVoidTenderDetails, tenderTypeFromJson._printVoidTenderReceipt, tenderTypeFromJson._cashoutThreshold ? new scp_component_business_core_1.Money(tenderTypeFromJson._cashoutThreshold) : undefined);
+        }
+        else if (tenderTypeFromJson === null) {
+            tenderType = null;
+        }
+        return tenderType;
+    }
+    signatureRequired(tenderAmount, authResponse) {
+        let sigRequired = false;
+        switch (this.signatureCapturePolicy) {
+            case TenderSignatureCapturePolicy.AuthResponseOnly:
+                sigRequired = authResponse.signatureRequired;
+                break;
+            case TenderSignatureCapturePolicy.ConfigurationOnly:
+                if (this.signatureCaptureFloorLimit) {
+                    sigRequired = tenderAmount.gte(this.signatureCaptureFloorLimit);
+                }
+                else {
+                    sigRequired = false;
+                }
+                break;
+            case TenderSignatureCapturePolicy.AuthResponseOrConfiguration:
+                sigRequired =
+                    authResponse.signatureRequired ||
+                        !!(this.signatureCaptureFloorLimit && tenderAmount.gte(this.signatureCaptureFloorLimit));
+                break;
+            default:
+                break;
+        }
+        return sigRequired;
+    }
+    getChangeTenderType(container, accountingCurrency, balanceDue, tenderAmount, authorizationFailed, changeDueAmount) {
+        var _a, _b, _c;
+        const validChangeTenderTypes = [];
+        if (this._changeBehavior) {
+            const changeDefinitions = getConfiguredChangeDefinitions(container);
+            const changeBehaviorDefinition = changeDefinitions && changeDefinitions[this._changeBehavior];
+            if ((_a = changeBehaviorDefinition) === null || _a === void 0 ? void 0 : _a.forfeitChange) {
+                return;
+            }
+            const changeTenderIds = getChangeTenderIdsByBehavior(this._changeBehavior, authorizationFailed, container, changeDueAmount || getChangeAmount(balanceDue, tenderAmount));
+            const activeTenders = TenderType.getActiveTenders(container, accountingCurrency, false, false, false, false);
+            if (changeTenderIds) {
+                (_b = _.uniq(changeTenderIds)) === null || _b === void 0 ? void 0 : _b.forEach((changeTenderId) => {
+                    const changeTenderType = changeTenderId && activeTenders.find((aTender) => aTender.id === changeTenderId);
+                    // We currently only support change to cash or store credit
+                    // if other tenders were configured fallback on default behavior
+                    if (changeTenderType &&
+                        (changeTenderType.tenderTypeName === scp_types_commerce_devices_1.TenderType.Cash ||
+                            (changeTenderType.tenderTypeName === scp_types_commerce_devices_1.TenderType.ValueCertificate &&
+                                changeTenderType.tenderAuthCategory === Constants_1.TenderAuthCategory.StoredValueCertificateService) ||
+                            changeTenderType.tenderTypeName === scp_types_commerce_devices_1.TenderType.Gift)) {
+                        validChangeTenderTypes.push(changeTenderType);
+                    }
+                });
+            }
+        }
+        if (((_c = validChangeTenderTypes) === null || _c === void 0 ? void 0 : _c.length) === 0 && !authorizationFailed) {
+            if (this._tenderAuthCategory === Constants_1.TenderAuthCategory.None ||
+                this._tenderAuthCategory === Constants_1.TenderAuthCategory.GiftDevice ||
+                this._tenderAuthCategory === Constants_1.TenderAuthCategory.StoredValueCardService) {
+                const cashTenders = TenderType.getActiveCashTenders(TenderType.getActiveTenders(container, accountingCurrency, false, false, false, false));
+                return [(cashTenders && cashTenders[0]) || this];
+            }
+            return [this];
+        }
+        else {
+            return validChangeTenderTypes;
+        }
+    }
+    get id() {
+        return this._id;
+    }
+    get tenderName() {
+        return this._tenderName;
+    }
+    get eligibleForTaxLottery() {
+        return this._eligibleForTaxLottery;
+    }
+    get tenderTypeName() {
+        return this._tenderTypeName;
+    }
+    get tenderAuthCategory() {
+        return this._tenderAuthCategory;
+    }
+    get additionalTenderAuthCategories() {
+        return this._additionalTenderAuthCategories;
+    }
+    get cardType() {
+        return this._cardType;
+    }
+    get customCardType() {
+        return this._customCardType;
+    }
+    get tenderLabel() {
+        return this._tenderLabel;
+    }
+    get actions() {
+        return this._actions;
+    }
+    get printDeclineTenderDetails() {
+        return this._printDeclineTenderDetails;
+    }
+    get printDeclineTenderReceipt() {
+        return this._printDeclineTenderReceipt;
+    }
+    get printStoreTenderReceipt() {
+        return this._printStoreTenderReceipt;
+    }
+    get printVoidTenderDetails() {
+        return this._printVoidTenderDetails;
+    }
+    get printVoidTenderReceipt() {
+        return this._printVoidTenderReceipt;
+    }
+    get promptOnPartialApproval() {
+        return this._promptOnPartialApproval;
+    }
+    get signatureCaptureFloorLimit() {
+        return this._signatureCaptureFloorLimit;
+    }
+    get signatureCapturePolicy() {
+        return this._signatureCapturePolicy;
+    }
+    get requiresAuth() {
+        return this._tenderAuthCategory !== Constants_1.TenderAuthCategory.None;
+    }
+    get allowPostVoid() {
+        return this._allowPostVoid;
+    }
+    get overTenderRule() {
+        return this._overTenderRule;
+    }
+    get allowCallForAuthorization() {
+        return this._allowCallForAuthorization;
+    }
+    get allowRefund() {
+        return this._allowRefund;
+    }
+    get pluralTenderName() {
+        return this._pluralTenderName;
+    }
+    get fiscalCode() {
+        return this._fiscalCode;
+    }
+    get fiscalType() {
+        return this._fiscalType;
+    }
+    get subType() {
+        return this._subType;
+    }
+    get pinRules() {
+        return this._pinRules;
+    }
+    get changeBehavior() {
+        return this._changeBehavior;
+    }
+    get isForeignTender() {
+        return this._isForeignTender;
+    }
+    get currencyCode() {
+        return this._currencyCode;
+    }
+    get subscriptionEntryMethods() {
+        return this._subscriptionEntryMethods;
+    }
+    get cashoutThreshold() {
+        return this._cashoutThreshold;
+    }
+    static getActiveTenders(container, accountingCurrency, isRefund, withTransaction, withReference, withMappedTender, withOfflineTransaction) {
+        const configurationManager = container.get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager);
+        const configuredTenders = configurationManager.getTendersValues().tenderDefinitions;
+        const activeTenders = configuredTenders
+            .filter((configuredTender) => tenderIsActive(configuredTender, isRefund, withTransaction, withReference, withMappedTender, withOfflineTransaction, accountingCurrency))
+            .map((configuredTender) => new TenderType(configuredTender.tenderId, configuredTender.tenderName, configuredTender.tenderType, Constants_1.TenderAuthCategory[configuredTender.tenderAuthCategory], configuredTender.additionalTenderAuthCategories, scp_types_commerce_devices_1.CardType[configuredTender.cardType], TenderSignatureCapturePolicy[configuredTender.signatureCapturePolicy], configuredTender.hasOwnProperty("signatureCaptureFloorLimit")
+            ? new scp_component_business_core_1.Money(configuredTender.signatureCaptureFloorLimit, accountingCurrency)
+            : undefined, configuredTender.printDeclineTenderDetails, configuredTender.printDeclineTenderReceipt, configuredTender.printStoreTenderReceipt, configuredTender.allowPostVoid, configuredTender.allowCallForAuthorization !== false, configuredTender.allowRefund, configuredTender.pluralTenderName, configuredTender.fiscalCode, configuredTender.fiscalType, configuredTender.tenderLabel, configuredTender.actions, configuredTender.overTenderRule && Constants_1.OverTenderRule[configuredTender.overTenderRule], configuredTender.subType, configuredTender.customCardType, configuredTender.promptOnPartialApproval, configuredTender.pinRules, configuredTender.subscriptionEntryMethods, configuredTender.changeBehavior, configuredTender.isForeignTender, configuredTender.currencyCode, configuredTender.eligibleForTaxLottery, configuredTender.printVoidTenderDetails, configuredTender.printVoidTenderReceipt, configuredTender.hasOwnProperty("cashoutThreshold")
+            ? new scp_component_business_core_1.Money(configuredTender.cashoutThreshold, accountingCurrency)
+            : undefined));
+        return activeTenders;
+    }
+    static filterActiveTenderIds(tenderIds, configuredTenders, isRefund, withTransaction, withOfflineTransaction, accountingCurrency) {
+        return (tenderIds &&
+            tenderIds.filter((tenderId) => {
+                const tenderDef = configuredTenders &&
+                    configuredTenders.find((configuredTender) => {
+                        return tenderId === configuredTender.tenderId;
+                    });
+                return tenderIsActive(tenderDef, isRefund, withTransaction, false, false, withOfflineTransaction, accountingCurrency);
+            }));
+    }
+    static tenderAuthCategoryIsActive(tenderAuthCategory, configuredTenders, isRefund, withTransaction, withOfflineTransaction, accountingCurrency) {
+        //search configured tenders for tenderAuthCategory and check if active
+        const activeTenderDef = configuredTenders.find((configuredTender) => {
+            var _a;
+            return ((tenderAuthCategory === configuredTender.tenderAuthCategory || ((_a = configuredTender.additionalTenderAuthCategories) === null || _a === void 0 ? void 0 : _a.includes(tenderAuthCategory))) &&
+                tenderIsActive(configuredTender, isRefund, withTransaction, false, false, withOfflineTransaction, accountingCurrency));
+        });
+        return !!activeTenderDef;
+    }
+    static getActiveTenderGroupings(container, accountingCurrency, isRefund, withTransaction, activeTenders, originalTransactionsDetails, withOfflineTransaction) {
+        const configurationManager = container.get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager);
+        const configuredTenderGroupings = configurationManager.getTendersUIValues().tenderGroupings;
+        return configuredTenderGroupings
+            ? TenderType.getActiveTenderGroupsByTenderGroupingsConfig(container, accountingCurrency, isRefund, withTransaction, configuredTenderGroupings, originalTransactionsDetails, withOfflineTransaction)
+            : TenderType.getActiveTenderGroupsByTenders(filterOriginalTenders(activeTenders, originalTransactionsDetails), isRefund);
+    }
+    static getActiveTenderGroupsByTenderGroupingsConfig(container, accountingCurrency, isRefund, withTransaction, configuredTenderGroupings, originalTransactionsDetails, withOfflineTransaction) {
+        var _a;
+        const configurationManager = container.get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager);
+        const configuredTenders = configurationManager.getTendersValues().tenderDefinitions;
+        const filteredConfiguredTenders = filterOriginalTenders(configuredTenders, originalTransactionsDetails);
+        const activeTendersGroups = (_a = configuredTenderGroupings) === null || _a === void 0 ? void 0 : _a.filter((configuredTenderGroup) => {
+            var _a;
+            if (configuredTenderGroup.hasOwnProperty("tenderIds")) {
+                //search configured tenders for id, filter out non active and return array if at least 1 is active
+                const activeTenders = TenderType.filterActiveTenderIds(configuredTenderGroup.tenderIds, filteredConfiguredTenders, isRefund, withTransaction, withOfflineTransaction, accountingCurrency);
+                return ((_a = activeTenders) === null || _a === void 0 ? void 0 : _a.length) > 0;
+            }
+            else if (configuredTenderGroup.hasOwnProperty("tenderAuthCategory")) {
+                return TenderType.tenderAuthCategoryIsActive(configuredTenderGroup.tenderAuthCategory, filterOriginalTenders(configuredTenders, originalTransactionsDetails, true), isRefund, withTransaction, withOfflineTransaction, accountingCurrency);
+            }
+        }).map((configuredTenderGroup) => ({
+            tenderAuthCategory: configuredTenderGroup.tenderAuthCategory,
+            tenderIds: TenderType.filterActiveTenderIds(configuredTenderGroup.tenderIds, filteredConfiguredTenders, isRefund, withTransaction, withOfflineTransaction, accountingCurrency),
+            groupLabel: configuredTenderGroup.groupButtonText,
+        }));
+        return handleValueCertificateGroup(activeTendersGroups, filterOriginalTenders(configuredTenders, originalTransactionsDetails, true), isRefund, withTransaction, withOfflineTransaction, accountingCurrency);
+    }
+    static getActiveTenderGroupsByTenders(activeTenders, isRefund) {
+        var _a;
+        const cashTenders = TenderType.getActiveCashTenders(activeTenders);
+        const cashTenderId = cashTenders && cashTenders.length > 0 && cashTenders[0] && cashTenders[0].id;
+        const cashGroups = cashTenders
+            .filter((tender) => !tender.isForeignTender)
+            .map((cashTender) => TenderType.convertTenderTypeToGroup(cashTender));
+        const noneGroups = activeTenders
+            .filter((tender) => tender.tenderAuthCategory === Constants_1.TenderAuthCategory.None && tender.id !== cashTenderId)
+            .map((tender) => {
+            return TenderType.convertTenderTypeToGroup(tender);
+        });
+        const cardGroup = activeTenders.find((tender) => tender.tenderAuthCategory === Constants_1.TenderAuthCategory.PaymentDevice)
+            ? [{ tenderAuthCategory: Constants_1.TenderAuthCategory.PaymentDevice }]
+            : [];
+        const ttpGroup = activeTenders.find((tender) => {
+            var _a;
+            return tender.tenderAuthCategory === Constants_1.TenderAuthCategory.TapToPayOnPOS || ((_a = tender.additionalTenderAuthCategories) === null || _a === void 0 ? void 0 : _a.includes(Constants_1.TenderAuthCategory.TapToPayOnPOS));
+        })
+            ? [{ tenderAuthCategory: Constants_1.TenderAuthCategory.TapToPayOnPOS }]
+            : [];
+        const nonIntegratedGroup = activeTenders.find((tender) => tender.tenderAuthCategory === Constants_1.TenderAuthCategory.NonIntegratedDevice)
+            ? [{ tenderAuthCategory: Constants_1.TenderAuthCategory.NonIntegratedDevice }]
+            : [];
+        let giftGroup = activeTenders.find((tender) => tender.tenderAuthCategory === Constants_1.TenderAuthCategory.GiftDevice)
+            ? [{ tenderAuthCategory: Constants_1.TenderAuthCategory.GiftDevice }]
+            : [];
+        if (!(giftGroup && giftGroup.length > 0)) {
+            giftGroup = activeTenders.find((tender) => tender.tenderAuthCategory === Constants_1.TenderAuthCategory.StoredValueCardService)
+                ? [{ tenderAuthCategory: Constants_1.TenderAuthCategory.StoredValueCardService }]
+                : [];
+        }
+        const valueCertificateGroup = ((_a = activeTenders
+            .filter((tender) => tender.tenderAuthCategory === Constants_1.TenderAuthCategory.StoredValueCertificateService)) === null || _a === void 0 ? void 0 : _a.map((certificateTender) => {
+            return {
+                tenderAuthCategory: Constants_1.TenderAuthCategory.StoredValueCertificateService,
+                groupLabel: { default: certificateTender.tenderName },
+                subType: certificateTender.subType,
+                tenderIds: [certificateTender.id],
+            };
+        })) || [];
+        const walletGroup = activeTenders.find((tender) => tender.tenderAuthCategory === Constants_1.TenderAuthCategory.Wallet)
+            ? [{ tenderAuthCategory: Constants_1.TenderAuthCategory.Wallet }]
+            : [];
+        const loyaltyGroup = activeTenders.find((tender) => tender.tenderAuthCategory === Constants_1.TenderAuthCategory.LoyaltyVoucherService)
+            ? [{ tenderAuthCategory: Constants_1.TenderAuthCategory.LoyaltyVoucherService }]
+            : [];
+        return [
+            ...cashGroups,
+            ...cardGroup,
+            ...ttpGroup,
+            ...nonIntegratedGroup,
+            ...giftGroup,
+            ...valueCertificateGroup,
+            ...walletGroup,
+            ...loyaltyGroup,
+            ...noneGroups,
+        ];
+    }
+    static convertTenderTypeToGroup(tender) {
+        return (tender && {
+            tenderAuthCategory: tender.tenderAuthCategory,
+            tenderIds: [tender.id],
+            groupLabel: tender.tenderLabel,
+        });
+    }
+    static getActiveCashTenders(activeTenders) {
+        return activeTenders.filter((aTender) => aTender.tenderTypeName === scp_types_commerce_devices_1.TenderType.Cash);
+    }
+}
+exports.TenderType = TenderType;
+function combineOriginalUnreferencedAndMappedTenders(tender, unreferencedAndMappedTenders) {
+    var _a;
+    const matchingUnreferencedTender = unreferencedAndMappedTenders.find((combinedTender) => (tender.tenderId && combinedTender.tenderId && combinedTender.tenderId === tender.tenderId) ||
+        //Cards and wallets will have different tenderIds
+        (tender.isMappedTender &&
+            combinedTender.isMappedTender &&
+            tender.tenderAuthCategory !== Constants_1.TenderAuthCategory.None &&
+            tender.tenderAuthCategory !== Constants_1.TenderAuthCategory.StoredValueCertificateService &&
+            tender.tenderType === combinedTender.tenderType));
+    if (matchingUnreferencedTender) {
+        if (tender.mappedOriginTenderId !== matchingUnreferencedTender.tenderId) {
+            matchingUnreferencedTender.refundedAmount = matchingUnreferencedTender.refundedAmount.plus(tender.refundedAmount);
+            matchingUnreferencedTender.previouslyRefundedAmount =
+                matchingUnreferencedTender.previouslyRefundedAmount.plus(tender.previouslyRefundedAmount);
+            matchingUnreferencedTender.originalTenderAmount = matchingUnreferencedTender.originalTenderAmount.plus(tender.originalTenderAmount);
+        }
+        if (matchingUnreferencedTender.adjustmentAmount &&
+            tender.adjustmentAmount &&
+            !_.isEqual(tender.originalTransactionReferences, matchingUnreferencedTender.originalTransactionReferences)) {
+            matchingUnreferencedTender.adjustmentAmount = matchingUnreferencedTender.adjustmentAmount.plus(tender.adjustmentAmount);
+        }
+        if (matchingUnreferencedTender.originalTransactionReferences) {
+            if (((_a = tender.originalTransactionReferences) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                tender.originalTransactionReferences.forEach((origTranRef) => {
+                    const matchingTranReference = matchingUnreferencedTender.originalTransactionReferences.find((ref) => ref.transactionLineReference.transactionId ===
+                        origTranRef.transactionLineReference.transactionId &&
+                        ref.transactionLineReference.lineNumber === origTranRef.transactionLineReference.lineNumber);
+                    if (matchingTranReference) {
+                        matchingTranReference.refundableAmount = origTranRef.refundableAmount;
+                    }
+                    else {
+                        matchingUnreferencedTender.originalTransactionReferences.push(origTranRef);
+                    }
+                });
+            }
+        }
+        else {
+            matchingUnreferencedTender.originalTransactionReferences = tender.originalTransactionReferences;
+        }
+    }
+    else {
+        unreferencedAndMappedTenders.push(tender);
+    }
+}
+function getOriginalTenderRefundableAmount(originalTender, refundDue, originalTransactionDetails) {
+    var _a;
+    if (!originalTender) {
+        return undefined;
+    }
+    let refundableAmount = new scp_component_business_core_1.Money(0, refundDue.currency);
+    const mergedTransactionReferences = [];
+    if (((_a = originalTender.originalTransactionReferences) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        originalTender.originalTransactionReferences.forEach((ref) => {
+            const matchingRef = mergedTransactionReferences.find((matching) => matching.transactionLineReference.transactionId === ref.transactionLineReference.transactionId);
+            if (matchingRef) {
+                matchingRef.refundableAmount = matchingRef.refundableAmount.plus(ref.refundableAmount);
+            }
+            else {
+                mergedTransactionReferences.push(Object.assign({}, ref));
+            }
+        });
+        mergedTransactionReferences.forEach((origTranRef) => {
+            var _a, _b;
+            const originalTenderReferenceTranId = (_a = origTranRef.transactionLineReference) === null || _a === void 0 ? void 0 : _a.transactionId;
+            const originalTran = (_b = originalTransactionDetails) === null || _b === void 0 ? void 0 : _b.find((origTran) => origTran.originalTransactionId === originalTenderReferenceTranId);
+            if (refundDue) {
+                const returnTotalAmount = getReturnOrCancelTotalAmount(originalTran);
+                // If transaction was partially returned, tranRef.refundableAmount will have the full original tender amount, default to the partial return total amount
+                const originalTenderAmount = getLowestRefundDue(undefined, returnTotalAmount, adjustAmount(origTranRef.refundableAmount, originalTender.adjustmentAmount));
+                // Mapped tenders will only use their transaction references for refund amount calculation, if they have been fully tendered,
+                // they will not have transaction references, do not subtract refunded amount
+                const currentTranRefundableAmount = calculateRefundableAmount(originalTenderAmount, originalTender.isMappedTender ? undefined : originalTender.refundedAmount, returnTotalAmount, refundDue);
+                // Multi receipt transactions with the same mapped tender will have have multiple transaction references, refundDue will be the total
+                // of the current transaction, returnTotal amount is the original total of the individual transactions. Do not allow refundable amount
+                // to be greater than the refundDue, do not account for the individual original totals here or the amounts won't be combined
+                refundableAmount = getLowestRefundDue(refundableAmount.plus(currentTranRefundableAmount), undefined, refundDue);
+            }
+        });
+    }
+    return originalTender.isMappedTender
+        ? refundableAmount
+        : (refundableAmount.ne(new scp_component_business_core_1.Money(0, refundDue.currency)) && refundableAmount) ||
+            originalTender.refundedAmount;
+}
+function getLowestRefundDue(refundDue, returnTotalAmount, remainingTenderAmount) {
+    const lowestRefundDue = returnTotalAmount && refundDue && returnTotalAmount.gt(refundDue)
+        ? refundDue
+        : returnTotalAmount || refundDue;
+    return ((remainingTenderAmount && lowestRefundDue && remainingTenderAmount.gt(lowestRefundDue)
+        ? lowestRefundDue
+        : remainingTenderAmount) || lowestRefundDue);
+}
+function calculateRefundableAmount(originalTenderAmount, refundedAmount, returnTotalAmount, refundDue) {
+    const remainingTenderAmount = (refundedAmount && originalTenderAmount && originalTenderAmount.minus(refundedAmount)) ||
+        originalTenderAmount;
+    return getLowestRefundDue(refundDue, returnTotalAmount, remainingTenderAmount);
+}
+function getConfiguredMappedTenders(originalTender, configurationManager, transactionId, originalTransactions, refundDue) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const mappedTenders = [];
+    const tenderConfig = (_a = configurationManager) === null || _a === void 0 ? void 0 : _a.getTendersValues();
+    const tenderTypeBehaviors = (_c = (_b = tenderConfig) === null || _b === void 0 ? void 0 : _b.tenderBehaviors) === null || _c === void 0 ? void 0 : _c.tenderTypeBehaviors;
+    const tenderDefinitions = (_d = tenderConfig) === null || _d === void 0 ? void 0 : _d.tenderDefinitions;
+    const configuredTender = (_e = tenderDefinitions) === null || _e === void 0 ? void 0 : _e.find((tender) => tender.tenderId === originalTender.tenderId);
+    const tenderTypeBehavior = configuredTender && tenderTypeBehaviors && tenderTypeBehaviors[configuredTender.tenderType];
+    const refundTenderTypes = (_f = tenderTypeBehavior) === null || _f === void 0 ? void 0 : _f.refundTenderTypes;
+    const mappedTenderTypeNames = refundTenderTypes &&
+        Object.keys(refundTenderTypes).filter((tenderType) => {
+            const mappedRefundTenderType = refundTenderTypes[tenderType];
+            return (mappedRefundTenderType &&
+                (!mappedRefundTenderType.hasOwnProperty("allowed") || mappedRefundTenderType["allowed"] === true) &&
+                allowMappedTender(tenderType, tenderConfig) &&
+                isOriginalTenderAmountAllowed(originalTender, mappedRefundTenderType, originalTransactions, refundDue));
+        });
+    (_g = mappedTenderTypeNames) === null || _g === void 0 ? void 0 : _g.forEach((tenderType) => {
+        var _a;
+        // For TenderAuthCategory: None tenders and Value certificate tenders need to have a tenderId, so we'll have one mapped tender for each
+        // of those tenders.
+        const tenderDefs = tenderDefinitions.filter((tenderDef) => {
+            var _a;
+            return tenderDef.tenderType === tenderType &&
+                ((_a = tenderDef.allowRefund) === null || _a === void 0 ? void 0 : _a.indexOf("WhenMapped")) > -1 &&
+                (tenderDef.tenderAuthCategory === Constants_1.TenderAuthCategory.None ||
+                    tenderDef.tenderAuthCategory === Constants_1.TenderAuthCategory.StoredValueCertificateService ||
+                    tenderDef.tenderAuthCategory === Constants_1.TenderAuthCategory.GiftDevice);
+        });
+        if ((_a = tenderDefs) === null || _a === void 0 ? void 0 : _a.length) {
+            tenderDefs.forEach((tenderDef) => {
+                const label = tenderDef.tenderType === scp_types_commerce_devices_1.TenderType.Cash
+                    ? I18n.t(mapTenderTypeToI18nCode.get(tenderType), { defaultValue: tenderDef.tenderName })
+                    : (tenderDef.tenderLabel &&
+                        I18n.t(tenderDef.tenderLabel.i18nCode, {
+                            defaultValue: tenderDef.tenderLabel.default,
+                        })) ||
+                        tenderDef.tenderName;
+                mappedTenders.push(buildMappedOriginalTender(originalTender, label, tenderDef.tenderType, tenderDef.tenderId, tenderDef.tenderAuthCategory, transactionId, originalTransactions, tenderDef.subType));
+            });
+        }
+        else {
+            const tenderName = I18n.t(mapTenderTypeToI18nCode.get(tenderType), { defaultValue: tenderType });
+            mappedTenders.push(buildMappedOriginalTender(originalTender, tenderName, tenderType, undefined, getTenderAuthCategoryFromTenderType(tenderType), transactionId, originalTransactions, undefined));
+        }
+    });
+    return mappedTenders;
+}
+function getActiveTendersByConfiguredPaymentRestrictions(activeTenderTypes, saleItemTypes, diContainer, orderTypes, productAttributeTypes) {
+    let nonRestrictedTenderTypes = [];
+    let restrictedTenderTypes = [];
+    activeTenderTypes.forEach((activeTenderType) => {
+        var _a, _b, _c, _d, _e, _f;
+        if (!isRestrictedTenderType(restrictedTenderTypes, activeTenderType)) {
+            const paymentRestrictionBehaviors = getPaymentRestrictionBehaviors(diContainer, activeTenderType.tenderTypeName);
+            //ignore paymentRestrictions for credit/debit tenders
+            if (paymentRestrictionBehaviors && !isCreditDebitTenderType(activeTenderType.tenderTypeName)) {
+                const configuredItemTypePaymentRestrictions = paymentRestrictionBehaviors.itemType;
+                const configuredOrderTypePaymentRestrictions = paymentRestrictionBehaviors.orderType;
+                const configuredItemAttributePaymentRestrictions = paymentRestrictionBehaviors.itemAttribute;
+                if (((_a = configuredItemTypePaymentRestrictions) === null || _a === void 0 ? void 0 : _a.length) > 0 ||
+                    ((_b = configuredOrderTypePaymentRestrictions) === null || _b === void 0 ? void 0 : _b.length) > 0 ||
+                    ((_c = configuredItemAttributePaymentRestrictions) === null || _c === void 0 ? void 0 : _c.length) > 0) {
+                    (_d = configuredItemTypePaymentRestrictions) === null || _d === void 0 ? void 0 : _d.map((itemType) => {
+                        var _a;
+                        const restrictedItemType = (_a = saleItemTypes) === null || _a === void 0 ? void 0 : _a.find((item) => item === itemType);
+                        if (restrictedItemType && !isRestrictedTenderType(restrictedTenderTypes, activeTenderType)) {
+                            restrictedTenderTypes.push(activeTenderType);
+                        }
+                    });
+                    (_e = configuredOrderTypePaymentRestrictions) === null || _e === void 0 ? void 0 : _e.map((orderType) => {
+                        var _a;
+                        const restrictedOrderType = (_a = orderTypes) === null || _a === void 0 ? void 0 : _a.find((item) => item === orderType);
+                        if (restrictedOrderType && !isRestrictedTenderType(restrictedTenderTypes, activeTenderType)) {
+                            restrictedTenderTypes.push(activeTenderType);
+                        }
+                    });
+                    (_f = configuredItemAttributePaymentRestrictions) === null || _f === void 0 ? void 0 : _f.map((itemAttribute) => {
+                        var _a;
+                        const restrictedItemAttribute = (_a = productAttributeTypes) === null || _a === void 0 ? void 0 : _a.find((item) => item === itemAttribute);
+                        if (restrictedItemAttribute && !isRestrictedTenderType(restrictedTenderTypes, activeTenderType)) {
+                            restrictedTenderTypes.push(activeTenderType);
+                        }
+                    });
+                    if (!isRestrictedTenderType(restrictedTenderTypes, activeTenderType)) {
+                        nonRestrictedTenderTypes.push(activeTenderType);
+                    }
+                }
+                else {
+                    nonRestrictedTenderTypes.push(activeTenderType);
+                }
+            }
+            else {
+                nonRestrictedTenderTypes.push(activeTenderType);
+            }
+        }
+    });
+    if (nonRestrictedTenderTypes.length > 0) {
+        return nonRestrictedTenderTypes;
+    }
+    return activeTenderTypes;
+}
+exports.getActiveTendersByConfiguredPaymentRestrictions = getActiveTendersByConfiguredPaymentRestrictions;
+function isCreditDebitTenderType(tenderTypeName) {
+    return tenderTypeName === "Credit" || tenderTypeName === "Debit";
+}
+function isRestrictedTenderType(restrictedTenderTypes, activeTenderType) {
+    var _a;
+    return !!(((_a = restrictedTenderTypes) === null || _a === void 0 ? void 0 : _a.length) > 0 &&
+        restrictedTenderTypes.find((restrictedTenderType) => restrictedTenderType.tenderTypeName === activeTenderType.tenderTypeName));
+}
+function isOriginalRefundableTenderTypeRestricted(restrictedTenders, originalRefundableTender) {
+    var _a;
+    return !!(((_a = restrictedTenders) === null || _a === void 0 ? void 0 : _a.length) > 0 &&
+        restrictedTenders.find((restrictedTender) => restrictedTender.tenderType === originalRefundableTender.tenderType));
+}
+function getRefundableTendersByPaymentRestrictions(originalRefundableTenders, saleItemTypes, diContainer, orderTypes, productAttributeTypes) {
+    let nonRestrictedTenders = [];
+    let restrictedTenders = [];
+    originalRefundableTenders.forEach((originalRefundableTender) => {
+        var _a, _b, _c, _d, _e, _f;
+        if (!isOriginalRefundableTenderTypeRestricted(restrictedTenders, originalRefundableTender)) {
+            const paymentRestrictionBehaviors = originalRefundableTender.tenderType &&
+                getPaymentRestrictionBehaviors(diContainer, originalRefundableTender.tenderType.toString());
+            if (paymentRestrictionBehaviors &&
+                !isCreditDebitTenderType(originalRefundableTender.tenderType.toString())) {
+                const configuredItemTypePaymentRestrictions = paymentRestrictionBehaviors.itemType;
+                const configuredOrderTypePaymentRestrictions = paymentRestrictionBehaviors.orderType;
+                const configuredItemAttributePaymentRestrictions = paymentRestrictionBehaviors.itemAttribute;
+                if (((_a = configuredItemTypePaymentRestrictions) === null || _a === void 0 ? void 0 : _a.length) > 0 ||
+                    ((_b = configuredOrderTypePaymentRestrictions) === null || _b === void 0 ? void 0 : _b.length) > 0 ||
+                    ((_c = configuredItemAttributePaymentRestrictions) === null || _c === void 0 ? void 0 : _c.length) > 0) {
+                    (_d = configuredItemTypePaymentRestrictions) === null || _d === void 0 ? void 0 : _d.map((itemType) => {
+                        var _a;
+                        const restrictedItemType = (_a = saleItemTypes) === null || _a === void 0 ? void 0 : _a.find((item) => item === itemType);
+                        if (restrictedItemType &&
+                            !isOriginalRefundableTenderTypeRestricted(restrictedTenders, originalRefundableTender)) {
+                            restrictedTenders.push(originalRefundableTender);
+                        }
+                    });
+                    (_e = configuredOrderTypePaymentRestrictions) === null || _e === void 0 ? void 0 : _e.map((orderType) => {
+                        var _a;
+                        const restrictedOrderType = (_a = orderTypes) === null || _a === void 0 ? void 0 : _a.find((item) => item === orderType);
+                        if (restrictedOrderType &&
+                            !isOriginalRefundableTenderTypeRestricted(restrictedTenders, originalRefundableTender)) {
+                            restrictedTenders.push(originalRefundableTender);
+                        }
+                    });
+                    (_f = configuredItemAttributePaymentRestrictions) === null || _f === void 0 ? void 0 : _f.map((itemAttribute) => {
+                        var _a;
+                        const restrictedItemAttribute = (_a = productAttributeTypes) === null || _a === void 0 ? void 0 : _a.find((item) => item === itemAttribute);
+                        if (restrictedItemAttribute &&
+                            !isOriginalRefundableTenderTypeRestricted(restrictedTenders, originalRefundableTender)) {
+                            restrictedTenders.push(originalRefundableTender);
+                        }
+                    });
+                    if (!isOriginalRefundableTenderTypeRestricted(restrictedTenders, originalRefundableTender)) {
+                        nonRestrictedTenders.push(originalRefundableTender);
+                    }
+                }
+                else {
+                    nonRestrictedTenders.push(originalRefundableTender);
+                }
+            }
+            else {
+                nonRestrictedTenders.push(originalRefundableTender);
+            }
+        }
+    });
+    if (nonRestrictedTenders.length > 0) {
+        return nonRestrictedTenders;
+    }
+    return originalRefundableTenders;
+}
+exports.getRefundableTendersByPaymentRestrictions = getRefundableTendersByPaymentRestrictions;
+function getSaleItemTypes(transaction) {
+    var _a;
+    const saleItemTypes = [];
+    (_a = transaction.lines) === null || _a === void 0 ? void 0 : _a.forEach((line) => {
+        if ((ItemLine_1.isItemLine(line) && !line.voided && line.lineType === scp_types_commerce_transaction_1.LineType.ItemSale) ||
+            line.lineType === scp_types_commerce_transaction_1.LineType.ItemOrder) {
+            switch (line.itemType) {
+                case scp_types_commerce_transaction_1.ItemType.NonMerch:
+                    if (!saleItemTypes.includes("NonMerch")) {
+                        saleItemTypes.push("NonMerch");
+                    }
+                    break;
+                case scp_types_commerce_transaction_1.ItemType.Merchandise:
+                    if (!saleItemTypes.includes("Merchandise")) {
+                        saleItemTypes.push("Merchandise");
+                    }
+                    break;
+                case scp_types_commerce_transaction_1.ItemType.ValueCard:
+                    if (!saleItemTypes.includes("ValueCard")) {
+                        saleItemTypes.push("ValueCard");
+                    }
+                    break;
+                case scp_types_commerce_transaction_1.ItemType.ValueCertificate:
+                    if (!saleItemTypes.includes("ValueCertificate")) {
+                        saleItemTypes.push("ValueCertificate");
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    });
+    return saleItemTypes;
+}
+exports.getSaleItemTypes = getSaleItemTypes;
+function getOrderTypes(transaction) {
+    var _a;
+    const orderTypes = [];
+    let isPickup;
+    let isDelivery;
+    let isSendSale;
+    const order = transaction.order;
+    if (order) {
+        (_a = transaction.lines) === null || _a === void 0 ? void 0 : _a.forEach((line) => {
+            if (ItemLine_1.isItemLine(line) && !line.voided) {
+                if (line.lineType === scp_types_commerce_transaction_1.LineType.ItemOrder) {
+                    const orderFulfillmentType = utility_1.getOrderFulfillmentType(transaction, line.fulfillmentGroupId);
+                    if (orderFulfillmentType === scp_types_commerce_transaction_1.FulfillmentType.shipToStore && !isPickup) {
+                        isPickup = true;
+                    }
+                    if (orderFulfillmentType === scp_types_commerce_transaction_1.FulfillmentType.shipToCustomer && !isDelivery) {
+                        isDelivery = true;
+                    }
+                }
+                else if (line.lineType === scp_types_commerce_transaction_1.LineType.ItemSale) {
+                    if (line.sendSale) {
+                        isSendSale = true;
+                    }
+                }
+            }
+        });
+    }
+    if (isPickup && !orderTypes.includes("Pickup")) {
+        orderTypes.push("Pickup");
+    }
+    if (isDelivery && !orderTypes.includes("Delivery")) {
+        orderTypes.push("Delivery");
+    }
+    if (isSendSale && !orderTypes.includes("SendSale")) {
+        orderTypes.push("SendSale");
+    }
+    return orderTypes;
+}
+exports.getOrderTypes = getOrderTypes;
+function getProductAttributeTypes(transaction) {
+    var _a;
+    const productAttributes = [];
+    (_a = transaction.lines) === null || _a === void 0 ? void 0 : _a.forEach((line) => {
+        var _a, _b, _c;
+        if (ItemLine_1.isItemLine(line) && !line.voided && ((_b = (_a = line.item) === null || _a === void 0 ? void 0 : _a.productAttributes) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+            (_c = line.item) === null || _c === void 0 ? void 0 : _c.productAttributes.forEach((productAttribute) => {
+                if (!productAttributes.includes(productAttribute.attributeType)) {
+                    productAttributes.push(productAttribute.attributeType);
+                }
+            });
+        }
+    });
+    return productAttributes;
+}
+exports.getProductAttributeTypes = getProductAttributeTypes;
+function transactionHasPaymentRestrictionTypes(itemTypes, orderTypes, productAttributeTypes) {
+    var _a, _b, _c;
+    return ((_a = orderTypes) === null || _a === void 0 ? void 0 : _a.length) > 0 || ((_b = itemTypes) === null || _b === void 0 ? void 0 : _b.length) > 0 || ((_c = productAttributeTypes) === null || _c === void 0 ? void 0 : _c.length) > 0 ? true : false;
+}
+exports.transactionHasPaymentRestrictionTypes = transactionHasPaymentRestrictionTypes;
+function getPaymentRestrictionBehaviors(diContainer, tenderType) {
+    const configurationManager = diContainer.get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager);
+    const tenderConfig = configurationManager && configurationManager.getTendersValues();
+    const tenderTypeBehaviors = tenderConfig && tenderConfig.tenderBehaviors && tenderConfig.tenderBehaviors.tenderTypeBehaviors;
+    const tenderTypeBehavior = tenderTypeBehaviors && tenderTypeBehaviors[tenderType];
+    return tenderTypeBehavior && tenderTypeBehavior.paymentRestrictionBehaviors;
+}
+exports.getPaymentRestrictionBehaviors = getPaymentRestrictionBehaviors;
+function isPaymentRestrictionBehaviorsConfigured(diContainer, activeTenderTypes) {
+    const configurationManager = diContainer.get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager);
+    const tenderConfig = configurationManager && configurationManager.getTendersValues();
+    const tenderTypeBehaviors = tenderConfig && tenderConfig.tenderBehaviors && tenderConfig.tenderBehaviors.tenderTypeBehaviors;
+    if (!tenderTypeBehaviors) {
+        return false;
+    }
+    const tenderTypeHasPaymentRestrictionBehaviors = activeTenderTypes.some((activeTenderType) => {
+        const paymentRestrictionBehaviors = getPaymentRestrictionBehaviors(diContainer, activeTenderType.tenderTypeName);
+        return paymentRestrictionBehaviors;
+    });
+    return tenderTypeHasPaymentRestrictionBehaviors;
+}
+exports.isPaymentRestrictionBehaviorsConfigured = isPaymentRestrictionBehaviorsConfigured;
+function sortOriginalTenders(originalTenders) {
+    var _a;
+    return (_a = originalTenders) === null || _a === void 0 ? void 0 : _a.sort((a, b) => {
+        return a.originalTenderAmount.gt(b.originalTenderAmount) ? -1 : 0;
+    });
+}
+function allowMappedTender(tenderType, tenderConfig) {
+    return tenderConfig.tenderDefinitions.some((tender) => { var _a; return tender.tenderType === tenderType && ((_a = tender.allowRefund) === null || _a === void 0 ? void 0 : _a.indexOf("WhenMapped")) > -1; });
+}
+function adjustAmount(amount, adjustmentAmount) {
+    var _a;
+    return (adjustmentAmount && ((_a = amount) === null || _a === void 0 ? void 0 : _a.plus(adjustmentAmount))) || amount;
+}
+function buildMappedOriginalTender(originalTender, tenderName, tenderType, tenderId, tenderAuthCategory, transactionId, originalTransactions, subType) {
+    var _a;
+    const originalTran = (_a = originalTransactions) === null || _a === void 0 ? void 0 : _a.find((origTran) => origTran.originalTransactionId === transactionId);
+    const returnTotalAmount = getReturnOrCancelTotalAmount(originalTran);
+    const tenderTypeName = tenderType;
+    return {
+        showReference: false,
+        isMappedTender: true,
+        tenderAuthCategory,
+        tenderId,
+        tenderName,
+        tenderType: tenderTypeName,
+        subType,
+        originalTransactionReferences: isOriginalTenderFullyRefunded(originalTender, returnTotalAmount)
+            ? undefined
+            : TenderHandlingSession_1.getOriginalTransactionReferences(transactionId, originalTender.originalLineReferences),
+        originalTenderAmount: originalTender.originalTenderAmount,
+        refundedAmount: originalTender.refundedAmount,
+        previouslyRefundedAmount: originalTender.previouslyRefundedAmount,
+        adjustmentAmount: originalTender.adjustmentAmount,
+        adjustmentType: originalTender.adjustmentType,
+        refundAllowed: isOriginalTenderFullyRefunded(originalTender, returnTotalAmount),
+        originalLineReferences: undefined,
+        mappedOriginTenderId: originalTender.tenderId,
+    };
+}
+function isOriginalTenderFullyRefunded(originalTender, returnTotalAmount) {
+    const totalRefundedAmount = originalTender &&
+        calculateTotalRefundedAmount(originalTender.previouslyRefundedAmount, originalTender.refundedAmount);
+    const adjustedOriginalTenderAmount = adjustAmount(originalTender.originalTenderAmount, originalTender.adjustmentAmount);
+    return ((totalRefundedAmount && totalRefundedAmount.gte(adjustedOriginalTenderAmount)) ||
+        originalTender.refundedAmount.gte(returnTotalAmount));
+}
+function calculateTotalRefundedAmount(previouslyRefundedAmount, refundedAmount) {
+    if (previouslyRefundedAmount && refundedAmount) {
+        return previouslyRefundedAmount.plus(refundedAmount);
+    }
+    else {
+        return previouslyRefundedAmount || refundedAmount;
+    }
+}
+function isOriginalTenderAmountAllowed(originalTender, refundRules, originalTransactionDetailsInfo, refundDue) {
+    if (refundRules && (refundRules.minimumAmount || refundRules.maximumAmount)) {
+        const refundableAmount = getRefundableAmountByTenderType(originalTender.tenderType, originalTransactionDetailsInfo, refundDue);
+        const maximumAmount = refundRules.maximumAmount && new scp_component_business_core_1.Money(refundRules.maximumAmount, refundDue.currency);
+        const minimumAmount = refundRules.minimumAmount && new scp_component_business_core_1.Money(refundRules.minimumAmount, refundDue.currency);
+        return (refundableAmount &&
+            (!maximumAmount || refundableAmount.lte(maximumAmount)) &&
+            (!minimumAmount || refundableAmount.gte(minimumAmount)));
+    }
+    return true;
+}
+function getRefundableAmountByTenderType(tenderType, originalTransactionsDetails, refundDue) {
+    var _a, _b;
+    if (refundDue) {
+        let totalRefundableAmount = new scp_component_business_core_1.Money("0", (_a = refundDue) === null || _a === void 0 ? void 0 : _a.currency);
+        (_b = originalTransactionsDetails) === null || _b === void 0 ? void 0 : _b.forEach((originalTransaction) => {
+            var _a, _b;
+            const filteredOriginalTenders = (_a = originalTransaction.originalTenders) === null || _a === void 0 ? void 0 : _a.filter((originalTender) => originalTender.tenderType === tenderType);
+            (_b = filteredOriginalTenders) === null || _b === void 0 ? void 0 : _b.forEach((tenderDetails) => {
+                const returnTotalAmount = getReturnOrCancelTotalAmount(originalTransaction);
+                const tenderRefundableAmount = calculateRefundableAmount(tenderDetails.originalTenderAmount, tenderDetails.refundedAmount, returnTotalAmount, refundDue);
+                if (tenderRefundableAmount) {
+                    totalRefundableAmount = totalRefundableAmount.plus(tenderRefundableAmount);
+                }
+            });
+        });
+        return totalRefundableAmount;
+    }
+}
+function isReferencedRefundTender(tenderType) {
+    var _a, _b;
+    return (((_a = tenderType) === null || _a === void 0 ? void 0 : _a.tenderAuthCategory) === Constants_1.TenderAuthCategory.PaymentDevice ||
+        ((_b = tenderType) === null || _b === void 0 ? void 0 : _b.tenderAuthCategory) === Constants_1.TenderAuthCategory.Wallet);
+}
+function handleValueCertificateGroup(tenderGroups, configuredTenders, isRefund, withTransaction, withOfflineTransaction, accountingCurrency) {
+    if (isRefund &&
+        tenderGroups.some((group) => group.tenderAuthCategory === Constants_1.TenderAuthCategory.StoredValueCertificateService)) {
+        const filteredGroups = tenderGroups.filter((group) => group.tenderAuthCategory !== Constants_1.TenderAuthCategory.StoredValueCertificateService) || [];
+        configuredTenders.forEach((tender) => {
+            if (tender.tenderAuthCategory === Constants_1.TenderAuthCategory.StoredValueCertificateService &&
+                tenderIsActive(tender, isRefund, withTransaction, false, false, withOfflineTransaction, accountingCurrency)) {
+                filteredGroups.push({
+                    tenderAuthCategory: Constants_1.TenderAuthCategory.StoredValueCertificateService,
+                    groupLabel: { default: tender.tenderName },
+                    subType: tender.subType,
+                });
+            }
+        });
+        return filteredGroups;
+    }
+    else {
+        return tenderGroups;
+    }
+}
+function filterOriginalTenders(activeTenders, originalTransactionsDetails, ignoreReferencedTenders) {
+    var _a;
+    if (activeTenders && ((_a = originalTransactionsDetails) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        originalTransactionsDetails.forEach((originalTransaction) => {
+            var _a;
+            if (((_a = originalTransaction.originalTenders) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                originalTransaction.originalTenders.forEach((tender) => {
+                    var _a, _b;
+                    const tenderConfig = activeTenders.find((configuredTender) => configuredTender.tenderId === tender.tenderId || configuredTender.id === tender.tenderId);
+                    const allowRefund = (_a = tenderConfig) === null || _a === void 0 ? void 0 : _a.allowRefund;
+                    if (((_b = allowRefund) === null || _b === void 0 ? void 0 : _b.indexOf(ITendersConfig_1.AllowRefund.WithOriginalTenderReference)) !== -1) {
+                        activeTenders = activeTenders.filter((tenderType) => (ignoreReferencedTenders && isReferencedRefundTender(tenderType)) ||
+                            (tenderType.id !== tender.tenderId && tenderType.tenderId !== tender.tenderId));
+                    }
+                });
+            }
+        });
+    }
+    return activeTenders;
+}
+function tenderIsActive(tenderDef, isRefund, withTransaction, withReference, mappedTender, offlineTransaction, accountingCurrency) {
+    if (tenderDef && (!tenderDef.hasOwnProperty("active") || tenderDef.active)) {
+        if (tenderDef.isForeignTender && tenderDef.currencyCode === accountingCurrency) {
+            return false;
+        }
+        if (isRefund) {
+            if (tenderDef.hasOwnProperty("allowRefund") && tenderDef.allowRefund.length > 0) {
+                return (tenderDef.allowRefund
+                    .map((option) => {
+                    switch (option) {
+                        case ITendersConfig_1.AllowRefund.WithoutTransaction:
+                            return !withTransaction && !offlineTransaction;
+                        case ITendersConfig_1.AllowRefund.WithOriginalTenderReference:
+                            return withReference;
+                        case ITendersConfig_1.AllowRefund.WhenMapped:
+                            return mappedTender;
+                        case ITendersConfig_1.AllowRefund.WithTransaction:
+                            return withTransaction && !withReference;
+                        case ITendersConfig_1.AllowRefund.WithOfflineTransaction:
+                            return offlineTransaction;
+                        default:
+                            return false;
+                    }
+                })
+                    .findIndex((result) => result) !== -1);
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    return false;
+}
+exports.tenderIsActive = tenderIsActive;
+//
+// Find/return the single matching, active configured tender that is identified by the given IAuthorizationResponse.
+// NOTE:  This qualification must never reject (throw QualificationError) even if no matching tender can be found.
+//        This because the given IAuthorizationResponse may well represent an authorized, collected tender!
+//        If we cannot find a matching TenderType to return, we return instead a string containing a technical
+//        message suitable for logging.
+// Matching rules:
+// - Only consider active tenders.
+// - If there's exactly one configured tender with a "tenderType" === the authResponse, that's the match.
+// - If there's > 1 configured tender matching on "tenderType" above, narrow the match using "cardType":
+//   - If there's exactly one configured tender with a "cardType" === the authResponse, that's the match.
+//     Otherwise, if there's exactly one with no "cardType" configured, it can match any cardType for its tenderType,
+//     so that's the match.
+// - If no match is made using the above criteria and a PaymentDevice card tender is configured, the tender will be
+//     allowed and treated as the single payment device card tender
+// - If we cannot arrive at exactly one match and no PaymentDeviceCard tender is configured, the validation fails.
+//
+function findConfiguredTenderFor(activeTenders, responseData, tenderAuthCategory) {
+    let matchFailedReasonCode = undefined;
+    let matchingTender = undefined;
+    if (shouldFindMatchingConfiguredTender(responseData)) {
+        if (hasActiveTenders(activeTenders)) {
+            const allowPaymentDeviceWallets = paymentDeviceCardExists(activeTenders) &&
+                (tenderAuthCategory === Constants_1.TenderAuthCategory.Wallet ||
+                    tenderAuthCategory === Constants_1.TenderAuthCategory.PaymentDevice) &&
+                responseData.tenderType === scp_types_commerce_devices_1.TenderType.Wallet;
+            if (tenderAuthCategory && !allowPaymentDeviceWallets) {
+                // Narrow down all configured tender to just those matching on tenderAuthCategory
+                activeTenders = activeTenders.filter((aTender) => {
+                    var _a;
+                    return aTender.tenderAuthCategory === tenderAuthCategory || ((_a = aTender.additionalTenderAuthCategories) === null || _a === void 0 ? void 0 : _a.includes(tenderAuthCategory));
+                });
+            }
+            let activeTenderTypeMatches;
+            // Need to match PaymentDevice wallets to both tenderType and cardType because there may be
+            // a tender with tenderType:Wallet and tenderAuthCategory:PaymentDevice that matches but is the wrong cardType.
+            // We don't want to match against that tender, but instead should match against the PaymentDeviceCard tender.
+            if (responseData.tenderType === scp_types_commerce_devices_1.TenderType.Wallet &&
+                (allowPaymentDeviceWallets || allowWalletSpecificTender(tenderAuthCategory, activeTenders))) {
+                activeTenderTypeMatches = activeTenders.filter((aTender) => {
+                    var _a;
+                    return aTender.tenderTypeName === scp_types_commerce_devices_1.TenderType.Wallet &&
+                        (aTender.cardType === responseData.cardType ||
+                            (aTender.cardType === scp_types_commerce_devices_1.CardType.Custom &&
+                                aTender.customCardType === ((_a = responseData.paymentProviderSpecificInfo) === null || _a === void 0 ? void 0 : _a.PaymentMethodVariant))) &&
+                        (aTender.tenderAuthCategory === Constants_1.TenderAuthCategory.Wallet ||
+                            aTender.tenderAuthCategory === Constants_1.TenderAuthCategory.PaymentDevice ||
+                            aTender.tenderAuthCategory === Constants_1.TenderAuthCategory.TapToPayOnPOS);
+                });
+            }
+            else {
+                // Narrow down all configured tenders to just those matching on "tenderType"
+                // where having responseData implies that tenderAuthCategory is not None
+                activeTenderTypeMatches = activeTenders.filter((aTender) => aTender.tenderTypeName === responseData.tenderType &&
+                    aTender.tenderAuthCategory !== Constants_1.TenderAuthCategory.None);
+            }
+            if (hasActiveTenders(activeTenderTypeMatches)) {
+                if (activeTenderTypeMatches.length === 1) {
+                    matchingTender = activeTenderTypeMatches[0];
+                }
+                else {
+                    // Multiple configured tenders match on "tenderType".  Narrow down using "cardType".
+                    if (responseData.cardType === scp_types_commerce_devices_1.CardType.Custom) {
+                        const result = findCustomCardType(activeTenderTypeMatches, responseData);
+                        matchingTender = result;
+                        matchFailedReasonCode = result;
+                    }
+                    else {
+                        let cardTypeMatches = activeTenderTypeMatches.filter((aTender) => aTender.cardType && aTender.cardType === responseData.cardType);
+                        if (!cardTypeMatches || cardTypeMatches.length === 0) {
+                            // No exact matches on "cardType".  Any candidate tenders left that match ANY cardType
+                            // (that is, they have no significant cardType configured)?
+                            cardTypeMatches = activeTenderTypeMatches.filter((aTender) => !aTender.cardType);
+                        }
+                        if (hasActiveTenders(cardTypeMatches)) {
+                            if (cardTypeMatches.length === 1) {
+                                matchingTender = cardTypeMatches[0];
+                            }
+                            else {
+                                if (responseData.subType) {
+                                    const subTypeMatches = activeTenderTypeMatches.filter((aTender) => aTender.subType && aTender.subType === responseData.subType);
+                                    if (subTypeMatches && subTypeMatches.length === 1) {
+                                        matchingTender = subTypeMatches[0];
+                                    }
+                                    else {
+                                        matchFailedReasonCode = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+                                        logger.info(`Cannot find configured tender matching auth response: ` +
+                                            `Multiple active tender types configured that match auth response tenderType ` +
+                                            `[${responseData.tenderType}] and auth response subType [${responseData.subType}]`);
+                                    }
+                                }
+                                else {
+                                    matchFailedReasonCode = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+                                    logger.info(`Cannot find configured tender matching auth response: ` +
+                                        `Multiple active tender types configured that match auth response tenderType ` +
+                                        `[${responseData.tenderType}] and auth response cardType [${responseData.cardType}]`);
+                                }
+                            }
+                        }
+                        else {
+                            matchFailedReasonCode = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+                            logger.info(`Cannot find configured tender matching auth response: ` +
+                                `Multiple active tender types configured match auth
+                  response tenderType [${responseData.tenderType}] ` +
+                                `and none match auth response cardType [${responseData.cardType}] to resolve to a single match`);
+                        }
+                    }
+                }
+            }
+            else {
+                matchFailedReasonCode = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+                logger.info(`Cannot find configured tender matching auth response: No active tender type configured ` +
+                    `that matches auth response tenderType, [${responseData.tenderType}]`);
+            }
+            // If a Debit tender was used and not matched fallback on TenderType Debit
+            // and CardType Debit if that tender exists
+            if (!matchingTender && responseData.tenderType === scp_types_commerce_devices_1.TenderType.Debit) {
+                const debitResult = findDebitCardType(activeTenderTypeMatches);
+                matchingTender = debitResult;
+                matchFailedReasonCode = debitResult;
+            }
+            // If a PaymentDevice tender is configured and no other matching tenders are configured,
+            // use the PaymentDevice tender
+            if (!matchingTender) {
+                const paymentDeviceTender = activeTenders.filter((aTender) => aTender.cardType &&
+                    aTender.cardType === scp_types_commerce_devices_1.CardType.PaymentDeviceCard &&
+                    aTender.tenderTypeName === scp_types_commerce_devices_1.TenderType.PaymentDevice);
+                if (paymentDeviceTender && paymentDeviceTender.length > 0) {
+                    logger.info("PaymentDevice tender is configured. The auth response tender will be allowed.");
+                    matchingTender = paymentDeviceTender[0];
+                    matchFailedReasonCode = undefined;
+                }
+                else {
+                    // no PaymentDevice tender configured; so log the error and return UnknownTender
+                    logger.error(`Cannot find configured tender matching auth response: tenderType [${responseData.tenderType}] ` +
+                        `and cardType [${responseData.cardType}] and no PaymentDevice tender configured.`);
+                }
+            }
+        }
+        else {
+            matchFailedReasonCode = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+            logger.error(`Cannot find configured tender matching auth response: No active tender types configured`);
+        }
+    }
+    else {
+        matchFailedReasonCode = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+        logger.debug(`Did not attempt to find configured tender with auth ` +
+            `responseCode: [${responseData.responseCode}], ` +
+            `cardType: [${responseData.cardType}] and tenderType, [${responseData.tenderType}]`);
+    }
+    return matchingTender || matchFailedReasonCode;
+}
+exports.findConfiguredTenderFor = findConfiguredTenderFor;
+function getReturnOrCancelTotalAmount(originalTran) {
+    var _a, _b, _c, _d;
+    // since return and cancel are mutually exclusive by design
+    const isCancel = (_b = (_a = originalTran) === null || _a === void 0 ? void 0 : _a.cancelTotalAmount) === null || _b === void 0 ? void 0 : _b.isNotZero();
+    const isReturn = (_d = (_c = originalTran) === null || _c === void 0 ? void 0 : _c.returnTotalAmount) === null || _d === void 0 ? void 0 : _d.isNotZero();
+    if (isCancel && isReturn) {
+        throw Error("Cancel and Return are not supported together.");
+    }
+    //This amount represents the item value being returned/cancelled.
+    let refundTotalAmount;
+    if (isCancel) {
+        refundTotalAmount = originalTran.cancelTotalAmount.abs();
+    }
+    else if (isReturn) {
+        refundTotalAmount = originalTran.returnTotalAmount.abs();
+    }
+    return refundTotalAmount;
+}
+exports.getReturnOrCancelTotalAmount = getReturnOrCancelTotalAmount;
+function isTenderCurrentlyRefunded(originalTender, refundableAmount) {
+    var _a, _b, _c;
+    const refundedAmount = adjustAmount((_a = originalTender) === null || _a === void 0 ? void 0 : _a.refundedAmount, (_b = originalTender) === null || _b === void 0 ? void 0 : _b.adjustmentAmount);
+    return (refundableAmount &&
+        (((_c = originalTender) === null || _c === void 0 ? void 0 : _c.isMappedTender) ? !refundableAmount.isPositive() : refundedAmount.gte(refundableAmount)));
+}
+exports.isTenderCurrentlyRefunded = isTenderCurrentlyRefunded;
+function allowWalletSpecificTender(tenderAuthCategory, tenders) {
+    return tenderAuthCategory === Constants_1.TenderAuthCategory.PaymentDevice && walletSpecificTenderExists(tenders);
+}
+exports.allowWalletSpecificTender = allowWalletSpecificTender;
+function hasActiveTenders(activeTenderTypeMatches) {
+    return activeTenderTypeMatches && activeTenderTypeMatches.length > 0;
+}
+function paymentDeviceCardExists(activeTenders) {
+    return activeTenders.some((t) => t.cardType === scp_types_commerce_devices_1.CardType.PaymentDeviceCard);
+}
+exports.paymentDeviceCardExists = paymentDeviceCardExists;
+function walletSpecificTenderExists(activeTenders) {
+    return activeTenders.some((t) => t.tenderAuthCategory === Constants_1.TenderAuthCategory.PaymentDevice &&
+        t.tenderTypeName === scp_types_commerce_devices_1.TenderType.Wallet);
+}
+exports.walletSpecificTenderExists = walletSpecificTenderExists;
+function shouldFindMatchingConfiguredTender(responseData) {
+    // If the response is not approved and we are not getting back a tender type and card type,
+    // do not check for a matching configured tender. Gift card redeem defaults to card type gift
+    return !(responseData.responseCode !== scp_types_commerce_devices_1.ResponseCodes.Approved &&
+        !responseData.tenderType &&
+        (!responseData.cardType ||
+            (responseData.requestType === scp_types_commerce_devices_1.PaymentRequestType.GiftCardRedeem &&
+                responseData.cardType === scp_types_commerce_devices_1.CardType.Gift)));
+}
+function findDebitCardType(activeTenderTypeMatches) {
+    let response;
+    const debitTenderMatches = activeTenderTypeMatches.filter((aTender) => aTender.cardType &&
+        aTender.cardType === scp_types_commerce_devices_1.CardType.Debit &&
+        aTender.tenderTypeName === scp_types_commerce_devices_1.TenderType.Debit);
+    if (!debitTenderMatches || debitTenderMatches.length === 0) {
+        response = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+        logger.info(`Cannot find configured debit tender matching auth response: ` +
+            `No tender types configured matching debit cardType`);
+    }
+    else if (debitTenderMatches && debitTenderMatches.length > 1) {
+        response = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+        logger.info(`Cannot find configured debit tender matching auth response: ` +
+            `Multiple active tender types configured matching`);
+    }
+    else {
+        response = debitTenderMatches[0];
+    }
+    return response;
+}
+function findCustomCardType(activeTenderTypeMatches, responseData) {
+    let response;
+    const cardTypeMatches = activeTenderTypeMatches.filter((aTender) => aTender.cardType &&
+        aTender.cardType === scp_types_commerce_devices_1.CardType.Custom &&
+        aTender.customCardType === responseData.customCardType);
+    if (!cardTypeMatches || cardTypeMatches.length === 0) {
+        response = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+        logger.info(`Cannot find configured tender matching auth response: ` +
+            `No tender types configured matching auth response tenderType [${responseData.tenderType}] ` +
+            `and auth response cardType [${responseData.cardType}] ` +
+            `and auth response customCardType [${responseData.customCardType}].`);
+    }
+    else if (cardTypeMatches && cardTypeMatches.length > 1) {
+        response = scp_types_commerce_transaction_1.TenderAuthFailureReasonCode.UnknownTender;
+        logger.info(`Cannot find configured tender matching auth response: ` +
+            `Multiple active tender types configured matching auth response tenderType [${responseData.tenderType}] ` +
+            `and auth response cardType [${responseData.cardType}] ` +
+            `and auth response customCardType [${responseData.customCardType}].`);
+    }
+    else {
+        response = cardTypeMatches[0];
+    }
+    return response;
+}
+function getTenderAuthCategoryFromTenderType(tenderType) {
+    switch (tenderType) {
+        case scp_types_commerce_devices_1.TenderType.Credit:
+        case scp_types_commerce_devices_1.TenderType.Debit:
+        case scp_types_commerce_devices_1.TenderType.PaymentDevice:
+            return Constants_1.TenderAuthCategory.PaymentDevice;
+        case scp_types_commerce_devices_1.TenderType.Wallet:
+            return Constants_1.TenderAuthCategory.Wallet;
+        case scp_types_commerce_devices_1.TenderType.Gift:
+            return Constants_1.TenderAuthCategory.GiftDevice;
+        default:
+            return Constants_1.TenderAuthCategory.None;
+    }
+}
+exports.getTenderAuthCategoryFromTenderType = getTenderAuthCategoryFromTenderType;
+function getChangeTenderIdsByBehavior(changeBehavior, authorizationFailed, diContainer, changeAmount) {
+    var _a, _b;
+    const changeDefinitions = getConfiguredChangeDefinitions(diContainer);
+    try {
+        let changeBehaviorDefinition = changeDefinitions && changeDefinitions[changeBehavior];
+        if (changeBehaviorDefinition) {
+            if (authorizationFailed) {
+                if (changeBehaviorDefinition.exceptionScenarios &&
+                    changeBehaviorDefinition.exceptionScenarios.authorizationFailure &&
+                    changeBehaviorDefinition.exceptionScenarios.authorizationFailure.changeBehavior) {
+                    const authFailureChangeDefinition = changeDefinitions &&
+                        changeDefinitions[changeBehaviorDefinition.exceptionScenarios.authorizationFailure.changeBehavior];
+                    if (authFailureChangeDefinition) {
+                        changeBehaviorDefinition = authFailureChangeDefinition;
+                    }
+                    else {
+                        // authorization failure has no valid defined fallback change tender
+                        return;
+                    }
+                }
+                else {
+                    // authorization failure has no defined fallback change tender
+                    return;
+                }
+            }
+            else if (changeAmount) {
+                const changeDueUpToAmountConfig = (_a = changeBehaviorDefinition.exceptionScenarios) === null || _a === void 0 ? void 0 : _a.changeDueUpToAmount;
+                if (changeDueUpToAmountConfig &&
+                    changeDueUpToAmountConfig.amount &&
+                    changeDueUpToAmountConfig.changeBehavior) {
+                    const changeDueUpToAmount = new scp_component_business_core_1.Money(changeDueUpToAmountConfig.amount, changeAmount.currency);
+                    if (changeAmount.lte(changeDueUpToAmount)) {
+                        const thresholdChangeDefinition = changeDefinitions && changeDefinitions[changeDueUpToAmountConfig.changeBehavior];
+                        if (thresholdChangeDefinition) {
+                            changeBehaviorDefinition = thresholdChangeDefinition;
+                        }
+                    }
+                }
+            }
+        }
+        if ((_b = changeBehaviorDefinition) === null || _b === void 0 ? void 0 : _b.changeTenders) {
+            const tenderIds = [];
+            // tslint:disable-next-line: forin
+            for (const changeTender in changeBehaviorDefinition.changeTenders) {
+                tenderIds.push(changeBehaviorDefinition.changeTenders[changeTender].tenderId);
+            }
+            return tenderIds;
+        }
+    }
+    catch (error) {
+        logger.info(`Failed to find change tender type ${error.message}`);
+    }
+}
+function getConfiguredChangeDefinitions(diContainer) {
+    const configurationManager = diContainer.get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager);
+    return configurationManager.getTendersValues().changeBehaviorDefinitions;
+}
+function getChangeAmount(balanceDue, tenderAmount) {
+    if (balanceDue && tenderAmount && balanceDue.lt(tenderAmount) && balanceDue.isPositive()) {
+        return tenderAmount.minus(balanceDue);
+    }
+}
+//# sourceMappingURL=TenderType.js.map