globalpayments-api 3.10.13 → 3.10.15

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

@@ -0,0 +1,1277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for UPA Story 2 methods:
+ *   balance(), reverse(), deletePreAuth(), startCardTransaction(), reboot()
+ *
+ *   Balance         – UpaEbtTests.cs:EbtFoodstampBalanceInquiry, EbtCashBenefitsBalanceInquiry, EbtBalance
+ *   Reverse         – UpaCreditTests.cs:CreditSale_WhenReversedByTerminalRefNumber_ShouldReturnSuccess
+ *   DeletePreAuth   – UpaCreditTests.cs:DeletePreAuth / UpaMicTests.cs:CreditDeletePreAuth
+ *   StartCardTransaction – UpaAdminTests.cs (4 test cases)
+ *   Reboot          – UpaAdminTests.cs:Reboot / UpaMicTests.cs:Reboot
+ */
+const src_1 = require("../../../../src");
+const Logging_1 = require("../../../../src/Utils/Logging");
+const DeviceService_1 = require("../../../../src/Services/DeviceService");
+const Enums_1 = require("../../../../src/Terminals/Enums");
+const TransactionResponse_1 = require("../../../../src/Terminals/UPA/Reponses/TransactionResponse");
+const UpaGiftCardResponse_1 = require("../../../../src/Terminals/UPA/Reponses/UpaGiftCardResponse");
+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 Enums_2 = require("../../../../src/Entities/Enums");
+const useLiveMic = process.env.UPA_LIVE === "true";
+const gpApiAppId = process.env.GP_API_APP_ID;
+const gpApiAppKey = process.env.GP_API_APP_KEY;
+const hasLiveGpApiCredentials = !!gpApiAppId && !!gpApiAppKey;
+const describeUpaStory2 = useLiveMic && !hasLiveGpApiCredentials ? describe.skip : describe;
+const liveOnlyStory2 = useLiveMic ? test : test.skip;
+jest.setTimeout(240000);
+/* eslint-disable indent */
+function expectLiveSuccess(response, expectedCommand) {
+    const expectedCommands = Array.isArray(expectedCommand)
+        ? expectedCommand
+        : [expectedCommand];
+    expect(expectedCommands).toContain(response.command);
+    expect(response.status).toBe("Success");
+    expect(response.deviceResponseCode).toBe("00");
+}
+function formatLiveFailure(response, operation) {
+    const deviceCode = response.deviceResponseCode ?? "";
+    const hostCode = response.responseCode ?? "";
+    return `${operation} prerequisite failed in live MIC: device ${deviceCode} ${response.deviceResponseMessage ?? ""}; host ${hostCode} ${response.responseText ?? ""}`.trim();
+}
+function isKnownLiveSaleBlocker(response) {
+    const pinVerificationError = response.deviceResponseCode === "HOST001" &&
+        response.responseCode === "86" &&
+        response.responseText === "CANT VERIFY PIN";
+    const timeoutError = response.deviceResponseCode === "APP002" &&
+        response.deviceResponseMessage === "TIMEOUT";
+    return pinVerificationError || timeoutError;
+}
+function isKnownLiveBalanceBlocker(response) {
+    const pinVerificationError = response.deviceResponseCode === "HOST001" &&
+        response.responseCode === "86" &&
+        response.responseText === "CANT VERIFY PIN";
+    const hostCommunicationError = response.deviceResponseCode === "HOST002" &&
+        response.deviceResponseMessage === "HOST COMMUNICATIONS ERROR";
+    const userCancelledError = response.deviceResponseCode === "APP001" &&
+        response.deviceResponseMessage === "TRANSACTION CANCELLED BY USER";
+    const timeoutError = response.deviceResponseCode === "APP002" &&
+        response.deviceResponseMessage === "TIMEOUT";
+    return (pinVerificationError ||
+        hostCommunicationError ||
+        userCancelledError ||
+        timeoutError);
+}
+function isKnownLiveBusyBlocker(response) {
+    return (response.command === "SendCommand" &&
+        response.deviceResponseCode === "32" &&
+        response.deviceResponseMessage === "BUSY");
+}
+function isKnownLiveStartCardTransactionBlocker(response) {
+    const documentedErrorCodes = [
+        "CARD002",
+        "CARD003",
+        "CARD004",
+        "CARD006",
+        "CARD007",
+        "CARD009",
+        "CARD011",
+        "CARD018",
+        "APP001",
+        "APP002",
+        "APP013",
+        "ERR013",
+    ];
+    return (!!response.deviceResponseCode &&
+        documentedErrorCodes.includes(response.deviceResponseCode));
+}
+function isKnownLiveGiftCardBlocker(response) {
+    return (response.deviceResponseCode === "GIFT001" &&
+        response.deviceResponseMessage === "NOT A VALID GIFT CARD");
+}
+function isKnownLiveReverseAutoFallbackBlocker(response) {
+    return (response.command === "Reversal" &&
+        response.deviceResponseCode === "ERR013" &&
+        response.deviceResponseMessage === "[tranNo]-MISSING MANDATORY FIELD");
+}
+function isKnownLiveTransportTimeout(error) {
+    return (error instanceof Error &&
+        (error.message === "Socket timeout occurred." ||
+            error.message.includes("ECONNRESET") ||
+            error.message.includes("socket hang up")));
+}
+function expectParsedStartCardTransactionResponse(response) {
+    expect(response.command).toBe("StartCardTransaction");
+    expect(response.status).toBe("Success");
+    expect(response.deviceResponseCode).toBe("00");
+    if (response.acquisitionType) {
+        expect(response.acquisitionType).toMatch(/^(INSERT|CONTACT|CONTACTLESS|SWIPE|MANUAL|SCAN|TAP)$/);
+    }
+    if (response.luhnCheckPassed) {
+        expect(response.luhnCheckPassed).toMatch(/^[YN]$/);
+    }
+    if (response.fallback) {
+        expect(response.fallback).toMatch(/^[01]$/);
+    }
+    if (response.avsFlag) {
+        expect(response.avsFlag).toMatch(/^[01]$/);
+    }
+    if (response.cardSecurityPromptFlag) {
+        expect(response.cardSecurityPromptFlag).toMatch(/^[01]$/);
+    }
+    if (response.cashBackFlag) {
+        expect(response.cashBackFlag).toMatch(/^[01]$/);
+    }
+    if (response.surchargeFlag) {
+        expect(response.surchargeFlag).toMatch(/^[01]$/);
+    }
+    if (response.dccEligible) {
+        expect(response.dccEligible).toMatch(/^[01]$/);
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function expectLiveDeletePreAuthFailure(action, operation) {
+    try {
+        const response = await action();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (isKnownLiveBusyBlocker(response)) {
+            console.warn(formatLiveFailure(response, operation));
+            return;
+        }
+        expect(response.status !== "Success" ||
+            response.deviceResponseCode !== "00" ||
+            (!!response.responseCode && response.responseCode !== "00")).toBe(true);
+    }
+    catch (error) {
+        if (isKnownLiveTransportTimeout(error)) {
+            console.warn(`${operation} timed out while waiting on the device or gateway.`);
+            return;
+        }
+        expect(error).toBeInstanceOf(Error);
+        expect(error.message).toBeTruthy();
+    }
+}
+function expectLiveBalanceResponseFields(response) {
+    expect(["BalanceInquiry", "SendCommand"]).toContain(response.command);
+    expect(response.status).toBe("Success");
+    expect(response.deviceResponseCode).toBe("00");
+    expect(response.responseCode).toBe("00");
+    expect(response.responseText).toBeTruthy();
+    if (response.referenceNumber) {
+        expect(response.referenceNumber).toMatch(/^[A-Z0-9]+$/i);
+    }
+    expect(response.availableBalance).not.toBeUndefined();
+    if (response.transactionType) {
+        expect(response.transactionType).toContain("BALANCE");
+    }
+    if (response.maskedCardNumber) {
+        expect(response.maskedCardNumber).toMatch(/\*{2,}|X{2,}/);
+    }
+    if (response.entryMethod) {
+        expect(response.entryMethod).toMatch(/^(MANUAL|SWIPE|INSERT|TAP|SCAN|NONE)$/);
+    }
+    if (response.expirationDate) {
+        expect(response.expirationDate).toMatch(/^\d{2}\/\d{2}$/);
+    }
+    if (response.pinVerified) {
+        expect(response.pinVerified).toMatch(/^[01]$/);
+    }
+    if (response.fallback) {
+        expect(response.fallback).toMatch(/^[01]$/);
+    }
+}
+async function expectLiveBalanceFailure(action, operation) {
+    try {
+        const response = await action();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (isKnownLiveBusyBlocker(response)) {
+            console.warn(formatLiveFailure(response, operation));
+            return;
+        }
+        expect(response.status !== "Success" ||
+            response.deviceResponseCode !== "00" ||
+            (!!response.responseCode && response.responseCode !== "00")).toBe(true);
+    }
+    catch (error) {
+        if (isKnownLiveTransportTimeout(error)) {
+            console.warn(`${operation} timed out while waiting on the device or gateway.`);
+            return;
+        }
+        expect(error).toBeInstanceOf(Error);
+        expect(error.message).toBeTruthy();
+    }
+}
+async function reverseLiveSaleWithRetry(device, terminalRefNumber, amount, maxAttempts = 3) {
+    let response;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const builder = device.reverse().withEcrId(12);
+        if (terminalRefNumber) {
+            builder.withTerminalRefNumber(terminalRefNumber);
+        }
+        if (amount !== undefined) {
+            builder.withAmount(amount);
+        }
+        response = await builder.execute();
+        if (!isKnownLiveBusyBlocker(response) || attempt === maxAttempts) {
+            return response;
+        }
+        await delay(10000);
+    }
+    return response;
+}
+function expectLiveReverseResponseFields(response) {
+    expect(response.command).toBe("Reversal");
+    expect(response.status).toBe("Success");
+    expect(response.deviceResponseCode).toBe("00");
+    expect(response.responseCode).toBe("00");
+    expect(response.responseText).toBeTruthy();
+    expect(response.terminalRefNumber).toBeTruthy();
+    if (response.referenceNumber) {
+        expect(response.referenceNumber).toMatch(/^[A-Z0-9]+$/i);
+    }
+    if (response.transactionType) {
+        expect(response.transactionType).toContain("REVERSAL");
+    }
+    if (response.maskedCardNumber) {
+        expect(response.maskedCardNumber).toMatch(/\*{2,}|X{2,}/);
+    }
+    if (response.entryMethod) {
+        expect(response.entryMethod).toMatch(/^(MANUAL|SWIPE|INSERT|TAP|SCAN|NONE)$/);
+    }
+    if (response.expirationDate) {
+        expect(response.expirationDate).toMatch(/^\d{2}\/\d{2}$/);
+    }
+}
+async function expectLiveReverseFailure(action, operation) {
+    try {
+        const response = await action();
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (isKnownLiveBusyBlocker(response)) {
+            console.warn(formatLiveFailure(response, operation));
+            return;
+        }
+        expect(response.status !== "Success" ||
+            response.deviceResponseCode !== "00" ||
+            (!!response.responseCode && response.responseCode !== "00")).toBe(true);
+    }
+    catch (error) {
+        if (isKnownLiveTransportTimeout(error)) {
+            console.warn(`${operation} timed out while waiting on the device or gateway.`);
+            return;
+        }
+        expect(error).toBeInstanceOf(Error);
+        expect(error.message).toBeTruthy();
+    }
+}
+async function deletePreAuthWithRetry(device, transactionId, amount, maxAttempts = 3) {
+    let response;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        response = await device
+            .deletePreAuth()
+            .withEcrId(13)
+            .withTransactionId(transactionId)
+            .withAmount(amount)
+            .execute();
+        if (!isKnownLiveBusyBlocker(response) || attempt === maxAttempts) {
+            return response;
+        }
+        await delay(10000);
+    }
+    return response;
+}
+async function createLiveSale(device) {
+    const response = await device
+        .sale(1.0)
+        .withGratuity(0)
+        .withEcrId(13)
+        .withClerkId(123)
+        .execute();
+    expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+    if (response.deviceResponseCode === "00") {
+        expect(["COMPLETE", "INITIATED"]).toContain(response.deviceResponseText);
+        expect(response.terminalRefNumber).toBeTruthy();
+    }
+    return response;
+}
+async function createLiveDebitSale(device) {
+    const response = await device
+        .sale(1.0)
+        .withPaymentMethodType(src_1.PaymentMethodType.Debit)
+        .withCashBack(0)
+        .withEcrId(13)
+        .withClerkId(123)
+        .execute();
+    expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+    if (response.deviceResponseCode === "00") {
+        expect(["COMPLETE", "INITIATED"]).toContain(response.deviceResponseText);
+        expect(response.terminalRefNumber).toBeTruthy();
+    }
+    return response;
+}
+async function createLivePreAuth(device) {
+    const response = await device
+        .authorize(1.0)
+        .withEcrId(13)
+        .withClerkId(123)
+        .execute();
+    expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+    if (response.deviceResponseCode !== "00") {
+        throw new Error(formatLiveFailure(response, "PreAuth"));
+    }
+    expect(["COMPLETE", "INITIATED"]).toContain(response.deviceResponseText);
+    expect(response.transactionId).toBeTruthy();
+    return response;
+}
+async function executeLiveStartCardTransaction(device, param, indicator, transData, operation) {
+    let response;
+    try {
+        response = await device.startCardTransaction(param, indicator, transData);
+    }
+    catch (error) {
+        if (isKnownLiveTransportTimeout(error)) {
+            console.warn(`${operation} timed out while waiting on the device or gateway.`);
+            return undefined;
+        }
+        throw error;
+    }
+    expect(response).not.toBeNull();
+    expect(response).toBeInstanceOf(UpaGiftCardResponse_1.UpaGiftCardResponse);
+    if (isKnownLiveGiftCardBlocker(response) ||
+        isKnownLiveStartCardTransactionBlocker(response)) {
+        console.warn(formatLiveFailure(response, operation));
+        return undefined;
+    }
+    expectLiveSuccess(response, "StartCardTransaction");
+    expectParsedStartCardTransactionResponse(response);
+    return response;
+}
+/* eslint-enable indent */
+// ===========================================================================
+// Test infrastructure helpers
+// ===========================================================================
+function buildConfig(gpApiOverrides = {}) {
+    const config = new src_1.ConnectionConfig();
+    config.deviceType = src_1.DeviceType.UPA_DEVICE;
+    config.connectionMode = Enums_1.ConnectionModes.MEET_IN_THE_CLOUD;
+    config.requestIdProvider = { getRequestId: () => 9999 };
+    const logger = new Logging_1.SampleRequestLogger(new Logging_1.Logger("logs"));
+    config.requestLogger = logger;
+    if (useLiveMic && !hasLiveGpApiCredentials) {
+        throw new Error("Set GP_API_APP_ID and GP_API_APP_KEY to run live UPA Story 2 tests.");
+    }
+    const gpApiConfig = new src_1.GpApiConfig();
+    gpApiConfig.appId = gpApiAppId ?? "UNIT_TEST_APP_ID";
+    gpApiConfig.appKey = gpApiAppKey ?? "UNIT_TEST_APP_KEY";
+    gpApiConfig.environment = src_1.Environment.Test;
+    gpApiConfig.channel = src_1.Channel.CardPresent;
+    gpApiConfig.country = "US";
+    gpApiConfig.deviceCurrency = "USD";
+    gpApiConfig.requestLogger = logger;
+    if (useLiveMic) {
+        gpApiConfig.accessTokenInfo = new src_1.AccessTokenInfo();
+    }
+    else {
+        gpApiConfig.accessTokenInfo = {
+            transactionProcessingAccountName: "test",
+            accessToken: "UNIT_TEST_FAKE_TOKEN",
+        };
+    }
+    Object.assign(gpApiConfig, gpApiOverrides);
+    config.gatewayConfig = gpApiConfig;
+    return config;
+}
+// ===========================================================================
+// balance()
+// References:
+//   UpaEbtTests.cs – EbtFoodstampBalanceInquiry, EbtCashBenefitsBalanceInquiry, EbtBalance
+//     Assert.AreEqual("00", response.ResponseCode / DeviceResponseCode)
+//     Assert.AreEqual("Success", response.DeviceResponseText)
+// ===========================================================================
+describeUpaStory2("UPA Story 2 – balance()", () => {
+    let device;
+    beforeEach(() => {
+        device = DeviceService_1.DeviceService.create(buildConfig());
+        device.ecrId = "13";
+    });
+    /**
+     * Mirrors UpaEbtTests.cs – EbtFoodstampBalanceInquiry
+     *   var response = _device.Balance().WithEcrId(13)
+     *       .WithPaymentMethodType(PaymentMethodType.EBT)
+     *       .WithCurrency(CurrencyType.FOODSTAMPS).Execute();
+     *   Assert.AreEqual("00", response.ResponseCode);
+     */
+    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 (useLiveMic) {
+            if (isKnownLiveBalanceBlocker(response)) {
+                console.warn(formatLiveFailure(response, "BalanceInquiry Foodstamp"));
+                return;
+            }
+            if (isKnownLiveBusyBlocker(response)) {
+                console.warn(formatLiveFailure(response, "BalanceInquiry Foodstamp"));
+                return;
+            }
+            expectLiveSuccess(response, ["BalanceInquiry", "SendCommand"]);
+            return;
+        }
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    /**
+     * Mirrors UpaEbtTests.cs – EbtBalance
+     *   Assert.AreEqual("Success", response.DeviceResponseText);
+     *   Assert.AreEqual("00", response.DeviceResponseCode);
+     */
+    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();
+        if (useLiveMic) {
+            if (isKnownLiveBalanceBlocker(response)) {
+                console.warn(formatLiveFailure(response, "BalanceInquiry EBT"));
+                return;
+            }
+            if (isKnownLiveBusyBlocker(response)) {
+                console.warn(formatLiveFailure(response, "BalanceInquiry EBT"));
+                return;
+            }
+            expectLiveSuccess(response, ["BalanceInquiry", "SendCommand"]);
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseText).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    liveOnlyStory2("[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);
+        if (isKnownLiveBalanceBlocker(response)) {
+            console.warn(formatLiveFailure(response, "BalanceInquiry Mastercard"));
+            return;
+        }
+        if (isKnownLiveBusyBlocker(response)) {
+            console.warn(formatLiveFailure(response, "BalanceInquiry Mastercard"));
+            return;
+        }
+        expectLiveSuccess(response, ["BalanceInquiry", "SendCommand"]);
+        expectLiveBalanceResponseFields(response);
+        expect(response.cardGroup).toBe("CREDIT");
+        expect(response.cardType).toMatch(/^(MASTERCARD|MasterCard|MC)$/i);
+    });
+    liveOnlyStory2("[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);
+        if (isKnownLiveBalanceBlocker(response)) {
+            console.warn(formatLiveFailure(response, "BalanceInquiry response fields"));
+            return;
+        }
+        if (isKnownLiveBusyBlocker(response)) {
+            console.warn(formatLiveFailure(response, "BalanceInquiry response fields"));
+            return;
+        }
+        expectLiveSuccess(response, ["BalanceInquiry", "SendCommand"]);
+        expectLiveBalanceResponseFields(response);
+        expect(response.cardType).toBeTruthy();
+        expect(response.cardGroup).toBeTruthy();
+        expect(response.cardHolderName).toBeTruthy();
+    });
+    liveOnlyStory2("[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 (isKnownLiveBusyBlocker(response)) {
+            console.warn(formatLiveFailure(response, "BalanceInquiry EBT field validation"));
+            return;
+        }
+        if (isKnownLiveBalanceBlocker(response)) {
+            expect(response.cardGroup).toBeTruthy();
+            expect(response.ebtType).toBeTruthy();
+            expect(response.cardType).toBeTruthy();
+            return;
+        }
+        expectLiveSuccess(response, ["BalanceInquiry", "SendCommand"]);
+        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();
+    });
+    liveOnlyStory2("[LiveNegative] balance() with invalid target device surfaces device error", async () => {
+        const unavailableDevice = DeviceService_1.DeviceService.create(buildConfig());
+        unavailableDevice.ecrId = "99999999";
+        await expectLiveBalanceFailure(() => unavailableDevice
+            .balance()
+            .withEcrId(99999999)
+            .withPaymentMethodType(src_1.PaymentMethodType.Credit)
+            .execute(), "BalanceInquiry invalid target device");
+    });
+    liveOnlyStory2("[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 (isKnownLiveBusyBlocker(response)) {
+            console.warn(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.");
+    });
+    liveOnlyStory2("[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 (isKnownLiveBusyBlocker(response)) {
+            console.warn(formatLiveFailure(response, "BalanceInquiry host error"));
+            return;
+        }
+        if (response.deviceResponseCode === "HOST001") {
+            expect(response.availableBalance).toBeUndefined();
+            return;
+        }
+        if (response.deviceResponseCode === "APP002") {
+            console.warn(formatLiveFailure(response, "BalanceInquiry host error"));
+            return;
+        }
+        console.warn("BalanceInquiry host error scenario was not reproduced in the current live run.");
+    });
+    test.skip("[EnvDependent] balance() forced transaction timeout requires controlled network or device conditions", () => { });
+    test.skip("[CardDependent] balance() EBT not supported for presented card requires a deterministic non-EBT card routing scenario", () => { });
+    test.skip("[PhysicalDevice] balance() with low battery requires a device-level APP013 precondition", () => { });
+});
+// ===========================================================================
+// reverse()
+// References:
+//   UpaCreditTests.cs – CreditSale_WhenReversedByTerminalRefNumber_ShouldReturnSuccess
+//     Assert.AreEqual("00", reverseResponse.DeviceResponseCode);
+// ===========================================================================
+describeUpaStory2("UPA Story 2 – reverse()", () => {
+    let device;
+    beforeEach(() => {
+        device = DeviceService_1.DeviceService.create(buildConfig());
+        device.ecrId = "13";
+    });
+    /**
+     * Mirrors UpaCreditTests.cs – CreditSale_WhenReversedByTerminalRefNumber_ShouldReturnSuccess
+     *   Assert.IsNotNull(reverseResponse);
+     *   Assert.AreEqual("00", reverseResponse.DeviceResponseCode);
+     */
+    test("[.] reverse() with TerminalRefNumber returns deviceResponseCode == '00'", async () => {
+        let response;
+        if (useLiveMic) {
+            try {
+                const saleResponse = await createLiveSale(device);
+                if (saleResponse.deviceResponseCode !== "00") {
+                    if (isKnownLiveSaleBlocker(saleResponse)) {
+                        console.warn(formatLiveFailure(saleResponse, "Sale"));
+                        return;
+                    }
+                    throw new Error(formatLiveFailure(saleResponse, "Sale"));
+                }
+                response = await reverseLiveSaleWithRetry(device, saleResponse.terminalRefNumber);
+            }
+            catch (error) {
+                if (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("0001234567890123")
+                .withEcrId(12)
+                .execute();
+        }
+        expect(response).not.toBeNull();
+        expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+        if (useLiveMic) {
+            if (isKnownLiveBusyBlocker(response)) {
+                console.warn(formatLiveFailure(response, "Reversal"));
+                return;
+            }
+            expectLiveSuccess(response, ["Reversal", "SendCommand"]);
+            return;
+        }
+        expect(response.deviceResponseCode).toBe("00");
+        expect(response.status).toBe("Success");
+    });
+    // The documented no-tranNo auto-reversal behavior is SI-only. In the current
+    // MITC setup this test records the live terminal limitation instead of claiming
+    // full spec compliance for the SI fallback path.
+    liveOnlyStory2("[LiveSetup] reverse() without tranNo documents current MITC behavior", async () => {
+        try {
+            const saleResponse = await createLiveSale(device);
+            if (saleResponse.deviceResponseCode !== "00") {
+                if (isKnownLiveSaleBlocker(saleResponse)) {
+                    console.warn(formatLiveFailure(saleResponse, "Sale"));
+                    return;
+                }
+                throw new Error(formatLiveFailure(saleResponse, "Sale"));
+            }
+            const response = await reverseLiveSaleWithRetry(device);
+            if (isKnownLiveBusyBlocker(response)) {
+                console.warn(formatLiveFailure(response, "Reversal auto previous financial transaction"));
+                return;
+            }
+            if (isKnownLiveReverseAutoFallbackBlocker(response)) {
+                console.warn("Reverse auto previous financial transaction is not supported in the current MITC configuration; the terminal requires tranNo.");
+                return;
+            }
+            expectLiveSuccess(response, ["Reversal", "SendCommand"]);
+        }
+        catch (error) {
+            if (isKnownLiveTransportTimeout(error)) {
+                console.warn("Reverse auto previous financial transaction timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    liveOnlyStory2("[LivePositive] reverse() returns documented response fields on success", async () => {
+        try {
+            const saleResponse = await createLiveSale(device);
+            if (saleResponse.deviceResponseCode !== "00") {
+                if (isKnownLiveSaleBlocker(saleResponse)) {
+                    console.warn(formatLiveFailure(saleResponse, "Sale"));
+                    return;
+                }
+                throw new Error(formatLiveFailure(saleResponse, "Sale"));
+            }
+            const response = await reverseLiveSaleWithRetry(device, saleResponse.terminalRefNumber);
+            if (isKnownLiveBusyBlocker(response)) {
+                console.warn(formatLiveFailure(response, "Reversal response field verification"));
+                return;
+            }
+            expectLiveSuccess(response, ["Reversal", "SendCommand"]);
+            expectLiveReverseResponseFields(response);
+        }
+        catch (error) {
+            if (isKnownLiveTransportTimeout(error)) {
+                console.warn("Reverse response field verification timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    liveOnlyStory2("[LiveNegative] reverse() already reversed transaction returns failure", async () => {
+        try {
+            const saleResponse = await createLiveSale(device);
+            if (saleResponse.deviceResponseCode !== "00") {
+                if (isKnownLiveSaleBlocker(saleResponse)) {
+                    console.warn(formatLiveFailure(saleResponse, "Sale"));
+                    return;
+                }
+                throw new Error(formatLiveFailure(saleResponse, "Sale"));
+            }
+            const firstReverseResponse = await reverseLiveSaleWithRetry(device, saleResponse.terminalRefNumber);
+            if (isKnownLiveBusyBlocker(firstReverseResponse)) {
+                console.warn(formatLiveFailure(firstReverseResponse, "Initial reversal"));
+                return;
+            }
+            expectLiveSuccess(firstReverseResponse, ["Reversal", "SendCommand"]);
+            await expectLiveReverseFailure(() => reverseLiveSaleWithRetry(device, saleResponse.terminalRefNumber, undefined, 1), "Reversal already reversed transaction");
+        }
+        catch (error) {
+            if (isKnownLiveTransportTimeout(error)) {
+                console.warn("Reverse already reversed transaction timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    liveOnlyStory2("[LiveNegative] reverse() with invalid authorizedAmount returns failure", async () => {
+        try {
+            const saleResponse = await createLiveSale(device);
+            if (saleResponse.deviceResponseCode !== "00") {
+                if (isKnownLiveSaleBlocker(saleResponse)) {
+                    console.warn(formatLiveFailure(saleResponse, "Sale"));
+                    return;
+                }
+                throw new Error(formatLiveFailure(saleResponse, "Sale"));
+            }
+            await expectLiveReverseFailure(() => reverseLiveSaleWithRetry(device, saleResponse.terminalRefNumber, 99.99, 1), "Reversal invalid authorizedAmount");
+        }
+        catch (error) {
+            if (isKnownLiveTransportTimeout(error)) {
+                console.warn("Reverse invalid authorizedAmount timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    liveOnlyStory2("[LivePositive] reverse() debit transaction returns success", async () => {
+        try {
+            const saleResponse = await createLiveDebitSale(device);
+            if (saleResponse.deviceResponseCode !== "00") {
+                if (isKnownLiveSaleBlocker(saleResponse)) {
+                    console.warn(formatLiveFailure(saleResponse, "Debit Sale"));
+                    return;
+                }
+                throw new Error(formatLiveFailure(saleResponse, "Debit Sale"));
+            }
+            const response = await reverseLiveSaleWithRetry(device, saleResponse.terminalRefNumber);
+            if (isKnownLiveBusyBlocker(response)) {
+                console.warn(formatLiveFailure(response, "Debit Reversal"));
+                return;
+            }
+            expectLiveSuccess(response, ["Reversal", "SendCommand"]);
+            expectLiveReverseResponseFields(response);
+            if (response.transactionType) {
+                expect(response.transactionType.toUpperCase()).toContain("DEBIT");
+            }
+        }
+        catch (error) {
+            if (isKnownLiveTransportTimeout(error)) {
+                console.warn("Reverse debit transaction timed out while waiting on the device or gateway.");
+                return;
+            }
+            throw error;
+        }
+    });
+    liveOnlyStory2("[LiveNegative] reverse() with invalid target device returns failure", async () => {
+        const unavailableDevice = DeviceService_1.DeviceService.create(buildConfig());
+        unavailableDevice.ecrId = "99999999";
+        await expectLiveReverseFailure(() => unavailableDevice
+            .reverse()
+            .withEcrId(99999999)
+            .withTerminalRefNumber("0001")
+            .execute(), "Reversal invalid target device");
+    });
+    // The following cases are intentionally left as skipped placeholders because
+    // they require SI-only reversal fallback behavior or physical device states
+    // that are not reproducible from the current MITC automation setup.
+    test.skip("[SIOnly] reverse() after non-financial transaction with no previous financial transaction returns TRAN001", () => { });
+    test.skip("[SIOnly] reverse() without tranNo on an already voided transaction returns VOID002", () => { });
+    test.skip("[MITCLimit] reverse() not accepted in current state returns a deterministic device error", () => { });
+    test.skip("[EnvDependent] reverse() forced timeout scenario requires controlled network or device conditions", () => { });
+    test.skip("[PhysicalDevice] reverse() on a not-activated device requires a separately provisioned terminal state", () => { });
+    test.skip("[PhysicalDevice] reverse() with low battery requires a device-level battery precondition", () => { });
+});
+// ===========================================================================
+// deletePreAuth()
+// References:
+//   UpaCreditTests.cs – DeletePreAuth (TCP)
+//     Assert.AreEqual("Success", response.DeviceResponseText);
+//     Assert.AreEqual("00", response.DeviceResponseCode);
+//   UpaMicTests.cs – CreditDeletePreAuth (MIC — Declined on real device)
+// ===========================================================================
+describeUpaStory2("UPA Story 2 – deletePreAuth()", () => {
+    let device;
+    beforeEach(() => {
+        device = DeviceService_1.DeviceService.create(buildConfig());
+        device.ecrId = "13";
+    });
+    /**
+     * Mirrors UpaCreditTests.cs – DeletePreAuth
+     *   Assert.IsNotNull(response);
+     *   Assert.AreEqual("Success", response.DeviceResponseText);
+     *   Assert.AreEqual("00", response.DeviceResponseCode);
+     */
+    test("[UpaCreditTests] deletePreAuth() with transactionId and amount returns Success", async () => {
+        let response;
+        if (useLiveMic) {
+            try {
+                const preAuthResponse = await createLivePreAuth(device);
+                response = await deletePreAuthWithRetry(device, preAuthResponse.transactionId, 1.0);
+            }
+            catch (error) {
+                if (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 (useLiveMic) {
+            if (isKnownLiveBusyBlocker(response)) {
+                console.warn(formatLiveFailure(response, "DeletePreAuth"));
+                return;
+            }
+            expectLiveSuccess(response, ["DeletePreAuth", "SendCommand"]);
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseText).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    liveOnlyStory2("[LiveNegative] deletePreAuth() with unknown reference number returns failure", async () => {
+        await expectLiveDeletePreAuthFailure(() => device
+            .deletePreAuth()
+            .withEcrId(13)
+            .withTransactionId("999999999999")
+            .withAmount(1.0)
+            .execute(), "DeletePreAuth unknown reference number");
+    });
+    liveOnlyStory2("[LiveNegative] deletePreAuth() without reference number returns failure", async () => {
+        await expectLiveDeletePreAuthFailure(() => device
+            .deletePreAuth()
+            .withEcrId(13)
+            .withAmount(1.0)
+            .execute(), "DeletePreAuth missing mandatory reference number");
+    });
+    liveOnlyStory2("[LiveNegative] deletePreAuth() with invalid target device surfaces device error", async () => {
+        const unavailableDevice = DeviceService_1.DeviceService.create(buildConfig());
+        unavailableDevice.ecrId = "99999999";
+        await expectLiveDeletePreAuthFailure(() => unavailableDevice
+            .deletePreAuth()
+            .withEcrId(99999999)
+            .withTransactionId("200015214831")
+            .withAmount(1.0)
+            .execute(), "DeletePreAuth device error");
+    });
+});
+// ===========================================================================
+// startCardTransaction()
+// References:
+//   UpaAdminTests.cs – StartCardTransaction_AllCardAcquisitionTypes
+//     Assert.AreEqual("Success", response.Status);
+//     Assert.AreEqual("00", response.DeviceResponseCode);
+// ===========================================================================
+describeUpaStory2("UPA Story 2 – startCardTransaction()", () => {
+    let device;
+    beforeEach(() => {
+        device = DeviceService_1.DeviceService.create(buildConfig());
+        device.ecrId = "13";
+    });
+    /**
+     * Mirrors UpaAdminTests.cs – StartCardTransaction_AllCardAcquisitionTypes
+     *   Assert.IsNotNull(response);
+     *   Assert.AreEqual("Success", response.Status);
+        test("[UpaAdminTests] startCardTransaction() all acquisition types returns Success", async () => {
+     */
+    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 = Enums_2.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (useLiveMic && 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 (useLiveMic) {
+            if (isKnownLiveStartCardTransactionBlocker(response)) {
+                console.warn(formatLiveFailure(response, "StartCardTransaction all acquisition types"));
+                return;
+            }
+            expectLiveSuccess(response, "StartCardTransaction");
+            expectParsedStartCardTransactionResponse(response);
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    /**
+     * Mirrors UpaAdminTests.cs – StartCardTransaction (basic, swipe only)
+     *   Assert.IsNotNull(response);
+     *   Assert.AreEqual("Success", response.Status);
+     */
+    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 = Enums_2.TransactionType.Sale;
+        let response;
+        try {
+            response = await device.startCardTransaction(param, indicator, transData);
+        }
+        catch (error) {
+            if (useLiveMic && 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 (useLiveMic) {
+            if (isKnownLiveGiftCardBlocker(response) ||
+                isKnownLiveStartCardTransactionBlocker(response)) {
+                console.warn(formatLiveFailure(response, "StartCardTransaction swipe with GIFT filter"));
+                return;
+            }
+            expectLiveSuccess(response, "StartCardTransaction");
+            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 = Enums_2.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 = Enums_2.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 = Enums_2.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",
+        });
+    });
+    liveOnlyStory2("[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 = Enums_2.TransactionType.Sale;
+        const response = await 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();
+    });
+    liveOnlyStory2("[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 = Enums_2.TransactionType.Sale;
+        const response = await executeLiveStartCardTransaction(device, param, indicator, transData, "StartCardTransaction infinite timeout");
+        if (!response) {
+            return;
+        }
+        expect(response.acquisitionType).toBeTruthy();
+    });
+    liveOnlyStory2("[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 = Enums_2.TransactionType.Sale;
+        const response = await 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.");
+        }
+    });
+    liveOnlyStory2("[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 = Enums_2.TransactionType.Refund;
+        const response = await 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();
+    });
+    liveOnlyStory2("[LiveSetup] startCardTransaction() scan mode returns scanned data", async () => {
+        const param = new UpaParam_1.UpaParam();
+        param.timeout = 90;
+        param.acquisitionTypes = [AcquisitionType_1.AcquisitionType.Scan];
+        param.header = "Scan Sale";
+        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 = Enums_2.TransactionType.Sale;
+        const response = await executeLiveStartCardTransaction(device, param, indicator, transData, "StartCardTransaction scan mode");
+        if (!response) {
+            return;
+        }
+        expect(response.acquisitionType.toUpperCase()).toBe("SCAN");
+        expect(response.scannedData).toBeTruthy();
+    });
+});
+// ===========================================================================
+// reboot()
+// References:
+//   UpaAdminTests.cs – Reboot: Assert.AreEqual("Success", response.Status)
+//   UpaMicTests.cs – Reboot: Assert.AreEqual("00", response.DeviceResponseCode)
+//                             Assert.AreEqual("COMPLETE", response.DeviceResponseText)
+//                             (unit test uses mock returning "Success" / "00")
+// ===========================================================================
+describeUpaStory2("UPA Story 2 – reboot()", () => {
+    let device;
+    beforeEach(() => {
+        device = DeviceService_1.DeviceService.create(buildConfig());
+        device.ecrId = "13";
+    });
+    /**
+     * Mirrors UpaAdminTests.cs – Reboot + UpaMicTests.cs – Reboot
+     *   Assert.IsNotNull(response);
+     *   Assert.AreEqual("Success", response.Status);
+     *   Assert.AreEqual("00", response.DeviceResponseCode);
+     */
+    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 (useLiveMic) {
+            expectLiveSuccess(response, "Reboot");
+            return;
+        }
+        expect(response.status).toBe("Success");
+        expect(response.deviceResponseCode).toBe("00");
+    });
+    liveOnlyStory2("[LiveSetup] reboot() on inactive or unresponsive terminal documents current routing behavior", async () => {
+        const unavailableDevice = DeviceService_1.DeviceService.create(buildConfig());
+        unavailableDevice.ecrId = "99999999";
+        try {
+            const response = await unavailableDevice.reboot();
+            expect(response).not.toBeNull();
+            expect(response).toBeInstanceOf(TransactionResponse_1.TransactionResponse);
+            if (isKnownLiveBusyBlocker(response)) {
+                console.warn(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 (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(buildConfig({ serviceUrl: "http://127.0.0.1:1" }), "reboot-communication-failure");
+        communicationFailureDevice.ecrId = "13";
+        await expect(communicationFailureDevice.reboot()).rejects.toBeInstanceOf(Error);
+    });
+});
+//# sourceMappingURL=UpaStory2Methods.test.js.map