globalpayments-api 3.12.0 → 3.13.0

package/lib/test/Unit/Terminals/UPA/UpaAdmin.test.js

@@ -731,574 +731,2419 @@ afterEach(async () => {
             message: "cardTypeFilter must contain only supported card types for startCardTransaction",
         });
     });
-    test("[LiveSetup] startCardTransaction() manual mode with MC filter returns manual entry data", async () => {
+    test("[UpaAdminTests] startCardTransaction() Contact only returns Success", async () => {
         const param = new UpaParam_1.UpaParam();
-        param.timeout = 90;
-        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
-        param.header = "Manual MC Sale";
+        param.timeout = 100;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact];
+        param.header = "Insert Card";
         param.displayTotalAmount = "Yes";
-        param.promptForManual = true;
         const indicator = new ProcessIndicator_1.ProcessingIndicator();
         indicator.QuickChip = "Y";
-        indicator.CheckLuhn = "Y";
-        indicator.SecurityCode = "Y";
-        indicator.CardTypeFilter = [CardTypeFilter_1.CardTypeFilter.MC];
+        indicator.CheckLuhn = "N";
         const transData = new UpaTransactionData_1.UpaTransactionData();
-        transData.totalAmount = 1.0;
+        transData.totalAmount = 5.0;
         transData.cashBackAmount = 0.0;
         transData.tranDate = new Date();
         transData.tranTime = new Date();
         transData.transType = src_1.TransactionType.Sale;
-        const response = await (0, UpaHelpertest_1.executeLiveStartCardTransaction)(device, param, indicator, transData, "StartCardTransaction manual MC");
-        if (!response) {
-            return;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
         }
-        expect(response.acquisitionType.toUpperCase()).toBe("MANUAL");
-        if (response.cardBrandShortName) {
-            expect(response.cardBrandShortName.toUpperCase()).toBe("MC");
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction Contact only timed out while waiting on the device.");
+                return;
+            }
+            throw error;
         }
-        if (response.cardBrand) {
-            expect(response.cardBrand.toUpperCase()).toContain("MASTER");
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction Contact only"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            return;
         }
-        expect(response.expiryDate).toBeTruthy();
-        expect(response.cvv).toBeTruthy();
+        expect(response.status).toBe("Success");
     });
-    test("[LiveSetup] startCardTransaction() accepts infinite timeout card entry", async () => {
+    test("[UpaAdminTests] startCardTransaction() Contactless only returns Success", async () => {
         const param = new UpaParam_1.UpaParam();
-        param.timeout = 0;
-        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact, AcquisitionType_1.AcquisitionType.Swipe];
-        param.header = "Infinite Timeout";
+        param.timeout = 100;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contactless];
+        param.header = "Tap Card";
         param.displayTotalAmount = "Yes";
         const indicator = new ProcessIndicator_1.ProcessingIndicator();
-        indicator.QuickChip = "Y";
-        indicator.CheckLuhn = "Y";
+        indicator.QuickChip = "N";
+        indicator.CheckLuhn = "N";
         const transData = new UpaTransactionData_1.UpaTransactionData();
-        transData.totalAmount = 1.0;
+        transData.totalAmount = 5.0;
         transData.cashBackAmount = 0.0;
         transData.tranDate = new Date();
         transData.tranTime = new Date();
         transData.transType = src_1.TransactionType.Sale;
-        const response = await (0, UpaHelpertest_1.executeLiveStartCardTransaction)(device, param, indicator, transData, "StartCardTransaction infinite timeout");
-        if (!response) {
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction Contactless only timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction Contactless only"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
             return;
         }
-        expect(response.acquisitionType).toBeTruthy();
+        expect(response.status).toBe("Success");
     });
-    test("[LiveSetup] startCardTransaction() manual VISA flow returns AVS-capable response data", async () => {
+    test("[UpaAdminTests] startCardTransaction() Swipe or Contact returns Success", async () => {
         const param = new UpaParam_1.UpaParam();
-        param.timeout = 90;
-        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
-        param.header = "Manual VISA Sale";
+        param.timeout = 45;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Swipe, AcquisitionType_1.AcquisitionType.Contact];
+        param.header = "Swipe or Insert Card";
         param.displayTotalAmount = "Yes";
-        param.promptForManual = true;
         const indicator = new ProcessIndicator_1.ProcessingIndicator();
-        indicator.QuickChip = "Y";
+        indicator.QuickChip = "N";
         indicator.CheckLuhn = "Y";
         indicator.SecurityCode = "Y";
-        indicator.CardTypeFilter = [CardTypeFilter_1.CardTypeFilter.VISA];
         const transData = new UpaTransactionData_1.UpaTransactionData();
-        transData.totalAmount = 1.0;
+        transData.totalAmount = 5.0;
         transData.cashBackAmount = 0.0;
         transData.tranDate = new Date();
         transData.tranTime = new Date();
         transData.transType = src_1.TransactionType.Sale;
-        const response = await (0, UpaHelpertest_1.executeLiveStartCardTransaction)(device, param, indicator, transData, "StartCardTransaction manual VISA");
-        if (!response) {
-            return;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
         }
-        expect(response.acquisitionType.toUpperCase()).toBe("MANUAL");
-        if (response.cardBrandShortName) {
-            expect(response.cardBrandShortName.toUpperCase()).toBe("VI");
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction Swipe or Contact timed out while waiting on the device.");
+                return;
+            }
+            throw error;
         }
-        if (response.cardBrand) {
-            expect(response.cardBrand.toUpperCase()).toContain("VISA");
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction Swipe or Contact"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            expect(response.fallback).toBe("0");
+            return;
         }
-        if (response.avsFlag) {
-            expect(response.avsFlag).toBe("1");
+        expect(response.status).toBe("Success");
+        expect(response.fallback).toBe("0");
+    });
+    test("[UpaAdminTests] startCardTransaction() with CashBack returns Success", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 100;
+        param.acquisitionTypes = [
+            AcquisitionType_1.AcquisitionType.Contact,
+            AcquisitionType_1.AcquisitionType.Contactless,
+            AcquisitionType_1.AcquisitionType.Swipe,
+        ];
+        param.header = "Debit Transaction";
+        param.displayTotalAmount = "Yes";
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "N";
+        indicator.CheckLuhn = "N";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 5.0;
+        transData.cashBackAmount = 10.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
         }
-        else {
-            console.warn("StartCardTransaction manual VISA did not return AVSFlag on the current device configuration.");
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction with CashBack timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction with CashBack"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            expect(response.fallback).toBe("0");
+            return;
         }
+        expect(response.status).toBe("Success");
+        expect(response.fallback).toBe("0");
     });
-    test("[LiveSetup] startCardTransaction() manual AMEX refund flow returns refund card-entry data", async () => {
+    test("[UpaAdminTests] startCardTransaction() Refund returns Success", async () => {
         const param = new UpaParam_1.UpaParam();
-        param.timeout = 90;
-        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
-        param.header = "Manual AMEX Refund";
+        param.timeout = 100;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Swipe];
+        param.header = "Refund Transaction";
         param.displayTotalAmount = "Yes";
-        param.promptForManual = true;
         const indicator = new ProcessIndicator_1.ProcessingIndicator();
-        indicator.QuickChip = "Y";
+        indicator.QuickChip = "N";
         indicator.CheckLuhn = "Y";
-        indicator.SecurityCode = "Y";
-        indicator.CardTypeFilter = [CardTypeFilter_1.CardTypeFilter.AMEX];
+        indicator.SecurityCode = "N";
         const transData = new UpaTransactionData_1.UpaTransactionData();
-        transData.totalAmount = 1.0;
+        transData.totalAmount = 5.0;
         transData.cashBackAmount = 0.0;
         transData.tranDate = new Date();
         transData.tranTime = new Date();
         transData.transType = src_1.TransactionType.Refund;
-        const response = await (0, UpaHelpertest_1.executeLiveStartCardTransaction)(device, param, indicator, transData, "StartCardTransaction manual AMEX refund");
-        if (!response) {
-            return;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
         }
-        expect(response.acquisitionType.toUpperCase()).toBe("MANUAL");
-        if (response.cardBrandShortName &&
-            !["AX", "AMEX"].includes(response.cardBrandShortName.toUpperCase())) {
-            console.warn("StartCardTransaction AMEX refund validation requires an actual AMEX-presented card; the current live run returned a different brand.");
-            return;
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction Refund timed out while waiting on the device.");
+                return;
+            }
+            throw error;
         }
-        if (response.cardBrand &&
-            !response.cardBrand.toUpperCase().includes("AMEX") &&
-            !response.cardBrand.toUpperCase().includes("AMERICAN EXPRESS")) {
-            console.warn("StartCardTransaction AMEX refund validation requires an actual AMEX-presented card; the current live run returned a different brand.");
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction Refund"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
             return;
         }
-        expect(response.expiryDate).toBeTruthy();
-        expect(response.cvv).toBeTruthy();
+        expect(response.status).toBe("Success");
     });
