globalpayments-api 3.10.14 → 3.11.0

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

@@ -0,0 +1,1260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for device-level methods:
+ *   endOfDay(), sendStoreAndForward(), getSignature(), ping(),
+ *   balance(), reverse(), deletePreAuth(),
+ *   startCardTransaction(), reboot(),
+ *   MITC connection mode, deleteSaf(), cancel(), registerPOS()
+ *
+ */
+const src_1 = require("../../../../src");
+const DeviceService_1 = require("../../../../src/Services/DeviceService");
+const AcquisitionType_1 = require("../../../../src/Entities/Enums/AcquisitionType");
+const CardTypeFilter_1 = require("../../../../src/Entities/Enums/CardTypeFilter");
+const ProcessIndicator_1 = require("../../../../src/Entities/UPA/ProcessIndicator");
+const UpaParam_1 = require("../../../../src/Entities/UPA/UpaParam");
+const UpaTransactionData_1 = require("../../../../src/Entities/UPA/UpaTransactionData");
+const TransactionResponse_1 = require("../../../../src/Terminals/UPA/Reponses/TransactionResponse");
+const UpaEODResponse_1 = require("../../../../src/Terminals/UPA/Reponses/UpaEODResponse");
+const UpaGiftCardResponse_1 = require("../../../../src/Terminals/UPA/Reponses/UpaGiftCardResponse");
+const UpaSAFResponse_1 = require("../../../../src/Terminals/UPA/Reponses/UpaSAFResponse");
+const UpaSignatureResponse_1 = require("../../../../src/Terminals/UPA/Reponses/UpaSignatureResponse");
+const UpaHelpertest_1 = require("./UpaHelpertest");
+jest.setTimeout(240000);
+function sleep(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+async function settleDevice(delayMs = 8000) {
+    if (UpaHelpertest_1.useLiveMic) {
+        await sleep(delayMs);
+    }
+}
+afterEach(async () => {
+    await settleDevice();
+});
+// ===========================================================================
+// endOfDay()
+//   response != null, Status == "Success"
+//   response != null
+//   DeviceResponseText == "Success", DeviceResponseCode == "00"
+//   BatchId != null
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – endOfDay()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaCreditTests][UpaDebitTests][UpaEbtTests][UpaMicTests] endOfDay() returns expected response", async () => {
+        const saleresponse = await device
+            .sale(5.0)
+            .withEcrId(13)
+            .withClerkId(123)
+            .execute();
+        expect(saleresponse).not.toBeNull();
+        expect(saleresponse.deviceResponseCode).toBe("00");
+        const response = await device.endOfDay();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaEODResponse_1.UpaEODResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            expect(response.command).toBe("EODProcessing");
+            expect(response.status).toBeTruthy();
+            expect(response.deviceResponseCode).toBeTruthy();
+            expect(response.deviceResponseText).toBeTruthy();
+            if (response.status === "Success") {
+                expect(response.deviceResponseCode).toBe("00");
+                expect(response.deviceResponseText).toBe("Success");
+                expect(response.batchId).toBeDefined();
+                expect(response.batchId).not.toBeNull();
+            }
+            else {
+                expect(response.status).toBe("Failed");
+            }
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseText).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+        expect(response.batchId).toBeDefined();
+        expect(response.batchId).not.toBeNull();
+    });
+});
+// ===========================================================================
+// sendStoreAndForward()
+// Status == "Success", DeviceResponseText == "Success", DeviceResponseCode == "00"
+//  no assertion (only checks no ApiException thrown)
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – sendStoreAndForward()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaAdminTests][UpaMicTests] sendStoreAndForward() returns expected response and does not throw", async () => {
+        const response = await device.sendStoreAndForward();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaSAFResponse_1.UpaSAFResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            expect(response.command).toBe("SendSAF");
+            expect(response.status).toBeTruthy();
+            expect(response.deviceResponseCode).toBeTruthy();
+            expect(response.deviceResponseText).toBeTruthy();
+            if (response.status === "Success") {
+                expect(response.deviceResponseCode).toBe("00");
+                expect(response.deviceResponseText).toBe("Success");
+            }
+            else {
+                expect(response.status).toBe("Failed");
+            }
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseText).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+});
+// ===========================================================================
+// getSignature() / PromptAndGetSignatureFile()
+// DeviceResponseCode == "00", Status == "Success"
+// SignatureData != null
+// SignatureData populated (with prompt2 + displayOption)
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – getSignature()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaAdminTests:130][UpaAdminTests:693] getSignature() returns expected response and SignatureData", async () => {
+        const response = await device.getSignature("Please sign");
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaSignatureResponse_1.UpaSignatureResponse);
+        expect(response.deviceResponseCode).toBe("00");
+        expect(response.status).toBe("Success");
+        expect(response.signatureData).not.toBeNull();
+        expect(response.signatureData).toBeInstanceOf(Buffer);
+    });
+    test("[UpaMicTests:483] getSignature() with prompt2 + displayOption returns populated SignatureData", async () => {
+        const response = await device.getSignature("Please sign", "and confirm", 1);
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(UpaSignatureResponse_1.UpaSignatureResponse);
+        expect(response.signatureData).toBeInstanceOf(Buffer);
+        expect(response.signatureData.length).toBeGreaterThan(0);
+    });
+});
+// ===========================================================================
+// ping()
+// DeviceResponseCode == "00", Status == "Success"
+// no assertion (only checks no ApiException thrown)
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – ping()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaAdminTests:52][UpaMicTests:42] ping() returns expected response values and does not throw", async () => {
+        const response = await device.ping();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            expect(response.responseText).toBe("SUCCESS");
+            expect(["INITIATED", "COMPLETE"]).toContain(response.deviceResponseText);
+            expect(response.transactionId).toBeTruthy();
+            return;
+        }
+        expect(response.deviceResponseCode).toBe("00");
+        expect(response.status).toBe("Success");
+    });
+});
+// ===========================================================================
+// balance()
+//     Assert.AreEqual("00", response.ResponseCode / DeviceResponseCode)
+//     Assert.AreEqual("Success", response.DeviceResponseText)
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – balance()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaEbtTests] balance() with EBT Foodstamp returns deviceResponseCode == '00'", async () => {
+        const response = await device
+            .balance()
+            .withEcrId(13)
+            .withPaymentMethodType(src_1.PaymentMethodType.EBT)
+            .execute();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (UpaHelpertest_1.useLiveMic) {
+            // if (isKnownLiveBalanceBlocker(response)) {
+            //   console.warn(formatLiveFailure(response, "BalanceInquiry Foodstamp"));
+            //   return;
+            // }
+            // if (isKnownLiveBusyBlocker(response)) {
+            //   console.warn(formatLiveFailure(response, "BalanceInquiry Foodstamp"));
+            //   return;
+            // }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["BalanceInquiry", "SendCommand"]);
+            return;
+        }
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[UpaEbtTests] balance() with EBT returns status Success and deviceResponseCode '00'", async () => {
+        const response = await device
+            .balance()
+            .withEcrId(13)
+            .withPaymentMethodType(src_1.PaymentMethodType.EBT)
+            .execute();
+        expect(response).not.toBeNull();
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseText).toBe("COMPLETE");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[LivePositive] balance() with MC card returns success", async () => {
+        const response = await device
+            .balance()
+            .withEcrId(13)
+            .withPaymentMethodType(src_1.PaymentMethodType.Credit)
+            .execute();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        (0, UpaHelpertest_1.expectLiveSuccess)(response, ["BalanceInquiry", "SendCommand"]);
+        (0, UpaHelpertest_1.expectLiveBalanceResponseFields)(response);
+        expect(response.cardGroup).toBe("CREDIT");
+        expect(response.cardType).toMatch(/^(MASTERCARD|MasterCard|MC)$/i);
+    });
+    test("[LivePositive] balance() returns documented response fields on success", async () => {
+        const response = await device
+            .balance()
+            .withEcrId(13)
+            .withPaymentMethodType(src_1.PaymentMethodType.Credit)
+            .execute();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        (0, UpaHelpertest_1.expectLiveSuccess)(response, ["BalanceInquiry", "SendCommand"]);
+        (0, UpaHelpertest_1.expectLiveBalanceResponseFields)(response);
+        expect(response.cardType).toBeTruthy();
+        expect(response.cardGroup).toBeTruthy();
+        expect(response.cardHolderName).toBeTruthy();
+    });
+    test("[LivePositive] balance() with EBT populates ebtType and cardGroup", async () => {
+        const response = await device
+            .balance()
+            .withEcrId(13)
+            .withPaymentMethodType(src_1.PaymentMethodType.EBT)
+            .execute();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        expect(["BalanceInquiry", "SendCommand"]).toContain(response.command);
+        if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
+            console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "BalanceInquiry EBT field validation"));
+            return;
+        }
+        if ((0, UpaHelpertest_1.isKnownLiveBalanceBlocker)(response)) {
+            expect(response.cardGroup).toBeTruthy();
+            expect(response.ebtType).toBeTruthy();
+            expect(response.cardType).toBeTruthy();
+            return;
+        }
+        (0, UpaHelpertest_1.expectLiveSuccess)(response, ["BalanceInquiry", "SendCommand"]);
+        (0, UpaHelpertest_1.expectLiveBalanceResponseFields)(response);
+        if (response.cardGroup !== "EBT" || !response.ebtType) {
+            console.warn("BalanceInquiry EBT field validation requires an actual EBT-presented card; the current live run returned a non-EBT successful balance response.");
+            return;
+        }
+        expect(response.cardGroup).toBe("EBT");
+        expect(response.ebtType).toBeTruthy();
+        expect(response.cardType).toBeTruthy();
+    });
+    test("[LiveNegative] balance() with invalid target device surfaces device error", async () => {
+        const unavailableDevice = DeviceService_1.DeviceService.create((0, UpaHelpertest_1.buildConfig)());
+        unavailableDevice.ecrId = "99999999";
+        await (0, UpaHelpertest_1.expectLiveBalanceFailure)(() => unavailableDevice
+            .balance()
+            .withEcrId(99999999)
+            .withPaymentMethodType(src_1.PaymentMethodType.Credit)
+            .execute(), "BalanceInquiry invalid target device");
+    });
+    test("[LiveSetup] balance() invalid clerk number documents current terminal behavior", async () => {
+        const response = await device
+            .balance()
+            .withEcrId(13)
+            .withClerkId(99999999)
+            .withPaymentMethodType(src_1.PaymentMethodType.Credit)
+            .execute();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
+            console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "BalanceInquiry invalid clerk"));
+            return;
+        }
+        if (response.status !== "Success" ||
+            response.deviceResponseCode !== "00" ||
+            (!!response.responseCode && response.responseCode !== "00")) {
+            expect(response.deviceResponseCode).not.toBe("00");
+            return;
+        }
+        console.warn("BalanceInquiry invalid clerk number was accepted by the current terminal configuration.");
+    });
+    test("[LiveSetup] balance() host error omits availableBalance and documents current reference behavior", async () => {
+        const response = await device
+            .balance()
+            .withEcrId(13)
+            .withPaymentMethodType(src_1.PaymentMethodType.EBT)
+            .execute();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
+            console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "BalanceInquiry host error"));
+            return;
+        }
+        if (response.deviceResponseCode === "HOST001") {
+            expect(response.availableBalance).toBeUndefined();
+            return;
+        }
+        if (response.deviceResponseCode === "APP002") {
+            console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "BalanceInquiry host error"));
+            return;
+        }
+        console.warn("BalanceInquiry host error scenario was not reproduced in the current live run.");
+    });
+});
+// ===========================================================================
+// reverse()
+// ===========================================================================
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – reverse()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaCreditTests] reverse() with TerminalRefNumber returns deviceResponseCode == '00'", async () => {
+        let response;
+        let termno = "";
+        if (UpaHelpertest_1.useLiveMic) {
+            try {
+                const 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"));
+                        return;
+                    }
+                    throw new Error((0, UpaHelpertest_1.formatLiveFailure)(saleResponse, "Sale"));
+                }
+                termno = saleResponse.terminalRefNumber;
+                response = await (0, UpaHelpertest_1.reverseLiveSaleWithRetry)(device, saleResponse.terminalRefNumber);
+            }
+            catch (error) {
+                if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                    console.warn("Reverse live MIC prerequisite timed out while waiting on the device or gateway.");
+                    return;
+                }
+                throw error;
+            }
+        }
+        else {
+            response = await device
+                .reverse()
+                .withTerminalRefNumber(termno)
+                .withEcrId(12)
+                .execute();
+        }
+        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, "Reversal"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Reversal", "SendCommand"]);
+            return;
+        }
+        expect(response.deviceResponseCode).toBe("00");
+        expect(response.status).toBe("Success");
+    });
+    test("[LiveSetup] reverse() without tranNo documents current MITC behavior", async () => {
+        try {
+            const response = await device
+                .reverse()
+                .withAmount(1.0)
+                .withEcrId(12)
+                .execute();
+            if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Reversal auto previous financial transaction"));
+                return;
+            }
+            if ((0, UpaHelpertest_1.isKnownLiveReverseAutoFallbackBlocker)(response)) {
+                console.warn("Reverse auto previous financial transaction is not supported in the current MITC configuration; the terminal requires tranNo.");
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Reversal", "SendCommand"]);
+        }
+        catch (error) {
+            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("Reverse auto previous financial transaction timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    test("[LivePositive] reverse() returns documented response fields on success", async () => {
+        try {
+            const 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"));
+                    return;
+                }
+                throw new Error((0, UpaHelpertest_1.formatLiveFailure)(saleResponse, "Sale"));
+            }
+            const response = await (0, UpaHelpertest_1.reverseLiveSaleWithRetry)(device, saleResponse.terminalRefNumber);
+            if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Reversal response field verification"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Reversal", "SendCommand"]);
+            (0, UpaHelpertest_1.expectLiveReverseResponseFields)(response);
+        }
+        catch (error) {
+            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("Reverse response field verification timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    test("[LiveNegative] reverse() already reversed transaction returns failure", async () => {
+        try {
+            const 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"));
+                    return;
+                }
+                throw new Error((0, UpaHelpertest_1.formatLiveFailure)(saleResponse, "Sale"));
+            }
+            const firstReverseResponse = await (0, UpaHelpertest_1.reverseLiveSaleWithRetry)(device, saleResponse.terminalRefNumber);
+            if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(firstReverseResponse)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(firstReverseResponse, "Initial reversal"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(firstReverseResponse, ["Reversal", "SendCommand"]);
+            await (0, UpaHelpertest_1.expectLiveReverseFailure)(() => (0, UpaHelpertest_1.reverseLiveSaleWithRetry)(device, saleResponse.terminalRefNumber, undefined, 1), "Reversal already reversed transaction");
+        }
+        catch (error) {
+            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("Reverse already reversed transaction timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    test("[LiveNegative] reverse() with invalid authorizedAmount returns failure", async () => {
+        try {
+            const 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"));
+                    return;
+                }
+                throw new Error((0, UpaHelpertest_1.formatLiveFailure)(saleResponse, "Sale"));
+            }
+            await (0, UpaHelpertest_1.expectLiveReverseFailure)(() => (0, UpaHelpertest_1.reverseLiveSaleWithRetry)(device, saleResponse.terminalRefNumber, 99.99, 1), "Reversal invalid authorizedAmount");
+        }
+        catch (error) {
+            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("Reverse invalid authorizedAmount timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    test("[LivePositive] reverse() debit transaction returns success", async () => {
+        try {
+            const saleResponse = await (0, UpaHelpertest_1.createLiveDebitSale)(device);
+            if (saleResponse.deviceResponseCode !== "00") {
+                if ((0, UpaHelpertest_1.isKnownLiveSaleBlocker)(saleResponse)) {
+                    console.warn((0, UpaHelpertest_1.formatLiveFailure)(saleResponse, "Debit Sale"));
+                    return;
+                }
+                throw new Error((0, UpaHelpertest_1.formatLiveFailure)(saleResponse, "Debit Sale"));
+            }
+            const response = await (0, UpaHelpertest_1.reverseLiveSaleWithRetry)(device, saleResponse.terminalRefNumber);
+            if ((0, UpaHelpertest_1.isKnownLiveBusyBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "Debit Reversal"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["Reversal", "SendCommand"]);
+            (0, UpaHelpertest_1.expectLiveReverseResponseFields)(response);
+            if (response.transactionType) {
+                expect(response.transactionType.toUpperCase()).toContain("DEBIT");
+            }
+        }
+        catch (error) {
+            if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                console.warn("Reverse debit transaction timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    test("[LiveNegative] reverse() with invalid target device returns failure", async () => {
+        const unavailableDevice = DeviceService_1.DeviceService.create((0, UpaHelpertest_1.buildConfig)());
+        unavailableDevice.ecrId = "99999999";
+        await (0, UpaHelpertest_1.expectLiveReverseFailure)(() => unavailableDevice
+            .reverse()
+            .withEcrId(99999999)
+            .withTerminalRefNumber("0001")
+            .execute(), "Reversal invalid target device");
+    });
+});
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – deletePreAuth()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaCreditTests] deletePreAuth() with transactionId and amount returns Success", async () => {
+        let response;
+        if (UpaHelpertest_1.useLiveMic) {
+            try {
+                const preAuthResponse = await (0, UpaHelpertest_1.createLivePreAuth)(device);
+                response = await (0, UpaHelpertest_1.deletePreAuthWithRetry)(device, preAuthResponse.transactionId, 1.0);
+            }
+            catch (error) {
+                if ((0, UpaHelpertest_1.isKnownLiveTransportTimeout)(error)) {
+                    console.warn("DeletePreAuth live MIC prerequisite timed out while waiting on the device or gateway.");
+                    return;
+                }
+                throw error;
+            }
+        }
+        else {
+            response = await device
+                .deletePreAuth()
+                .withEcrId(13)
+                .withTransactionId("200071138640")
+                .withAmount(1.0)
+                .execute();
+        }
+        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, "DeletePreAuth"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, ["DeletePreAuth", "SendCommand"]);
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseText).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[LiveNegative] deletePreAuth() with unknown reference number returns failure", async () => {
+        await (0, UpaHelpertest_1.expectLiveDeletePreAuthFailure)(() => device
+            .deletePreAuth()
+            .withEcrId(13)
+            .withTransactionId("999999999999")
+            .withAmount(1.0)
+            .execute(), "DeletePreAuth unknown reference number");
+    });
+    test("[LiveNegative] deletePreAuth() without reference number returns failure", async () => {
+        await (0, UpaHelpertest_1.expectLiveDeletePreAuthFailure)(() => device.deletePreAuth().withEcrId(13).withAmount(1.0).execute(), "DeletePreAuth missing mandatory reference number");
+    });
+    test("[LiveNegative] deletePreAuth() with invalid target device surfaces device error", async () => {
+        const unavailableDevice = DeviceService_1.DeviceService.create((0, UpaHelpertest_1.buildConfig)());
+        unavailableDevice.ecrId = "99999999";
+        await (0, UpaHelpertest_1.expectLiveDeletePreAuthFailure)(() => unavailableDevice
+            .deletePreAuth()
+            .withEcrId(99999999)
+            .withTransactionId("200015214831")
+            .withAmount(1.0)
+            .execute(), "DeletePreAuth device error");
+    });
+});
+(0, UpaHelpertest_1.describeUpaLive)("UPA Admin – startCardTransaction()", () => {
+    let device;
+    beforeEach(() => {
+        device = (0, UpaHelpertest_1.createTestDevice)();
+    });
+    test("[UpaAdminTests] startCardTransaction() all acquisition types 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.header = "Sale Transaction";
+        param.displayTotalAmount = "Yes";
+        param.promptForManual = false;
+        param.brandIcon1 = 1;
+        param.brandIcon2 = 1;
+        param.timeout = 100;
+        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 = 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 all acquisition types timed out while waiting on the device or gateway.");
+                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 all acquisition types"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            (0, UpaHelpertest_1.expectParsedStartCardTransactionResponse)(response);
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    test("[UpaAdminTests] startCardTransaction() swipe with GIFT filter returns Success", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 60;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Swipe];
+        param.header = "Header";
+        param.displayTotalAmount = "Y";
+        param.promptForManual = true;
+        param.brandIcon1 = 4;
+        param.brandIcon2 = 3;
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CheckLuhn = "Y";
+        indicator.SecurityCode = "Y";
+        indicator.CardTypeFilter = [CardTypeFilter_1.CardTypeFilter.GIFT];
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = 11.2;
+        transData.cashBackAmount = 2.5;
+        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 swipe with GIFT filter timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+        expect(response).not.toBeNull();
+        if (UpaHelpertest_1.useLiveMic) {
+            if ((0, UpaHelpertest_1.isKnownLiveGiftCardBlocker)(response) ||
+                (0, UpaHelpertest_1.isKnownLiveStartCardTransactionBlocker)(response)) {
+                console.warn((0, UpaHelpertest_1.formatLiveFailure)(response, "StartCardTransaction swipe with GIFT filter"));
+                return;
+            }
+            (0, UpaHelpertest_1.expectLiveSuccess)(response, "StartCardTransaction");
+            (0, UpaHelpertest_1.expectParsedStartCardTransactionResponse)(response);
+            return;
+        }
+        expect(response.status).toBe("Success");
+    });
+    test("[SdkValidation] startCardTransaction() without acquisitionTypes throws ArgumentError", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 90;
+        param.header = "Missing acquisition types";
+        param.displayTotalAmount = "Yes";
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "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;
+        await expect(device.startCardTransaction(param, indicator, transData)).rejects.toMatchObject({
+            name: src_1.ArgumentError.name,
+            message: "acquisitionTypes is required for startCardTransaction",
+        });
+    });
+    test.each([[-1], [Number.NaN], ["invalid"]])("[SdkValidation] startCardTransaction() with invalid totalAmount %p throws ArgumentError", async (invalidTotalAmount) => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 90;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Invalid amount";
+        param.displayTotalAmount = "Yes";
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        const transData = new UpaTransactionData_1.UpaTransactionData();
+        transData.totalAmount = invalidTotalAmount;
+        transData.cashBackAmount = 0.0;
+        transData.tranDate = new Date();
+        transData.tranTime = new Date();
+        transData.transType = src_1.TransactionType.Sale;
+        await expect(device.startCardTransaction(param, indicator, transData)).rejects.toMatchObject({
+            name: src_1.ArgumentError.name,
+            message: "totalAmount must be a non-negative number for startCardTransaction",
+        });
+    });
+    test("[SdkValidation] startCardTransaction() with invalid cardTypeFilter throws ArgumentError", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 90;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Manual];
+        param.header = "Invalid card type filter";
+        param.displayTotalAmount = "Yes";
+        const indicator = new ProcessIndicator_1.ProcessingIndicator();
+        indicator.QuickChip = "Y";
+        indicator.CardTypeFilter = ["XYZ"];
+        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;
+        await expect(device.startCardTransaction(param, indicator, transData)).rejects.toMatchObject({
+            name: src_1.ArgumentError.name,
+            message: "cardTypeFilter must contain only supported card types for startCardTransaction",
+        });
+    });
+    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.");
+        }
+        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;
+        }
+    });
+});
+//# sourceMappingURL=UpaAdmin.test.js.map