-    test("[LiveSetup] startCardTransaction() accepts card via Contact|Contactless|Swipe|Manual", async () => {
+    test("[UpaAdminTests] startCardTransaction() with VISA and MasterCard filter returns Success", async () => {
         const param = new UpaParam_1.UpaParam();
-        param.acquisitionTypes = [
-            AcquisitionType_1.AcquisitionType.Contact,
-            AcquisitionType_1.AcquisitionType.Contactless,
-            AcquisitionType_1.AcquisitionType.Swipe,
-            AcquisitionType_1.AcquisitionType.Manual,
-        ];
+        param.timeout = 100;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact];
+        param.header = "VISA and MasterCard Only";
+        param.displayTotalAmount = "Yes";
         const indicator = new ProcessIndicator_1.ProcessingIndicator();
-        indicator.QuickChip = "Y";
-        indicator.CheckLuhn = "N";
+        indicator.QuickChip = "N";
+        indicator.CheckLuhn = "Y";
+        indicator.SecurityCode = "Y";
+        indicator.CardTypeFilter = [CardTypeFilter_1.CardTypeFilter.VISA, CardTypeFilter_1.CardTypeFilter.MC];
         const transData = new UpaTransactionData_1.UpaTransactionData();
-        transData.totalAmount = 1.0;
+        transData.totalAmount = 5.0;
         transData.cashBackAmount = 0.0;
         transData.tranDate = new Date();
         transData.tranTime = new Date();
         transData.transType = src_1.TransactionType.Sale;
-        const response = await device.startCardTransaction(param, indicator, transData);
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction with VISA/MC filter timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
         expect(response).not.toBeNull();
         expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
-        expect(response.status).toBe("Success");
-        expect(response.deviceResponseCode).toBe("00");
-        expect(response.acquisitionType?.toUpperCase()).toMatch(/^(CONTACT|CONTACTLESS|SWIPE|MANUAL|INSERT|TAP)$/);
-    }, 300000);
-});
-(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – reboot()", () => {
-    let device;
-    beforeEach(() => {
-        device = (0, UpaHelpertest_1.createTestDevice)();
-    });
-    test("[UpaAdminTests][UpaMicTests] reboot() returns Success and does not throw", async () => {
-        const response = await device.reboot();
-        expect(response).not.toBeNull();
-        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
         if (UpaHelpertest_1.useLiveMic) {
-            (0, UpaHelpertest_1.expectLiveSuccess)(response, "Reboot");
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction VISA/MC filter"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
             return;
         }
         expect(response.status).toBe("Success");
-        expect(response.deviceResponseCode).toBe("00");
     });
-    test("[LiveSetup] reboot() on inactive or unresponsive terminal documents current routing behavior", async () => {
-        const unavailableDevice = DeviceService_1.DeviceService.create((0, UpaHelpertest_1.buildConfig)());
-        unavailableDevice.ecrId = "99999999";
+    test("[UpaAdminTests] startCardTransaction() with amount less than one dollar returns Success", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 100;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact, AcquisitionType_1.AcquisitionType.Swipe];
+        param.header = "Small Amount";
+        param.displayTotalAmount = "Yes";
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "N";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 0.5;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
         try {
-            const response = await unavailableDevice.reboot();
-            expect(response).not.toBeNull();
-            expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
-            if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
-                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Reboot inactive or unresponsive terminal"));
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction with small amount timed out while waiting on the device.");
                 return;
             }
-            if (response.status !== "Success" ||
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction small amount"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            expect(response.fallback).toBe("0");
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.fallback).toBe("0");
+    });
+    test("[UpaAdminTests] startCardTransaction() verifies response fields are populated", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 100;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact];
+        param.header = "Test Transaction";
+        param.displayTotalAmount = "Yes";
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y";
+        indicator.SecurityCode = "N";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 5.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction response fields verification timed out.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction response fields"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            expect(response.acquisitionType).toBeTruthy();
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.acquisitionType).toBeTruthy();
+    });
+    test("[UpaAdminTests] startCardTransaction() Contact with infinite timeout returns Success", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 0;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact];
+        param.header = "No Timeout";
+        param.displayTotalAmount = "Yes";
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "N";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 5.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction Contact infinite timeout timed out.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction Contact infinite timeout"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[UpaAdminTests] startCardTransaction() Contactless with infinite timeout returns Success", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 0;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contactless];
+        param.header = "No Timeout";
+        param.displayTotalAmount = "Yes";
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "N";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 5.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction Contactless infinite timeout timed out.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction Contactless infinite timeout"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[UpaAdminTests] startCardTransaction() with BrandIcons returns Success", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 100;
+        param.acquisitionTypes = [
+            AcquisitionType_1.AcquisitionType.Contact,
+            AcquisitionType_1.AcquisitionType.Swipe,
+            AcquisitionType_1.AcquisitionType.Contactless,
+        ];
+        param.header = "Card Entry";
+        param.displayTotalAmount = "Yes";
+        param.brandIcon1 = 31;
+        param.brandIcon2 = 15;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "N";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 5.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction with BrandIcons timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction with BrandIcons"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[LiveSetup] startCardTransaction() manual mode with MC filter returns manual entry data", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 90;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Manual MC Sale";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = true;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y";
+        indicator.SecurityCode = "Y";
+        indicator.CardTypeFilter = [CardTypeFilter_1.CardTypeFilter.MC];
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 1.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        const response = await (0, UpaHelpertest_1.executeLiveStartCardTransaction)(device, param, indicator, transData, "StartCardTransaction manual MC");
+        if (!response) {
+            return;
+        }
+        expect(response.acquisitionType.toUpperCase()).toBe("MANUAL");
+        if (response.cardBrandShortName) {
+            expect(response.cardBrandShortName.toUpperCase()).toBe("MC");
+        }
+        if (response.cardBrand) {
+            expect(response.cardBrand.toUpperCase()).toContain("MASTER");
+        }
+        expect(response.expiryDate).toBeTruthy();
+        expect(response.cvv).toBeTruthy();
+    });
+    test("[LiveSetup] startCardTransaction() accepts infinite timeout card entry", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 0;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact, AcquisitionType_1.AcquisitionType.Swipe];
+        param.header = "Infinite Timeout";
+        param.displayTotalAmount = "Yes";
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 1.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        const response = await (0, UpaHelpertest_1.executeLiveStartCardTransaction)(device, param, indicator, transData, "StartCardTransaction infinite timeout");
+        if (!response) {
+            return;
+        }
+        expect(response.acquisitionType).toBeTruthy();
+    });
+    test("[LiveSetup] startCardTransaction() manual VISA flow returns AVS-capable response data", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 90;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Manual VISA Sale";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = true;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y";
+        indicator.SecurityCode = "Y";
+        indicator.CardTypeFilter = [CardTypeFilter_1.CardTypeFilter.VISA];
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 1.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        const response = await (0, UpaHelpertest_1.executeLiveStartCardTransaction)(device, param, indicator, transData, "StartCardTransaction manual VISA");
+        if (!response) {
+            return;
+        }
+        expect(response.acquisitionType.toUpperCase()).toBe("MANUAL");
+        if (response.cardBrandShortName) {
+            expect(response.cardBrandShortName.toUpperCase()).toBe("VI");
+        }
+        if (response.cardBrand) {
+            expect(response.cardBrand.toUpperCase()).toContain("VISA");
+        }
+        if (response.avsFlag) {
+            expect(response.avsFlag).toBe("1");
+        }
+        else {
+            console.warn("StartCardTransaction manual VISA did not return AVSFlag on the current device configuration.");
+        }
+    });
+    test("[LiveSetup] startCardTransaction() manual AMEX refund flow returns refund card-entry data", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 90;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Manual AMEX Refund";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = true;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y";
+        indicator.SecurityCode = "Y";
+        indicator.CardTypeFilter = [CardTypeFilter_1.CardTypeFilter.AMEX];
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 1.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Refund;
+        const response = await (0, UpaHelpertest_1.executeLiveStartCardTransaction)(device, param, indicator, transData, "StartCardTransaction manual AMEX refund");
+        if (!response) {
+            return;
+        }
+        expect(response.acquisitionType.toUpperCase()).toBe("MANUAL");
+        if (response.cardBrandShortName &&
+            !["AX", "AMEX"].includes(response.cardBrandShortName.toUpperCase())) {
+            console.warn("StartCardTransaction AMEX refund validation requires an actual AMEX-presented card; the current live run returned a different brand.");
+            return;
+        }
+        if (response.cardBrand &&
+            !response.cardBrand.toUpperCase().includes("AMEX") &&
+            !response.cardBrand.toUpperCase().includes("AMERICAN EXPRESS")) {
+            console.warn("StartCardTransaction AMEX refund validation requires an actual AMEX-presented card; the current live run returned a different brand.");
+            return;
+        }
+        expect(response.expiryDate).toBeTruthy();
+        expect(response.cvv).toBeTruthy();
+    });
+    test("[LiveSetup] startCardTransaction() accepts card via Contact|Contactless|Swipe|Manual", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [
+            AcquisitionType_1.AcquisitionType.Contact,
+            AcquisitionType_1.AcquisitionType.Contactless,
+            AcquisitionType_1.AcquisitionType.Swipe,
+            AcquisitionType_1.AcquisitionType.Manual,
+        ];
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "N";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 1.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        const response = await device.startCardTransaction(param, indicator, transData);
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        expect(response.acquisitionType?.toUpperCase()).toMatch(/^(CONTACT|CONTACTLESS|SWIPE|MANUAL|INSERT|TAP)$/);
+    }, 300000);
+});
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – reboot()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaAdminTests][UpaMicTests] reboot() returns Success and does not throw", async () => {
+        const response = await device.reboot();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "Reboot");
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[LiveSetup] reboot() on inactive or unresponsive terminal documents current routing behavior", async () => {
+        const unavailableDevice = DeviceService_1.DeviceService.create((0, UpaHelpertest_1.buildConfig)());
+        unavailableDevice.ecrId = "99999999";
+        try {
+            const response = await unavailableDevice.reboot();
+            expect(response).not.toBeNull();
+            expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+            if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Reboot inactive or unresponsive terminal"));
+                return;
+            }
+            if (response.status !== "Success" ||
                 response.deviceResponseCode !== "00" ||
                 (!!response.responseCode && response.responseCode !== "00")) {
                 expect(response.deviceResponseCode).not.toBe("00");
                 return;
             }
-            console.warn("Reboot inactive or unresponsive terminal scenario was accepted by the current terminal routing configuration.");
+            console.warn("Reboot inactive or unresponsive terminal scenario was accepted by the current terminal routing configuration.");
+        }
+        catch (error) {
+            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("Reboot inactive or unresponsive terminal timed out while waiting on the device or gateway.");
+                return;
+            }
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toBeTruthy();
+        }
+    });
+    test("[Negative] reboot() surfaces network or communication failure", async () => {
+        const communicationFailureDevice = DeviceService_1.DeviceService.create((0, UpaHelpertest_1.buildConfig)({ serviceUrl: "http://127.0.0.1:1" }), "reboot-communication-failure");
+        communicationFailureDevice.ecrId = "13";
+        await expect(communicationFailureDevice.reboot()).rejects.toBeInstanceOf(Error);
+    });
+});
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – deleteSaf()", () => {
+    let device;
+    async function settle(delayMs = 8000) {
+        if (UpaHelpertest_1.useLiveMic) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    function extractTranNoFromSafReport(safReport) {
+        const buckets = [
+            safReport?.approved,
+            safReport?.pending,
+            safReport?.declined,
+            safReport?.reportResult?.approved,
+            safReport?.reportResult?.pending,
+            safReport?.reportResult?.declined,
+        ];
+        for (const bucket of buckets) {
+            if (!bucket) {
+                continue;
+            }
+            for (const summary of Object.values(bucket)) {
+                const transactions = summary?.transactions ?? [];
+                for (const txn of transactions) {
+                    const candidate = txn?.transactionId;
+                    if (typeof candidate === "string" && /^\d{4,6}$/.test(candidate)) {
+                        return candidate;
+                    }
+                    if (typeof candidate === "number") {
+                        const asString = candidate.toString();
+                        if (/^\d{4,6}$/.test(asString)) {
+                            return asString;
+                        }
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaAdminTests:754] deleteSaf() executes over live MITC when a SAF record exists", async () => {
+        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
+        if (!safReport) {
+            return;
+        }
+        const safReferenceNumber = (0, UpaHelpertest_1.getFirstSafReferenceNumber)(safReport);
+        if (!safReferenceNumber) {
+            console.warn("deleteSaf() live MITC prerequisite skipped: no SAF records available.");
+            return;
+        }
+        console.log(safReferenceNumber);
+        const response = await device.deleteSaf(safReferenceNumber);
+        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
+        expect(response.command).toBe("DeleteSAF");
+        if (response.status === "Failed") {
+            if (["TRAN001", "TRAN010"].includes(response.deviceResponseCode)) {
+                console.warn(`deleteSaf() reference=${safReferenceNumber} returned spec-valid failure ${response.deviceResponseCode} (${response.deviceResponseText}); only host-declined SAF records are freely deletable per §12.4.25.4.`);
+                return;
+            }
+            throw new Error(`deleteSaf() returned unexpected failure code=${response.deviceResponseCode} status=${response.status} text="${response.deviceResponseText}". Per UPA spec §12.4.25.4 the only permitted failure codes for a well-formed request are TRAN001 or TRAN010.`);
+        }
+        (0, UpaHelpertest_1.expectLiveSuccess)(response, "DeleteSAF");
+    });
+    test('[UpaAdminTests:754] deleteSaf() surfaces response="DeleteSAF", cmdResult.result="Success", and transaction details', async () => {
+        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
+        if (!safReport) {
+            return;
+        }
+        const safReferenceNumber = (0, UpaHelpertest_1.getFirstSafReferenceNumber)(safReport);
+        if (!safReferenceNumber) {
+            console.warn("deleteSaf() live MITC prerequisite skipped: no SAF records available.");
+            return;
+        }
+        const response = await device.deleteSaf(safReferenceNumber);
+        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
+        expect(response.command).toBe("DeleteSAF");
+        if (response.status === "Failed") {
+            if (["TRAN001", "TRAN010"].includes(response.deviceResponseCode)) {
+                console.warn(`deleteSaf() reference=${safReferenceNumber} returned spec-valid failure ${response.deviceResponseCode} (${response.deviceResponseText}); only host-declined SAF records are freely deletable per §12.4.25.4.`);
+                return;
+            }
+            throw new Error(`deleteSaf() returned unexpected failure code=${response.deviceResponseCode} status=${response.status} text="${response.deviceResponseText}". Per UPA spec §12.4.25.4 the only permitted failure codes for a well-formed request are TRAN001 or TRAN010.`);
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        if (response.totalCount !== undefined ||
+            response.totalAmount !== undefined) {
+            expect(response.totalCount).toBeGreaterThanOrEqual(0);
+            expect(response.totalAmount).toBeGreaterThanOrEqual(0);
+        }
+    });
+    test("[UpaAdminTests:754] deleteSaf() by tranNo executes over live MITC", async () => {
+        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
+        if (!safReport) {
+            return;
+        }
+        const candidateTranNo = extractTranNoFromSafReport(safReport);
+        if (!candidateTranNo) {
+            console.warn("deleteSaf(by tranNo) live MITC prerequisite skipped: no SAF record exposed a numeric tranNo/transId.");
+            return;
+        }
+        expect(device.deleteSaf.length).toBeGreaterThanOrEqual(2);
+        const response = await device.deleteSaf(undefined, candidateTranNo);
+        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
+        expect(response.command).toBe("DeleteSAF");
+        expect(["Success", "Failed"]).toContain(response.status);
+        if (response.status === "Failed") {
+            expect(["TRAN001", "TRAN010"]).toContain(response.deviceResponseCode);
+        }
+    });
+    test("[UpaAdminTests:754] deleteSaf() with no identifiers deletes all host-declined SAF transactions", async () => {
+        expect(typeof device.deleteSaf).toBe("function");
+        expect(device.deleteSaf.length).toBeGreaterThanOrEqual(0);
+        if (process.env.UPA_DELETE_ALL_SAF !== "true") {
+            console.warn("deleteSaf() delete-all live scenario skipped. Set UPA_DELETE_ALL_SAF=true to execute (DESTRUCTIVE: erases every host-declined SAF record on the device).");
+            return;
+        }
+        // Seed at least one SAF record so the delete-all has something to act on.
+        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
+        if (!safReport) {
+            return;
+        }
+        const response = await device.deleteSaf();
+        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
+        expect(response.command).toBe("DeleteSAF");
+        // Success is the expected outcome; Failed with TRAN001
+        // if the batch happens to contain no host-declined records at execution time
+        expect(["Success", "Failed"]).toContain(response.status);
+    });
+    test("[UpaCreditTests] sale() serializes processing indicators without mocked responses", async () => {
+        const saleResponse = await (0, UpaHelpertest_1.createLiveSale)(device);
+        expect(saleResponse.status).toBe("Success");
+    });
+    test("[UpaAdminTests:754] deleteSaf() surfaces TRAN001 (TRANSACTION NOT FOUND) over live MITC", async () => {
+        const unknownSafReferenceNumber = `UNKNOWN-123`;
+        const response = await device.deleteSaf(unknownSafReferenceNumber);
+        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
+        expect(response.command).toBe("DeleteSAF");
+        expect(response.status).toBe("Failed");
+        if (response.deviceResponseCode === "TRAN001") {
+            expect(response.deviceResponseMessage).toMatch(/NOT FOUND/i);
+            return;
+        }
+        console.log(`deleteSaf() unknown reference returned ${response.deviceResponseCode} (${response.deviceResponseMessage}) instead of TRAN001; device firmware may normalize unknown references.`);
+    });
+    test("[UpaAdminTests:754] deleteSaf() surfaces TRAN010 (TRANSACTION CANNOT BE DELETED) over live MITC", async () => {
+        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
+        if (!safReport) {
+            return;
+        }
+        const approvedBucket = safReport.reportResult?.approved ?? {};
+        let approvedReferenceNumber;
+        for (const summary of Object.values(approvedBucket)) {
+            const transaction = summary?.transactions?.[0];
+            if (transaction?.referenceNumber) {
+                approvedReferenceNumber = transaction.referenceNumber;
+                break;
+            }
+        }
+        if (!approvedReferenceNumber) {
+            console.warn("deleteSaf() TRAN010 live scenario skipped: no approved (host-authorized) SAF records available. TRAN010 requires a pending or authorized transaction reference per spec §12.4.25.4.");
+            return;
+        }
+        const response = await device.deleteSaf(approvedReferenceNumber);
+        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
+        expect(response.command).toBe("DeleteSAF");
+        expect(response.status).toBe("Failed");
+        if (response.deviceResponseCode === "TRAN010") {
+            expect(response.deviceResponseMessage.toUpperCase()).toContain("CANNOT BE DELETED");
+            return;
+        }
+        console.warn(`deleteSaf() authorized-reference delete returned ${response.deviceResponseCode} (${response.deviceResponseMessage}) instead of TRAN010; device firmware may normalize the authorized-transaction outcome.`);
+    });
+});
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – cancel()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    function buildCancelableStartCardTransactionRequest() {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [
+            AcquisitionType_1.AcquisitionType.Contact,
+            AcquisitionType_1.AcquisitionType.Contactless,
+            AcquisitionType_1.AcquisitionType.Swipe,
+            AcquisitionType_1.AcquisitionType.Manual,
+        ];
+        param.header = "Cancel Transaction";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = false;
+        param.timeout = 30;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "N";
+        indicator.SecurityCode = "Y";
+        indicator.CardTypeFilter = [
+            CardTypeFilter_1.CardTypeFilter.VISA,
+            CardTypeFilter_1.CardTypeFilter.MC,
+            CardTypeFilter_1.CardTypeFilter.AMEX,
+            CardTypeFilter_1.CardTypeFilter.DISCOVER,
+        ];
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 1.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        return [param, indicator, transData];
+    }
+    function timeoutAfter(delayMs, label) {
+        return new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`${label} timed out after ${delayMs}ms`)), delayMs);
+        });
+    }
+    function sleep(delayMs) {
+        return new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    test("[UpaAdminTests:711] cancel() cancels an active startCardTransaction over live MITC", async () => {
+        const [param, indicator, transData] = buildCancelableStartCardTransactionRequest();
+        const activeCommand = device
+            .startCardTransaction(param, indicator, transData)
+            .then((response) => ({ kind: "resolved", response }))
+            .catch((error) => ({ kind: "rejected", error }));
+        await sleep(2000);
+        await expect(device.cancel()).resolves.toBeUndefined();
+        const result = await Promise.race([
+            activeCommand,
+            timeoutAfter(45000, "cancelled startCardTransaction"),
+        ]);
+        if (result.kind === "resolved") {
+            expect(result.response).toBeTruthy();
+            if (result.response instanceof TransactionResponse_1.TransactionResponse) {
+                expect([
+                    "StartCardTransaction",
+                    "CancelTransaction",
+                    "SendCommand",
+                ]).toContain(result.response.command);
+            }
+            return;
+        }
+        expect(result.error).toBeInstanceOf(Error);
+    });
+    test("[UpaAdminTests:711] cancel() sends CancelTransaction without a displayOption parameter", async () => {
+        expect(typeof device.cancel).toBe("function");
+        expect(device.cancel.length).toBe(0);
+        await expect(device.cancel()).resolves.toBeUndefined();
+    });
+    test("[UpaAdminTests:711] cancel() handles APP006 (TRANSACTION CANNOT BE CANCELED) without throwing", async () => {
+        await expect(device.cancel()).resolves.toBeUndefined();
+    });
+});
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – registerPOS()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaAdminTests:776] registerPOS() executes over live MITC", async () => {
+        const posData = new src_1.POSData();
+        posData.appName = `com.global.testapp.${Date.now()}`;
+        posData.launchOrder = 1;
+        posData.remove = false;
+        posData.silent = 0;
+        try {
+            const response = await device.registerPOS(posData);
+            expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+            expect(response.status).toBe("Success");
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "RegisterPOS");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes("SYSTEM_ERROR")) {
+                console.warn("registerPOS() succeeded on the device but GP-API returned SYSTEM_ERROR during response mediation; verify registration state on the terminal.");
+                return;
+            }
+            throw err;
+        }
+    });
+});
+// ===========================================================================
+// verify()
+//   CardVerify command with tokenRequest = "1"
+//   Confirms a multi-use token is created and returned by the host
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – verify()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaMicTests] verify() returns expected response", async () => {
+        const response = await device.verify().withEcrId(13).execute();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[UpaMicTests] verify() with tokenRequest = 1 returns a token", async () => {
+        try {
+            const response = await device
+                .verify()
+                .withRequestMultiUseToken(true)
+                .withCardBrandStorage(src_1.StoredCredentialInitiator.CardHolder)
+                .withEcrId(13)
+                .execute();
+            console.log("[VERIFY RESPONSE]", JSON.stringify(response, null, 2));
+            expect(response).not.toBeNull();
+            expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+            if (UpaHelpertest_1.useLiveMic) {
+                if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
+                    console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "CardVerify tokenRequest"));
+                    return;
+                }
+                (0, UpaHelpertest_1.expectLiveSuccess)(response, ["CardVerify", "SendCommand"]);
+                expect(response.token).toBeTruthy();
+                expect(response.token.length).toBeGreaterThan(0);
+                return;
+            }
+            expect(response.status).toBe("Success");
+            expect(response.deviceResponseCode).toBe("00");
+            // ...existing expects
+        }
+        catch (err) {
+            console.log("[VERIFY ERROR]", err);
+            throw err;
+        }
+    });
+    // ===============================================================//
+    test("[UpaManageTests:600] capture() serializes processCPC indicator", async () => {
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        const responseauth = await device
+            .authorize(10.0)
+            .withEcrId(13)
+            .execute();
+        const builder = device
+            .capture()
+            .withTransactionId(responseauth.transactionId)
+            .withAmount(10.0)
+            .withEcrId(13)
+            .withProcessCPC(true);
+        const request = controller.buildManageTransaction(builder).getJsonRequest();
+        console.log("[UpaManageTests:600] Capture with processCPC request payload:\n" +
+            JSON.stringify(request, null, 2));
+        expect(request.data.command).toBe("AuthCompletion");
+        expect(request.data.data.transaction.processCPC).toBe("1");
+        const response = await builder.execute();
+        expect(response.status).toBe("Success");
+    });
+    test("[UpaManageTests:601] capture() serializes processCPC false as 0", async () => {
+        const responseauth = await device
+            .authorize(10.0)
+            .withEcrId(13)
+            .execute();
+        const controller = src_1.ServicesContainer.instance().getDeviceController();
+        sleep(100);
+        const builder = device
+            .capture()
+            .withTransactionId(responseauth.transactionId)
+            .withAmount(10.0)
+            .withEcrId(13)
+            .withProcessCPC(false);
+        const request = controller.buildManageTransaction(builder).getJsonRequest();
+        console.log("[UpaManageTests:601] Capture with processCPC false request payload:\n" +
+            JSON.stringify(request, null, 2));
+        expect(request.data.command).toBe("AuthCompletion");
+        expect(request.data.data.transaction.processCPC).toBe("0");
+        const response = await builder.execute();
+        expect(response.status).toBe("Success");
+    });
+});
+// ===========================================================================
+// processingIndicators – StartCardTransaction Workflow
+// Per UPA spec §12.4.x: quickChip, checkLuhn, securityCode
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – StartCardTransaction processingIndicators workflow", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[ProcessingIndicators:StartCardTransaction] quickChip='Y' (Quick Chip EMV)", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact];
+        param.header = "Quick Chip Sale";
+        param.displayTotalAmount = "Yes";
+        param.timeout = 90;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y"; // Quick Chip enabled
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 10.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction quickChip='Y' timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction quickChip='Y'"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            // Quick Chip should result in Contact/Contactless acquisition
+            expect(["CONTACT", "CONTACTLESS", "INSERT", "TAP"].some((x) => response.acquisitionType?.toUpperCase().includes(x))).toBe(true);
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[ProcessingIndicators:StartCardTransaction] quickChip='N' (Traditional EMV)", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact];
+        param.header = "Traditional EMV Sale";
+        param.displayTotalAmount = "Yes";
+        param.timeout = 90;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "N"; // Traditional EMV
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 15.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction quickChip='N' timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction quickChip='N'"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            expect(response.acquisitionType).toBeTruthy();
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[ProcessingIndicators:StartCardTransaction] checkLuhn='Y' (with LUHN validation for manual entry)", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Manual Entry with LUHN Check";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = true;
+        param.timeout = 90;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y"; // LUHN validation enabled
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 20.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction checkLuhn='Y' timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction checkLuhn='Y'"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            // Manual entry should be recorded
+            expect(response.acquisitionType?.toUpperCase()).toBe("MANUAL");
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[ProcessingIndicators:StartCardTransaction] checkLuhn='N' (skip LUHN validation)", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Manual Entry without LUHN Check";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = true;
+        param.timeout = 90;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "N"; // LUHN validation disabled
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 25.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction checkLuhn='N' timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction checkLuhn='N'"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[ProcessingIndicators:StartCardTransaction] securityCode='Y' (prompt for CVV)", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Manual Entry with CVV Prompt";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = true;
+        param.timeout = 90;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y";
+        indicator.SecurityCode = "Y"; // Request CVV/CVC
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 30.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction securityCode='Y' timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction securityCode='Y'"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            // CVV should be present in manual entry response
+            if (response.acquisitionType?.toUpperCase() === "MANUAL") {
+                expect(response.cvv).toBeTruthy();
+            }
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[ProcessingIndicators:StartCardTransaction] securityCode='N' (skip CVV prompt)", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Manual Entry without CVV Prompt";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = true;
+        param.timeout = 90;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y";
+        indicator.SecurityCode = "N"; // Skip CVV prompt
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 35.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction securityCode='N' timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction securityCode='N'"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[ProcessingIndicators:StartCardTransaction] All indicators combined (quickChip=Y, checkLuhn=Y, securityCode=Y)", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [
+            AcquisitionType_1.AcquisitionType.Contact,
+            AcquisitionType_1.AcquisitionType.Contactless,
+            AcquisitionType_1.AcquisitionType.Swipe,
+            AcquisitionType_1.AcquisitionType.Manual,
+        ];
+        param.header = "Full Processing Indicators";
+        param.displayTotalAmount = "Yes";
+        param.timeout = 90;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y";
+        indicator.SecurityCode = "Y";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 50.0;
+        transData.cashBackAmount = 5.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction combined indicators timed out while waiting on the device.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction combined indicators"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            (0, UpaHelpertest_1.expectParsedStartCardTransactionResponse)(response);
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+});
+// ===========================================================================
+// processingIndicators – Response Indicators Validation
+// Per UPA spec: luhnCheckPassed, fallback, pinVerified, qpsQualified, etc.
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – processingIndicators response indicators", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[ResponseIndicators] StartCardTransaction manual entry returns luhnCheckPassed indicator", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "LUHN Validation Response";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = true;
+        param.timeout = 90;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y"; // Enable LUHN check
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 10.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
         }
         catch (error) {
-            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
-                console.warn("Reboot inactive or unresponsive terminal timed out while waiting on the device or gateway.");
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction luhnCheckPassed response timed out.");
                 return;
             }
-            expect(error).toBeInstanceOf(Error);
-            expect(error.message).toBeTruthy();
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Response luhnCheckPassed indicator"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            // Per UPA spec: luhnCheckPassed should be present when checkLuhn='Y'
+            if (response.acquisitionType?.toUpperCase() === "MANUAL") {
+                // Response may include luhnCheckPassed as response indicator
+                // Document current behavior: presence depends on implementation
+                if (response.luhnCheckPassed !== undefined) {
+                    expect([response.luhnCheckPassed]).toContain(response.luhnCheckPassed);
+                }
+            }
+            return;
         }
+        expect(response.status).toBe("Success");
     });
-    test("[Negative] reboot() surfaces network or communication failure", async () => {
-        const communicationFailureDevice = DeviceService_1.DeviceService.create((0, UpaHelpertest_1.buildConfig)({ serviceUrl: "http://127.0.0.1:1" }), "reboot-communication-failure");
-        communicationFailureDevice.ecrId = "13";
-        await expect(communicationFailureDevice.reboot()).rejects.toBeInstanceOf(Error);
+    test("[ResponseIndicators] StartCardTransaction returns response indicators (status, code, acquisitionType)", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [
+            AcquisitionType_1.AcquisitionType.Contact,
+            AcquisitionType_1.AcquisitionType.Contactless,
+            AcquisitionType_1.AcquisitionType.Swipe,
+        ];
+        param.header = "Response Indicator Validation";
+        param.displayTotalAmount = "Yes";
+        param.timeout = 60;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "N";
+        indicator.SecurityCode = "Y";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 20.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction response indicators timed out.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Response indicator validation"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            // Per UPA spec §12.4.x: response should include these fields
+            expect(response.status).toBe("Success");
+            expect(response.deviceResponseCode).toBe("00");
+            expect(response.acquisitionType).toBeTruthy();
+            // Document optional response indicators
+            console.log("Response indicators: acquisitionType=%s, cardBrand=%s", response.acquisitionType, response.cardBrand);
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        expect(response.acquisitionType).toBeTruthy();
+    });
+    test("[ResponseIndicators] StartCardTransaction with cardTypeFilter returns restricted card brands", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Card Type Filter Response";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = true;
+        param.timeout = 90;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CardTypeFilter = [CardTypeFilter_1.CardTypeFilter.VISA, CardTypeFilter_1.CardTypeFilter.MC]; // Restrict to VISA/MC
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 15.0;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (UpaHelpertest_1.useLiveMic && (0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("StartCardTransaction cardTypeFilter response timed out.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Response cardTypeFilter validation"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            // Per cardTypeFilter=[VISA, MC], response should reflect only those brands
+            if (response.cardBrandShortName) {
+                expect(["VI", "MC"].some((b) => response.cardBrandShortName?.toUpperCase().includes(b))).toBe(true);
+            }
+            return;
+        }
+        expect(response.status).toBe("Success");
     });
 });
-(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – deleteSaf()", () => {
+// ===========================================================================
+// Direct Marketing Fields – Sale, Refund, PreAuth, TipAdjust, etc.
+// Per UPA spec: directMktInvoiceNbr, directMktShipMonth, directMktShipDay
+// ===========================================================================
+/**
+ * Helper: Generate Direct Marketing fields with correct date handling
+ * Per UPA spec: if directMktInvoiceNbr provided, directMktShipMonth and directMktShipDay are required
+ */
+function buildDirectMarketingFields(invoiceNumber, shipDate) {
+    const date = shipDate || new Date();
+    // Correct JavaScript date handling:
+    // getMonth() returns 0-11 (Jan=0, Aug=7), so add 1 and pad
+    // getDate() returns 1-31 (correct day of month)
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return {
+        directMktInvoiceNbr: invoiceNumber,
+        directMktShipMonth: month,
+        directMktShipDay: day,
+    };
+}
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – Direct Marketing Fields (Sale/Refund/PreAuth)", () => {
     let device;
-    async function settle(delayMs = 8000) {
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[DirectMarketing:Sale] Sale with directMktInvoiceNbr, directMktShipMonth, directMktShipDay", async () => {
+        const directMktFields = buildDirectMarketingFields("INV20260817001");
+        const response = (await device
+            .sale(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
         if (UpaHelpertest_1.useLiveMic) {
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Sale with Direct Marketing fields"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            expect(response.terminalRefNumber).toBeTruthy();
+            return;
         }
-    }
-    function extractTranNoFromSafReport(safReport) {
-        const buckets = [
-            safReport?.approved,
-            safReport?.pending,
-            safReport?.declined,
-            safReport?.reportResult?.approved,
-            safReport?.reportResult?.pending,
-            safReport?.reportResult?.declined,
-        ];
-        for (const bucket of buckets) {
-            if (!bucket) {
-                continue;
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[DirectMarketing:Sale] Sale returns directMktInvoiceNbr, directMktShipMonth, directMktShipDay in response", async () => {
+        const directMktFields = buildDirectMarketingFields("INV20260817002", new Date(2026, 7, 17));
+        const response = (await device
+            .sale(10.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Sale Direct Marketing response field validation"));
+                return;
             }
-            for (const summary of Object.values(bucket)) {
-                const transactions = summary?.transactions ?? [];
-                for (const txn of transactions) {
-                    const candidate = txn?.transactionId;
-                    if (typeof candidate === "string" && /^\d{4,6}$/.test(candidate)) {
-                        return candidate;
-                    }
-                    if (typeof candidate === "number") {
-                        const asString = candidate.toString();
-                        if (/^\d{4,6}$/.test(asString)) {
-                            return asString;
-                        }
-                    }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            // Per UPA spec: response should echo direct marketing fields
+            if (response.directMktInvoiceNbr) {
+                expect(response.directMktInvoiceNbr).toBe(directMktFields.directMktInvoiceNbr);
+            }
+            if (response.directMktShipMonth) {
+                expect(response.directMktShipMonth).toBe("08");
+            }
+            if (response.directMktShipDay) {
+                expect(response.directMktShipDay).toBe("17");
+            }
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[DirectMarketing:Refund] Refund with directMktInvoiceNbr, directMktShipMonth, directMktShipDay", async () => {
+        // Prerequisite: create a sale first
+        let saleResponse;
+        try {
+            saleResponse = await (0, UpaHelpertest_1.createLiveSale)(device);
+            if (saleResponse.deviceResponseCode !== "00") {
+                if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(saleResponse)) {
+                    console.warn((0, UpaHelpertest_1.formatLiveFailure)(saleResponse, "Sale prerequisite"));
+                    return;
                 }
+                throw new Error((0, UpaHelpertest_1.formatLiveFailure)(saleResponse, "Sale prerequisite"));
+            }
+        }
+        catch (error) {
+            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("Refund with Direct Marketing fields prerequisite timed out.");
+                return;
+            }
+            throw error;
+        }
+        const directMktFields = buildDirectMarketingFields("REFUND20260817001");
+        const refundResponse = (await device
+            .refund(1.0)
+            .withEcrId(13)
+            .withTransactionId(saleResponse.transactionId)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(refundResponse).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(refundResponse)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(refundResponse, "Refund with Direct Marketing fields"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(refundResponse, ["Refund", "SendCommand"]);
+            return;
+        }
+        expect(refundResponse.status).toBe("Success");
+    });
+    test("[DirectMarketing:PreAuth] PreAuth (OpenTab) with directMktInvoiceNbr, directMktShipMonth, directMktShipDay", async () => {
+        const directMktFields = buildDirectMarketingFields("PRETAB20260817001");
+        const response = (await device
+            .authorize(15.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "PreAuth with Direct Marketing fields"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["PreAuth", "SendCommand"]);
+            expect(response.transactionId).toBeTruthy();
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[DirectMarketing:Validation] Missing directMktShipMonth and directMktShipDay when directMktInvoiceNbr provided should be caught", async () => {
+        // Per UPA spec: if directMktInvoiceNbr is provided, directMktShipMonth and directMktShipDay must be provided too
+        // This test documents the behavior:
+        // If only invoice number is provided without month/day, the request should fail or device should reject it
+        try {
+            const response = (await device
+                .sale(5.0)
+                .withEcrId(13)
+                .withClerkId(123)
+                .withDirectMktInvoiceNbr("INCOMPLETE001")
+                // Intentionally omit directMktShipMonth and directMktShipDay
+                .execute());
+            expect(response).not.toBeNull();
+            // Per spec: incomplete direct marketing fields should result in failure
+            if (UpaHelpertest_1.useLiveMic && response.deviceResponseCode !== "00") {
+                console.log("[Validation] Incomplete Direct Marketing fields rejected:", response.deviceResponseCode, response.deviceResponseText);
+                expect(response.deviceResponseCode).not.toBe("00");
+                return;
+            }
+            console.warn("[Validation] Terminal accepted incomplete Direct Marketing fields; device may have looser validation");
+        }
+        catch (error) {
+            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("Incomplete Direct Marketing fields validation timed out.");
+                return;
             }
+            // Expected: ArgumentError or validation error
+            expect(error).toBeInstanceOf(Error);
         }
-        return undefined;
-    }
+    });
+    test("[DirectMarketing:DateHandling] Correct JavaScript date handling (getMonth() + 1, getDate())", async () => {
+        // Test date: August 17, 2026
+        const testDate = new Date(2026, 7, 17); // Month is 0-indexed, so 7 = August
+        const directMktFields = buildDirectMarketingFields("DATE_TEST_20260817", testDate);
+        // Verify correct month conversion (0-11 → 01-12)
+        expect(directMktFields.directMktShipMonth).toBe("08");
+        // Verify correct day (1-31)
+        expect(directMktFields.directMktShipDay).toBe("17");
+        const response = (await device
+            .sale(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Date handling validation"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            console.log("[DateHandling] Verified: Month=%s, Day=%s", directMktFields.directMktShipMonth, directMktFields.directMktShipDay);
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[DirectMarketing:EdgeCase] Month boundaries (January=01, December=12)", async () => {
+        // Test January (month=0)
+        const januaryFields = buildDirectMarketingFields("JAN_TEST_001", new Date(2026, 0, 1));
+        expect(januaryFields.directMktShipMonth).toBe("01");
+        // Test December (month=11)
+        const decemberFields = buildDirectMarketingFields("DEC_TEST_001", new Date(2026, 11, 31));
+        expect(decemberFields.directMktShipMonth).toBe("12");
+        console.log("[EdgeCase] Month boundaries verified: Jan=%s, Dec=%s", januaryFields.directMktShipMonth, decemberFields.directMktShipMonth);
+    });
+    test("[DirectMarketing:EdgeCase] Day padding (single digit days 01-09)", async () => {
+        // Test day 1 (should be "01", not "1")
+        const dayOneFields = buildDirectMarketingFields("DAY_01_TEST", new Date(2026, 7, 1));
+        expect(dayOneFields.directMktShipDay).toBe("01");
+        // Test day 9 (should be "09", not "9")
+        const dayNineFields = buildDirectMarketingFields("DAY_09_TEST", new Date(2026, 7, 9));
+        expect(dayNineFields.directMktShipDay).toBe("09");
+        console.log("[EdgeCase] Day padding verified: 01=%s, 09=%s", dayOneFields.directMktShipDay, dayNineFields.directMktShipDay);
+    });
+});
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – Parameterized Direct Marketing Tests", () => {
+    let device;
     beforeEach(() => {
         device = (0, UpaHelpertest_1.createTestDevice)();
     });
-    test("[UpaAdminTests:754] deleteSaf() executes over live MITC when a SAF record exists", async () => {
-        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
-        if (!safReport) {
+    const testCases = [
+        {
+            name: "Current Date Sale",
+            amount: 5.0,
+            invoicePrefix: "CURRENT",
+            shipDate: new Date(),
+        },
+        {
+            name: "Future Date Sale",
+            amount: 10.0,
+            invoicePrefix: "FUTURE",
+            shipDate: new Date(2026, 8, 30), // Sept 30, 2026
+        },
+        {
+            name: "Past Date Sale",
+            amount: 7.5,
+            invoicePrefix: "PAST",
+            shipDate: new Date(2026, 6, 15), // July 15, 2026
+        },
+        {
+            name: "Year-End Sale",
+            amount: 25.0,
+            invoicePrefix: "YEAREND",
+            shipDate: new Date(2026, 11, 31), // Dec 31, 2026
+        },
+    ];
+    test.each(testCases)("[Parameterized:DirectMarketing] $name with Direct Marketing fields", async (testCase) => {
+        const directMktFields = buildDirectMarketingFields(`${testCase.invoicePrefix}${Date.now()}`, testCase.shipDate);
+        const response = (await device
+            .sale(testCase.amount)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, `${testCase.name} Direct Marketing`));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            expect(response.terminalRefNumber).toBeTruthy();
             return;
         }
-        const safReferenceNumber = (0, UpaHelpertest_1.getFirstSafReferenceNumber)(safReport);
-        if (!safReferenceNumber) {
-            console.warn("deleteSaf() live MITC prerequisite skipped: no SAF records available.");
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+});
+// ===========================================================================
+// UPA Spec Parameters – cardOnFileIndicator, cardBrandTransId, merchantDecision
+// Per UPA Integrators Guide 02.20.02.B
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Spec Parameters – cardOnFileIndicator (Request)", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[SpecCompliance:cardOnFileIndicator] Sale with cardOnFileIndicator='C' (Cardholder Initiated)", async () => {
+        const response = (await device
+            .sale(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withRequestMultiUseToken(true)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.CardHolder)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "cardOnFileIndicator='C' Sale"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            expect(response.terminalRefNumber).toBeTruthy();
             return;
         }
-        console.log(safReferenceNumber);
-        const response = await device.deleteSaf(safReferenceNumber);
-        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
-        expect(response.command).toBe("DeleteSAF");
-        if (response.status === "Failed") {
-            if (["TRAN001", "TRAN010"].includes(response.deviceResponseCode)) {
-                console.warn(`deleteSaf() reference=${safReferenceNumber} returned spec-valid failure ${response.deviceResponseCode} (${response.deviceResponseText}); only host-declined SAF records are freely deletable per §12.4.25.4.`);
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[SpecCompliance:cardOnFileIndicator] Sale with cardOnFileIndicator='M' (Merchant Initiated)", async () => {
+        const response = (await device
+            .sale(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withRequestMultiUseToken(true)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.Merchant)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "cardOnFileIndicator='M' Sale"));
                 return;
             }
-            throw new Error(`deleteSaf() returned unexpected failure code=${response.deviceResponseCode} status=${response.status} text="${response.deviceResponseText}". Per UPA spec §12.4.25.4 the only permitted failure codes for a well-formed request are TRAN001 or TRAN010.`);
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            expect(response.terminalRefNumber).toBeTruthy();
+            return;
         }
-        (0, UpaHelpertest_1.expectLiveSuccess)(response, "DeleteSAF");
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
     });
-    test('[UpaAdminTests:754] deleteSaf() surfaces response="DeleteSAF", cmdResult.result="Success", and transaction details', async () => {
-        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
-        if (!safReport) {
+    test("[SpecCompliance:cardOnFileIndicator] Refund with cardOnFileIndicator='C'", async () => {
+        const sale = await (0, UpaHelpertest_1.createLiveSale)(device);
+        if (!sale || !sale.transactionId) {
+            console.warn("Refund cardOnFileIndicator test: Sale prerequisite failed");
             return;
         }
-        const safReferenceNumber = (0, UpaHelpertest_1.getFirstSafReferenceNumber)(safReport);
-        if (!safReferenceNumber) {
-            console.warn("deleteSaf() live MITC prerequisite skipped: no SAF records available.");
+        const response = (await device
+            .refund(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withTransactionId(sale.transactionId)
+            .withRequestMultiUseToken(true)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.CardHolder)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "cardOnFileIndicator='C' Refund"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Refund", "SendCommand"]);
             return;
         }
-        const response = await device.deleteSaf(safReferenceNumber);
-        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
-        expect(response.command).toBe("DeleteSAF");
-        if (response.status === "Failed") {
-            if (["TRAN001", "TRAN010"].includes(response.deviceResponseCode)) {
-                console.warn(`deleteSaf() reference=${safReferenceNumber} returned spec-valid failure ${response.deviceResponseCode} (${response.deviceResponseText}); only host-declined SAF records are freely deletable per §12.4.25.4.`);
+        expect(response.status).toBe("Success");
+    });
+    test("[SpecCompliance:cardOnFileIndicator] PreAuth with cardOnFileIndicator='M'", async () => {
+        const response = (await device
+            .authorize(10.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withRequestMultiUseToken(true)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.Merchant)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "cardOnFileIndicator='M' PreAuth"));
                 return;
             }
-            throw new Error(`deleteSaf() returned unexpected failure code=${response.deviceResponseCode} status=${response.status} text="${response.deviceResponseText}". Per UPA spec §12.4.25.4 the only permitted failure codes for a well-formed request are TRAN001 or TRAN010.`);
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["PreAuth", "SendCommand"]);
+            expect(response.transactionId).toBeTruthy();
+            return;
         }
         expect(response.status).toBe("Success");
-        expect(response.deviceResponseCode).toBe("00");
-        if (response.totalCount !== undefined ||
-            response.totalAmount !== undefined) {
-            expect(response.totalCount).toBeGreaterThanOrEqual(0);
-            expect(response.totalAmount).toBeGreaterThanOrEqual(0);
-        }
     });
-    test("[UpaAdminTests:754] deleteSaf() by tranNo executes over live MITC", async () => {
-        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
-        if (!safReport) {
+});
+// ===========================================================================
+// UPA Spec Parameters – cardBrandTransId Response Validation
+// Per UPA spec: cardBrandTransId echoed in response for Sale, Refund, PreAuth, AuthCompletion
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Spec Parameters – cardBrandTransId Response", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[SpecCompliance:cardBrandTransId] Sale with cardBrandTransId parameter", async () => {
+        const testTransId = "VISA_TRANS_20260817_001";
+        const response = (await device
+            .sale(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withCardBrandTransId(testTransId)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "cardBrandTransId Sale request"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            // Per spec: cardBrandTransId should be echoed in response
+            if (response.cardBrandTransId) {
+                console.log("cardBrandTransId in response: %s", response.cardBrandTransId);
+            }
             return;
         }
-        const candidateTranNo = extractTranNoFromSafReport(safReport);
-        if (!candidateTranNo) {
-            console.warn("deleteSaf(by tranNo) live MITC prerequisite skipped: no SAF record exposed a numeric tranNo/transId.");
+        expect(response.status).toBe("Success");
+    });
+    test("[SpecCompliance:cardBrandTransId] Refund preserves cardBrandTransId", async () => {
+        const sale = await (0, UpaHelpertest_1.createLiveSale)(device);
+        if (!sale || !sale.transactionId) {
+            console.warn("Refund cardBrandTransId test: Sale prerequisite failed");
             return;
         }
-        expect(device.deleteSaf.length).toBeGreaterThanOrEqual(2);
-        const response = await device.deleteSaf(undefined, candidateTranNo);
-        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
-        expect(response.command).toBe("DeleteSAF");
-        expect(["Success", "Failed"]).toContain(response.status);
-        if (response.status === "Failed") {
-            expect(["TRAN001", "TRAN010"]).toContain(response.deviceResponseCode);
+        const testTransId = "MC_TRANS_20260817_002";
+        const response = (await device
+            .refund(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withTransactionId(sale.transactionId)
+            .withCardBrandTransId(testTransId)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "cardBrandTransId Refund request"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Refund", "SendCommand"]);
+            return;
         }
+        expect(response.status).toBe("Success");
     });
-    test("[UpaAdminTests:754] deleteSaf() with no identifiers deletes all host-declined SAF transactions", async () => {
-        expect(typeof device.deleteSaf).toBe("function");
-        expect(device.deleteSaf.length).toBeGreaterThanOrEqual(0);
-        if (process.env.UPA_DELETE_ALL_SAF !== "true") {
-            console.warn("deleteSaf() delete-all live scenario skipped. Set UPA_DELETE_ALL_SAF=true to execute (DESTRUCTIVE: erases every host-declined SAF record on the device).");
+    test("[SpecCompliance:cardBrandTransId] PreAuth with cardBrandTransId echoed in response", async () => {
+        const testTransId = "AMEX_TRANS_20260817_003";
+        const response = (await device
+            .authorize(15.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withCardBrandTransId(testTransId)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "cardBrandTransId PreAuth request"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["PreAuth", "SendCommand"]);
+            expect(response.transactionId).toBeTruthy();
+            // Verify cardBrandTransId presence
+            if (response.cardBrandTransId) {
+                console.log("PreAuth cardBrandTransId in response: %s", response.cardBrandTransId);
+            }
             return;
         }
-        // Seed at least one SAF record so the delete-all has something to act on.
-        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
-        if (!safReport) {
+        expect(response.status).toBe("Success");
+    });
+});
+// ===========================================================================
+// UPA Spec Parameters – Direct Marketing Response Fields
+// Per UPA spec: directMktInvoiceNbr, directMktShipMonth, directMktShipDay echoed in response
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Spec Parameters – Direct Marketing Response Fields", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[SpecCompliance:DirectMkt] Sale response contains directMktInvoiceNbr", async () => {
+        const directMktFields = buildDirectMarketingFields("INV20260817_RESP_001");
+        const response = (await device
+            .sale(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "directMktInvoiceNbr response"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            // Per UPA spec: directMktInvoiceNbr should be in response
+            if (response.directMktInvoiceNbr) {
+                expect(response.directMktInvoiceNbr).toBe(directMktFields.directMktInvoiceNbr);
+                console.log("✓ Sale response contains directMktInvoiceNbr: %s", response.directMktInvoiceNbr);
+            }
+            else {
+                console.warn("⚠ Sale response missing directMktInvoiceNbr field (device may not support)");
+            }
             return;
         }
-        const response = await device.deleteSaf();
-        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
-        expect(response.command).toBe("DeleteSAF");
-        // Success is the expected outcome; Failed with TRAN001
-        // if the batch happens to contain no host-declined records at execution time
-        expect(["Success", "Failed"]).toContain(response.status);
+        expect(response.status).toBe("Success");
     });
-    test("[UpaCreditTests] sale() serializes processing indicators without mocked responses", async () => {
-        const saleResponse = await (0, UpaHelpertest_1.createLiveSale)(device);
-        expect(saleResponse.status).toBe("Success");
+    test("[SpecCompliance:DirectMkt] Sale response contains directMktShipMonth (01-12 format)", async () => {
+        const directMktFields = buildDirectMarketingFields("INV20260817_MONTH_001");
+        const response = (await device
+            .sale(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "directMktShipMonth response"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            // Verify month format (01-12)
+            if (response.directMktShipMonth) {
+                expect(/^(0[1-9]|1[0-2])$/.test(response.directMktShipMonth)).toBe(true);
+                expect(response.directMktShipMonth).toBe(directMktFields.directMktShipMonth);
+                console.log("✓ Sale response contains directMktShipMonth: %s (valid format)", response.directMktShipMonth);
+            }
+            else {
+                console.warn("⚠ Sale response missing directMktShipMonth field (device may not support)");
+            }
+            return;
+        }
+        expect(response.status).toBe("Success");
     });
-    test("[UpaAdminTests:754] deleteSaf() surfaces TRAN001 (TRANSACTION NOT FOUND) over live MITC", async () => {
-        const unknownSafReferenceNumber = `UNKNOWN-123`;
-        const response = await device.deleteSaf(unknownSafReferenceNumber);
-        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
-        expect(response.command).toBe("DeleteSAF");
-        expect(response.status).toBe("Failed");
-        if (response.deviceResponseCode === "TRAN001") {
-            expect(response.deviceResponseMessage).toMatch(/NOT FOUND/i);
+    test("[SpecCompliance:DirectMkt] Sale response contains directMktShipDay (01-31 format)", async () => {
+        const directMktFields = buildDirectMarketingFields("INV20260817_DAY_001");
+        const response = (await device
+            .sale(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "directMktShipDay response"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            // Verify day format (01-31)
+            if (response.directMktShipDay) {
+                expect(/^(0[1-9]|[12][0-9]|3[01])$/.test(response.directMktShipDay)).toBe(true);
+                expect(response.directMktShipDay).toBe(directMktFields.directMktShipDay);
+                console.log("✓ Sale response contains directMktShipDay: %s (valid format)", response.directMktShipDay);
+            }
+            else {
+                console.warn("⚠ Sale response missing directMktShipDay field (device may not support)");
+            }
             return;
         }
-        console.log(`deleteSaf() unknown reference returned ${response.deviceResponseCode} (${response.deviceResponseMessage}) instead of TRAN001; device firmware may normalize unknown references.`);
+        expect(response.status).toBe("Success");
     });
-    test("[UpaAdminTests:754] deleteSaf() surfaces TRAN010 (TRANSACTION CANNOT BE DELETED) over live MITC", async () => {
-        const safReport = await (0, UpaHelpertest_1.ensureSafData)(device, UpaHelpertest_1.createLiveSale, settle);
-        if (!safReport) {
+    test("[SpecCompliance:DirectMkt] Refund response contains Direct Marketing fields", async () => {
+        const sale = await (0, UpaHelpertest_1.createLiveSale)(device);
+        if (!sale || !sale.transactionId) {
+            console.warn("Refund Direct Marketing response test: Sale prerequisite failed");
             return;
         }
-        const approvedBucket = safReport.reportResult?.approved ?? {};
-        let approvedReferenceNumber;
-        for (const summary of Object.values(approvedBucket)) {
-            const transaction = summary?.transactions?.[0];
-            if (transaction?.referenceNumber) {
-                approvedReferenceNumber = transaction.referenceNumber;
-                break;
+        const directMktFields = buildDirectMarketingFields("INV20260817_REFUND");
+        const response = (await device
+            .refund(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withTransactionId(sale.transactionId)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Refund Direct Marketing response"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Refund", "SendCommand"]);
+            // Validate all three fields
+            if (response.directMktInvoiceNbr) {
+                expect(response.directMktInvoiceNbr).toBe(directMktFields.directMktInvoiceNbr);
+            }
+            if (response.directMktShipMonth) {
+                expect(response.directMktShipMonth).toBe(directMktFields.directMktShipMonth);
+            }
+            if (response.directMktShipDay) {
+                expect(response.directMktShipDay).toBe(directMktFields.directMktShipDay);
+            }
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[SpecCompliance:DirectMkt] PreAuth response contains Direct Marketing fields", async () => {
+        const directMktFields = buildDirectMarketingFields("INV20260817_PREAUTH");
+        const response = (await device
+            .authorize(10.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "PreAuth Direct Marketing response"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["PreAuth", "SendCommand"]);
+            // All three Direct Marketing fields should be present
+            expect(response.transactionId).toBeTruthy();
+            if (response.directMktInvoiceNbr) {
+                console.log("✓ PreAuth response directMktInvoiceNbr: %s", response.directMktInvoiceNbr);
             }
-        }
-        if (!approvedReferenceNumber) {
-            console.warn("deleteSaf() TRAN010 live scenario skipped: no approved (host-authorized) SAF records available. TRAN010 requires a pending or authorized transaction reference per spec §12.4.25.4.");
-            return;
-        }
-        const response = await device.deleteSaf(approvedReferenceNumber);
-        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
-        expect(response.command).toBe("DeleteSAF");
-        expect(response.status).toBe("Failed");
-        if (response.deviceResponseCode === "TRAN010") {
-            expect(response.deviceResponseMessage.toUpperCase()).toContain("CANNOT BE DELETED");
             return;
         }
-        console.warn(`deleteSaf() authorized-reference delete returned ${response.deviceResponseCode} (${response.deviceResponseMessage}) instead of TRAN010; device firmware may normalize the authorized-transaction outcome.`);
+        expect(response.status).toBe("Success");
     });
 });
-(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – cancel()", () => {
+// ===========================================================================
+// UPA Spec Parameters – merchantDecision EMV Flow
+// Per UPA spec: Used in ProcessCardTransaction, ContinueCardTransaction, ContinueEMVTransaction
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Spec Parameters – merchantDecision EMV Flow", () => {
     let device;
     beforeEach(() => {
         device = (0, UpaHelpertest_1.createTestDevice)();
     });
-    function buildCancelableStartCardTransactionRequest() {
+    test("[SpecCompliance:merchantDecision] ProcessCardTransaction with merchantDecision='Approve'", async () => {
+        // Note: ProcessCardTransaction requires an active EMV flow which needs live MITC device
+        // This test documents the expected behavior per UPA spec
         const param = new UpaParam_1.UpaParam();
-        param.acquisitionTypes = [
-            AcquisitionType_1.AcquisitionType.Contact,
-            AcquisitionType_1.AcquisitionType.Contactless,
-            AcquisitionType_1.AcquisitionType.Swipe,
-            AcquisitionType_1.AcquisitionType.Manual,
-        ];
-        param.header = "Cancel Transaction";
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Contact];
+        param.timeout = 60;
+        param.header = "EMV Merchant Decision";
         param.displayTotalAmount = "Yes";
-        param.promptForManual = false;
-        param.timeout = 30;
         const indicator = new ProcessIndicator_1.ProcessingIndicator();
         indicator.QuickChip = "Y";
-        indicator.CheckLuhn = "N";
-        indicator.SecurityCode = "Y";
-        indicator.CardTypeFilter = [
-            CardTypeFilter_1.CardTypeFilter.VISA,
-            CardTypeFilter_1.CardTypeFilter.MC,
-            CardTypeFilter_1.CardTypeFilter.AMEX,
-            CardTypeFilter_1.CardTypeFilter.DISCOVER,
-        ];
         const transData = new UpaTransactionData_1.UpaTransactionData();
-        transData.totalAmount = 1.0;
+        transData.totalAmount = 10.0;
         transData.cashBackAmount = 0.0;
         transData.tranDate = new Date();
         transData.tranTime = new Date();
         transData.transType = src_1.TransactionType.Sale;
-        return [param, indicator, transData];
-    }
-    function timeoutAfter(delayMs, label) {
-        return new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`${label} timed out after ${delayMs}ms`)), delayMs);
-        });
-    }
-    function sleep(delayMs) {
-        return new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
-    test("[UpaAdminTests:711] cancel() cancels an active startCardTransaction over live MITC", async () => {
-        const [param, indicator, transData] = buildCancelableStartCardTransactionRequest();
-        const activeCommand = device
-            .startCardTransaction(param, indicator, transData)
-            .then((response) => ({ kind: "resolved", response }))
-            .catch((error) => ({ kind: "rejected", error }));
-        await sleep(2000);
-        await expect(device.cancel()).resolves.toBeUndefined();
-        const result = await Promise.race([
-            activeCommand,
-            timeoutAfter(45000, "cancelled startCardTransaction"),
-        ]);
-        if (result.kind === "resolved") {
-            expect(result.response).toBeTruthy();
-            if (result.response instanceof TransactionResponse_1.TransactionResponse) {
-                expect([
-                    "StartCardTransaction",
-                    "CancelTransaction",
-                    "SendCommand",
-                ]).toContain(result.response.command);
+        try {
+            const response = await device.startCardTransaction(param, indicator, transData);
+            expect(response).not.toBeNull();
+            if (UpaHelpertest_1.useLiveMic) {
+                // Per UPA spec: merchantDecision parameter is used in EMV processing
+                console.log("merchantDecision='Approve' would be used during EMV transaction processing");
+                // In live flow, this would be part of ContinueCardTransaction or ProcessCardTransaction
             }
-            return;
         }
-        expect(result.error).toBeInstanceOf(Error);
-    });
-    test("[UpaAdminTests:711] cancel() sends CancelTransaction without a displayOption parameter", async () => {
-        expect(typeof device.cancel).toBe("function");
-        expect(device.cancel.length).toBe(0);
-        await expect(device.cancel()).resolves.toBeUndefined();
-    });
-    test("[UpaAdminTests:711] cancel() handles APP006 (TRANSACTION CANNOT BE CANCELED) without throwing", async () => {
-        await expect(device.cancel()).resolves.toBeUndefined();
+        catch (error) {
+            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("merchantDecision='Approve' test timed out (expected for device awaiting card)");
+                return;
+            }
+            // Expected in test environment without live device
+        }
     });
 });
-(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – registerPOS()", () => {
+// ===========================================================================
+// UPA Spec Parameters – lineItemDisplay (lineItemLeft, lineItemRight)
+// Per UPA Integrators Guide 02.20.02.B – Display-only parameters for terminal UI
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Spec Parameters – lineItemDisplay", () => {
     let device;
     beforeEach(() => {
         device = (0, UpaHelpertest_1.createTestDevice)();
     });
-    test("[UpaAdminTests:776] registerPOS() executes over live MITC", async () => {
-        const posData = new src_1.POSData();
-        posData.appName = `com.global.testapp.${Date.now()}`;
-        posData.launchOrder = 1;
-        posData.remove = false;
-        posData.silent = 0;
-        try {
-            const response = await device.registerPOS(posData);
-            expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
-            expect(response.status).toBe("Success");
-            (0, UpaHelpertest_1.expectLiveSuccess)(response, "RegisterPOS");
+    test("[SpecCompliance:lineItemDisplay] Sale with lineItemLeft and lineItemRight display parameters", async () => {
+        const response = (await device
+            .sale(10.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withLineItemLeft("Widget - Product 1")
+            .withLineItemRight("Qty: 1 @ $10.00")
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "lineItem display Sale"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            return;
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            if (message.includes("SYSTEM_ERROR")) {
-                console.warn("registerPOS() succeeded on the device but GP-API returned SYSTEM_ERROR during response mediation; verify registration state on the terminal.");
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[DirectMarketing:lineItemDisplay] Sale with lineItemLeft/Right and Direct Marketing fields", async () => {
+        const directMktFields = buildDirectMarketingFields("INV987654");
+        const response = (await device
+            .sale(25.5)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withLineItemLeft("Coffee Cup - Medium")
+            .withLineItemRight("QTY: 2 @ $12.75")
+            .withDirectMktInvoiceNbr(directMktFields.directMktInvoiceNbr)
+            .withDirectMktShipMonth(directMktFields.directMktShipMonth)
+            .withDirectMktShipDay(directMktFields.directMktShipDay)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "lineItem + directMkt combined Sale"));
                 return;
             }
-            throw err;
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Sale", "SendCommand"]);
+            // Verify direct marketing fields are echoed in response
+            expect(response.directMktInvoiceNbr).toBe(directMktFields.directMktInvoiceNbr);
+            expect(response.directMktShipMonth).toBe(directMktFields.directMktShipMonth);
+            expect(response.directMktShipDay).toBe(directMktFields.directMktShipDay);
+            return;
+        }
+        expect(response.status).toBe("Success");
+        // In mock mode, direct marketing fields should be echoed
+        if (response.directMktInvoiceNbr) {
+            expect(response.directMktInvoiceNbr).toBe(directMktFields.directMktInvoiceNbr);
+        }
+    });
+    test("[SpecCompliance:lineItemDisplay] Refund with lineItemLeft display text", async () => {
+        const sale = await (0, UpaHelpertest_1.createLiveSale)(device);
+        if (!sale || !sale.transactionId) {
+            console.warn("lineItem Refund test: Sale prerequisite failed");
+            return;
+        }
+        const response = (await device
+            .refund(15.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withTransactionId(sale.transactionId)
+            .withLineItemLeft("Refund - Original Sale")
+            .withLineItemRight("Qty: 1")
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "lineItem Refund"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Refund", "SendCommand"]);
+            return;
         }
+        expect(response.status).toBe("Success");
     });
 });
 // ===========================================================================
-// verify()
-//   CardVerify command with tokenRequest = "1"
-//   Confirms a multi-use token is created and returned by the host
+// UPA Spec Parameters – preAuthAmount
+// Per UPA Integrators Guide 02.20.02.B – Pre-authorization amount (tip allowance workflow)
 // ===========================================================================
-(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – verify()", () => {
+(0, UpaHelpertest_1.describeUpaLive)("UPA Spec Parameters – preAuthAmount", () => {
     let device;
     beforeEach(() => {
         device = (0, UpaHelpertest_1.createTestDevice)();
     });
-    test("[UpaMicTests] verify() returns expected response", async () => {
-        const response = await device.verify().withEcrId(13).execute();
+    test("[SpecCompliance:preAuthAmount] PreAuth with base authorization and higher preAuthAmount (tip allowance)", async () => {
+        const baseAmount = 25.0;
+        const preAuthAmount = 35.0;
+        const response = (await device
+            .authorize(baseAmount) // Base authorization amount
+            .withEcrId(13)
+            .withClerkId(123)
+            .withPreAuthAmount(preAuthAmount) // Hold amount (includes tip allowance)
+            .execute());
         expect(response).not.toBeNull();
         expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "preAuthAmount PreAuth"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["PreAuth", "SendCommand"]);
+            expect(response.transactionId).toBeTruthy();
+            return;
+        }
         expect(response.status).toBe("Success");
         expect(response.deviceResponseCode).toBe("00");
     });
-    test("[UpaMicTests] verify() with tokenRequest = 1 returns a token", async () => {
-        try {
-            const response = await device
-                .verify()
-                .withRequestMultiUseToken(true)
-                .withCardBrandStorage(src_1.StoredCredentialInitiator.CardHolder)
-                .withEcrId(13)
-                .execute();
-            console.log("[VERIFY RESPONSE]", JSON.stringify(response, null, 2));
-            expect(response).not.toBeNull();
-            expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
-            if (UpaHelpertest_1.useLiveMic) {
-                if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
-                    console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "CardVerify tokenRequest"));
-                    return;
-                }
-                (0, UpaHelpertest_1.expectLiveSuccess)(response, ["CardVerify", "SendCommand"]);
-                expect(response.token).toBeTruthy();
-                expect(response.token.length).toBeGreaterThan(0);
+    test("[SpecCompliance:preAuthAmount] Refund of preAuthorized transaction", async () => {
+        const authResponse = (await device
+            .authorize(25.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withPreAuthAmount(35.0)
+            .execute());
+        if (!authResponse || !authResponse.transactionId) {
+            console.warn("preAuthAmount Refund: PreAuth prerequisite failed");
+            return;
+        }
+        // Refund the actual used amount, not the preAuthAmount hold
+        const refundResponse = (await device
+            .refund(25.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .withTransactionId(authResponse.transactionId)
+            .execute());
+        expect(refundResponse).not.toBeNull();
+        expect(refundResponse).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(refundResponse)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(refundResponse, "preAuthAmount Refund"));
                 return;
             }
-            expect(response.status).toBe("Success");
-            expect(response.deviceResponseCode).toBe("00");
-            // ...existing expects
-        }
-        catch (err) {
-            console.log("[VERIFY ERROR]", err);
-            throw err;
+            (0, UpaHelpertest_1.expectLiveSuccess)(refundResponse, ["Refund", "SendCommand"]);
+            return;
         }
+        expect(refundResponse.status).toBe("Success");
     });
-    // ===============================================================//
-    test("[UpaManageTests:600] capture() serializes processCPC indicator", async () => {
-        const controller = src_1.ServicesContainer.instance().getDeviceController();
-        const responseauth = await device
-            .authorize(10.0)
+    test("[SpecCompliance:preAuthAmount] PreAuth with preAuthAmount less than base authorization (decline allowance)", async () => {
+        // Scenario: Merchant wants to allow refund but NOT tip (e.g., phone order)
+        const baseAmount = 50.0;
+        const preAuthAmount = 50.0; // No tip allowance
+        const response = (await device
+            .authorize(baseAmount)
             .withEcrId(13)
-            .execute();
-        const builder = device
-            .capture()
-            .withTransactionId(responseauth.transactionId)
-            .withAmount(10.0)
-            .withEcrId(13)
-            .withProcessCPC(true);
-        const request = controller.buildManageTransaction(builder).getJsonRequest();
-        console.log("[UpaManageTests:600] Capture with processCPC request payload:\n" +
-            JSON.stringify(request, null, 2));
-        expect(request.data.command).toBe("AuthCompletion");
-        expect(request.data.data.transaction.processCPC).toBe("1");
-        const response = await builder.execute();
+            .withClerkId(123)
+            .withPreAuthAmount(preAuthAmount)
+            .execute());
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "preAuthAmount no-tip PreAuth"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["PreAuth", "SendCommand"]);
+            expect(response.transactionId).toBeTruthy();
+            return;
+        }
         expect(response.status).toBe("Success");
     });
-    test("[UpaManageTests:601] capture() serializes processCPC false as 0", async () => {
-        const responseauth = await device
-            .authorize(10.0)
+    test("[SpecCompliance:preAuthAmount] AuthCompletion with preAuthAmount establishes hold", async () => {
+        const authResponse = (await device
+            .authorize(30.0)
             .withEcrId(13)
-            .execute();
-        const controller = src_1.ServicesContainer.instance().getDeviceController();
-        sleep(100);
-        const builder = device
-            .capture()
-            .withTransactionId(responseauth.transactionId)
-            .withAmount(10.0)
+            .withClerkId(123)
+            .withPreAuthAmount(40.0)
+            .execute());
+        if (!authResponse || !authResponse.transactionId) {
+            console.warn("preAuthAmount AuthCompletion: PreAuth prerequisite failed");
+            return;
+        }
+        // Complete auth with the established preAuthAmount hold
+        const completeResponse = (await device
+            .authCompletion()
             .withEcrId(13)
-            .withProcessCPC(false);
-        const request = controller.buildManageTransaction(builder).getJsonRequest();
-        console.log("[UpaManageTests:601] Capture with processCPC false request payload:\n" +
-            JSON.stringify(request, null, 2));
-        expect(request.data.command).toBe("AuthCompletion");
-        expect(request.data.data.transaction.processCPC).toBe("0");
-        const response = await builder.execute();
-        expect(response.status).toBe("Success");
+            .withTransactionId(authResponse.transactionId)
+            .withAmount(35.0) // Actual tip + base amount used
+            .execute());
+        expect(completeResponse).not.toBeNull();
+        expect(completeResponse).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(completeResponse)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(completeResponse, "preAuthAmount AuthCompletion"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(completeResponse, ["AuthCompletion", "SendCommand"]);
+            return;
+        }
+        expect(completeResponse.status).toBe("Success");
+    });
+});
+// ===========================================================================
+// JIRA Story Requirements – Value Mapping Validation
+// ===========================================================================
+describe("JIRA Story: UPA Transaction Processing – Value Mapping", () => {
+    /**
+     * Verify that cardOnFileIndicator values map correctly:
+     * CardHolder -> 'C', Merchant -> 'M'
+     */
+    test("[Mapping:cardOnFileIndicator] Enum values map to correct UPA strings", () => {
+        // The enum itself stores the mapped values
+        expect(src_1.StoredCredentialInitiator.CardHolder).toBe("C");
+        expect(src_1.StoredCredentialInitiator.Merchant).toBe("M");
+    });
+    /**
+     * Verify acquisitionTypes can be joined for UPA format
+     */
+    test("[Mapping:acquisitionTypes] Array joins correctly for UPA request", () => {
+        const types = [
+            AcquisitionType_1.AcquisitionType.Contact,
+            AcquisitionType_1.AcquisitionType.Contactless,
+            AcquisitionType_1.AcquisitionType.Swipe,
+        ];
+        const joined = types.join("|");
+        expect(joined).toMatch(/Contact\|Contactless\|Swipe/);
+    });
+});
+// ===========================================================================
+// JIRA Story Requirements – Acceptance Conditions
+// ===========================================================================
+describe("JIRA Story: UPA Transaction Processing – Acceptance Criteria", () => {
+    /**
+     * Acceptance Criteria:
+     * Region: US
+     * Gateway: GP-API
+     * Environment: Sandbox
+     * Devices: UPA
+     * Payment Types: MC, VISA, Amex
+     * Credentials: Non-specific
+     *
+     * GIVEN: Node SDK is used
+     * WHEN: Tests run with all required fields
+     * THEN: Request goes through to UPA and transaction processes successfully
+     */
+    test("[Acceptance:Criteria] All JIRA requirements are testable", () => {
+        // This test verifies the structure supports the acceptance criteria
+        const device = (0, UpaHelpertest_1.createTestDevice)();
+        // Verify device is properly configured
+        expect(device).toBeDefined();
+        expect(device).toHaveProperty("sale");
+        expect(device).toHaveProperty("authorize");
+        expect(device).toHaveProperty("refund");
+        // Verify all builder methods are available
+        const saleBuilder = device.sale(10.0);
+        const requiredMethods = [
+            "withClerkId",
+            "withCardOnFileIndicator",
+            "withCardBrandTransId",
+            "withLineItemLeft",
+            "withLineItemRight",
+            "withLanguage",
+            "withMerchantDecision",
+            "withAcquisitionTypes",
+            "withPreAuthAmount",
+            "execute",
+        ];
+        for (const method of requiredMethods) {
+            expect(saleBuilder).toHaveProperty(method);
+            expect(typeof saleBuilder[method]).toBe("function");
+        }
+    });
+    /**
+     * Verify no manual code is needed - SDK handles everything
+     */
+    test.only("[Acceptance:NoManualCode] SDK methods handle all required fields", () => {
+        const device = (0, UpaHelpertest_1.createTestDevice)();
+        const builder = device
+            .sale(100.0)
+            .withClerkId(1)
+            .withCardOnFileIndicator(src_1.StoredCredentialInitiator.CardHolder)
+            .withCardBrandTransId("BRAND-001")
+            .withLineItemLeft("Test Item")
+            .withLineItemRight("$100.00")
+            .withLanguage("en")
+            .withMerchantDecision("Approve")
+            .withAcquisitionTypes([AcquisitionType_1.AcquisitionType.Contact])
+            .withPreAuthAmount(125.0);
+        // All fields should be set without manual property access
+        expect(builder.amount).toBe(100.0);
+        expect(builder.clerkId).toBe(1);
+        expect(builder.cardOnFileIndicator).toBe(src_1.StoredCredentialInitiator.CardHolder);
     });
 });
 // refund() with all administrative enhancements