@staxpayments/staxpayments-js 2.30.18

package/dist/cryptoutils.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.BlockChypCrypto = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _require = require('@noble/hashes/hmac'),
+  hmac = _require.hmac;
+var _require2 = require('@noble/hashes/sha256'),
+  sha256 = _require2.sha256;
+var _require3 = require('@noble/hashes/utils'),
+  randomBytes = _require3.randomBytes,
+  bytesToHex = _require3.bytesToHex,
+  utf8ToBytes = _require3.utf8ToBytes;
+var _require4 = require('@noble/curves/nist'),
+  p256 = _require4.p256;
+var moment = require('moment');
+var base32 = require('base32');
+var aesjs = require('aes-js');
+var BlockChypCrypto = exports.BlockChypCrypto = /*#__PURE__*/function () {
+  function BlockChypCrypto() {
+    (0, _classCallCheck2["default"])(this, BlockChypCrypto);
+  }
+  return (0, _createClass2["default"])(BlockChypCrypto, [{
+    key: "generateGatewayHeaders",
+    value: function generateGatewayHeaders(creds) {
+      var nonce = this.generateNonce();
+      var ts = this.generateIsoTimestamp();
+      var toSign = creds.apiKey + creds.bearerToken + ts + nonce;
+      var key = Buffer.from(creds.signingKey, 'hex');
+      var mac = hmac(sha256, key, utf8ToBytes(toSign));
+      var sig = bytesToHex(mac);
+      var results = {
+        'Nonce': nonce,
+        'Timestamp': ts,
+        'Authorization': 'Dual ' + creds.bearerToken + ':' + creds.apiKey + ':' + sig
+      };
+      return results;
+    }
+  }, {
+    key: "encrypt",
+    value: function encrypt(hexKey, plainText) {
+      var key = Buffer.from(hexKey, 'hex').slice(0, 32);
+      var keyArr = (0, _toConsumableArray2["default"])(key);
+      var iv = randomBytes(16);
+      var ivArr = (0, _toConsumableArray2["default"])(iv);
+      var aesCbc = new aesjs.ModeOfOperation.cbc(keyArr, ivArr);
+      var plainBytes = aesjs.padding.pkcs7.pad(aesjs.utils.utf8.toBytes(plainText));
+      var encryptedBytes = aesCbc.encrypt(plainBytes);
+      return bytesToHex(iv) + aesjs.utils.hex.fromBytes(encryptedBytes);
+    }
+  }, {
+    key: "sha256Hash",
+    value: function sha256Hash(msg) {
+      var msgBytes = Buffer.from(msg, 'hex');
+      return bytesToHex(sha256(msgBytes));
+    }
+  }, {
+    key: "validateSignature",
+    value: function validateSignature(publicKey, msg, sig) {
+      // Hash the message
+      var msgHash = this.sha256Hash(msg);
+      var msgHashBytes = Buffer.from(msgHash, 'hex');
+
+      // Convert hex string coordinates to BigInt and create point
+      var pubKeyPoint = p256.ProjectivePoint.fromAffine({
+        x: BigInt('0x' + publicKey.x),
+        y: BigInt('0x' + publicKey.y)
+      });
+      var pubKeyBytes = pubKeyPoint.toRawBytes(false);
+
+      // Create signature from r, s components
+      var signature = new p256.Signature(BigInt('0x' + sig.r), BigInt('0x' + sig.s));
+      var sigBytes = signature.toCompactRawBytes();
+
+      // Verify signature
+      return p256.verify(sigBytes, msgHashBytes, pubKeyBytes, {
+        prehash: true
+      });
+    }
+  }, {
+    key: "decrypt",
+    value: function decrypt(hexKey, cipherText) {
+      var key = Buffer.from(hexKey, 'hex').slice(0, 32);
+      var keyArr = (0, _toConsumableArray2["default"])(key);
+      var cipherBytes = Buffer.from(cipherText, 'hex');
+      var iv = cipherBytes.slice(0, 16);
+      var aesCbc = new aesjs.ModeOfOperation.cbc(keyArr, iv);
+      var cipher = cipherBytes.slice(16, cipherBytes.length);
+      var cipherArr = (0, _toConsumableArray2["default"])(cipher);
+      var decryptedBytes = aesjs.padding.pkcs7.strip(aesCbc.decrypt(cipherArr));
+      return aesjs.utils.utf8.fromBytes(decryptedBytes);
+    }
+  }, {
+    key: "generateNonce",
+    value: function generateNonce() {
+      return base32.encode(randomBytes(32)).toUpperCase();
+    }
+  }, {
+    key: "generateIsoTimestamp",
+    value: function generateIsoTimestamp() {
+      return moment().utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z';
+    }
+  }]);
+}();
+var CryptoUtils = new BlockChypCrypto();
+var _default = exports["default"] = CryptoUtils;

package/dist/global.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var base = _interopRequireWildcard(require("./client"));
+var root = _interopRequireWildcard(require("./staxpaymentsclient"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+if (typeof window !== 'undefined') {
+  window.staxpayments = _objectSpread(_objectSpread({}, base), root);
+}

package/dist/mappers.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.authRequestMapper = authRequestMapper;
+exports.authResponseMapper = authResponseMapper;
+/**
+ * Copyright 2019-2026 BlockChyp, Inc. All rights reserved. Use of this code is governed
+ * by a license that can be found in the LICENSE file.
+ *
+ * This file was generated automatically by the BlockChyp SDK Generator. Changes to this
+ * file will be lost every time the code is regenerated.
+ */
+
+/**
+ * Maps a Stax Payments charge or preauth request onto the BlockChyp wire model. Fields not
+ * listed here carry the same name on both sides and are matched by name; the generated
+ * mapper spells every one of them out.
+ */
+function authRequestMapper(src) {
+  var dst = {};
+  dst.tipAmount = src.tipAmount;
+  dst.taxAmount = src.taxAmount;
+  dst.terminalName = src.terminalName;
+  dst.amount = src.amount;
+  dst.currencyCode = src.currencyCode;
+  dst.promptForTip = src.promptForTip;
+  dst.test = src.test;
+  dst.enroll = src.enroll;
+  dst.externalPartnerMetadata = src.externalPartnerMetadata;
+  /**
+   * The caller's own reference rides out as externalTransactionRef. BlockChyp's own
+   * transactionRef is a different thing: it drives duplicate detection and transaction
+   * recall, and carries the Stax transaction id.
+   */
+  dst.externalTransactionRef = src.transactionRef;
+  return dst;
+}
+
+/**
+ * Maps a BlockChyp charge or preauth response onto the Stax Payments model. Fields not
+ * listed here are matched by name.
+ */
+function authResponseMapper(src) {
+  var dst = {};
+  dst.success = src.success;
+  dst.error = src.error;
+  dst.responseDescription = src.responseDescription;
+  /**
+   * The Stax transaction id comes back in the transaction ref. BlockChyp's
+   * transactionId is BlockChyp's own id and is deliberately not surfaced.
+   */
+  dst.transactionId = src.transactionRef;
+  dst.approved = src.approved;
+  dst.authCode = src.authCode;
+  dst.requestedAmount = src.requestedAmount;
+  dst.authorizedAmount = src.authorizedAmount;
+  dst.currencyCode = src.currencyCode;
+  dst.entryMethod = src.entryMethod;
+  dst.maskedPan = src.maskedPan;
+  dst.network = src.network;
+  dst.timestamp = src.timestamp;
+  dst.status = src.status;
+  dst.cardMetadata = src.cardMetadata;
+  dst.receiptSuggestions = src.receiptSuggestions;
+  dst.test = src.test;
+  /**
+   * The caller's own reference comes back from externalTransactionRef, not from
+   * BlockChyp's transactionRef, which carries the Stax transaction id and is surfaced
+   * as transactionId.
+   */
+  dst.transactionRef = src.externalTransactionRef;
+  return dst;
+}

package/dist/payments.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PaymentsClient = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var Mappers = _interopRequireWildcard(require("./mappers"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+/**
+ * Copyright 2019-2026 BlockChyp, Inc. All rights reserved. Use of this code is governed
+ * by a license that can be found in the LICENSE file.
+ *
+ * This file was generated automatically by the BlockChyp SDK Generator. Changes to this
+ * file will be lost every time the code is regenerated.
+ */
+// PaymentsClient exposes the Payment Endpoints for the Stax Payments
+// API. It is constructed by the root StaxPaymentsClient with a shared transport
+// (StaxPaymentsBaseClient), so every namespace shares one transient-credential
+// cache rather than exchanging credentials per namespace.
+var PaymentsClient = exports.PaymentsClient = /*#__PURE__*/function () {
+  function PaymentsClient(base) {
+    (0, _classCallCheck2["default"])(this, PaymentsClient);
+    this.base = base;
+  }
+
+  /**
+   * Executes a standard direct preauth and capture.
+   */
+  // Takes and returns the Stax Payments models. The BlockChyp wire models are
+  // an implementation detail: the request is mapped on the way out and the
+  // reply on the way back.
+  return (0, _createClass2["default"])(PaymentsClient, [{
+    key: "charge",
+    value: (function () {
+      var _charge = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(request) {
+        var response;
+        return _regenerator["default"].wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 1;
+              return this.base.routeTransaction('post', Mappers.authRequestMapper(request), '/api/charge', '/api/charge');
+            case 1:
+              response = _context.sent;
+              return _context.abrupt("return", Mappers.authResponseMapper(response.data));
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function charge(_x) {
+        return _charge.apply(this, arguments);
+      }
+      return charge;
+    }()
+    /**
+     * Executes a preauthorization intended to be captured later.
+     */
+    // Takes and returns the Stax Payments models. The BlockChyp wire models are
+    // an implementation detail: the request is mapped on the way out and the
+    // reply on the way back.
+    )
+  }, {
+    key: "preauth",
+    value: (function () {
+      var _preauth = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(request) {
+        var response;
+        return _regenerator["default"].wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 1;
+              return this.base.routeTransaction('post', Mappers.authRequestMapper(request), '/api/preauth', '/api/preauth');
+            case 1:
+              response = _context2.sent;
+              return _context2.abrupt("return", Mappers.authResponseMapper(response.data));
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function preauth(_x2) {
+        return _preauth.apply(this, arguments);
+      }
+      return preauth;
+    }())
+  }]);
+}();

package/dist/staxpaymentsclient.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StaxPaymentsClient = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _client = require("./client");
+var _payments = require("./payments");
+var _terminals = require("./terminals");
+/**
+ * Copyright 2019-2026 BlockChyp, Inc. All rights reserved. Use of this code is governed
+ * by a license that can be found in the LICENSE file.
+ *
+ * This file was generated automatically by the BlockChyp SDK Generator. Changes to this
+ * file will be lost every time the code is regenerated.
+ */
+// StaxPaymentsClient is the root Stax Payments client. It builds the shared
+// transport (StaxPaymentsBaseClient) once and exposes each API namespace
+// (e.g. payments, terminals) as a property, so a single set of transient
+// credentials is fetched, cached, and refreshed across every namespace rather
+// than per namespace.
+var StaxPaymentsClient = exports.StaxPaymentsClient = /*#__PURE__*/function () {
+  // Construct the root client with your Stax bearer token.
+  function StaxPaymentsClient(creds) {
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck2["default"])(this, StaxPaymentsClient);
+    this.base = new _client.StaxPaymentsBaseClient(creds, opts);
+    this.payments = new _payments.PaymentsClient(this.base);
+    this.terminals = new _terminals.TerminalsClient(this.base);
+  }
+
+  // heartbeat checks connectivity with the Stax Payments gateway.
+  return (0, _createClass2["default"])(StaxPaymentsClient, [{
+    key: "heartbeat",
+    value: function heartbeat() {
+      return this.base.heartbeat();
+    }
+
+    // Host configuration is shared across every namespace.
+  }, {
+    key: "setGatewayHost",
+    value: function setGatewayHost(host) {
+      this.base.setGatewayHost(host);
+    }
+  }, {
+    key: "getGatewayHost",
+    value: function getGatewayHost() {
+      return this.base.getGatewayHost();
+    }
+  }, {
+    key: "setTestGatewayHost",
+    value: function setTestGatewayHost(host) {
+      this.base.setTestGatewayHost(host);
+    }
+  }, {
+    key: "setDashboardHost",
+    value: function setDashboardHost(host) {
+      this.base.setDashboardHost(host);
+    }
+  }, {
+    key: "getDashboardHost",
+    value: function getDashboardHost() {
+      return this.base.getDashboardHost();
+    }
+  }, {
+    key: "setCoreHost",
+    value: function setCoreHost(host) {
+      this.base.setCoreHost(host);
+    }
+  }]);
+}();

package/dist/terminals.js

@@ -0,0 +1,308 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TerminalsClient = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+/**
+ * Copyright 2019-2026 BlockChyp, Inc. All rights reserved. Use of this code is governed
+ * by a license that can be found in the LICENSE file.
+ *
+ * This file was generated automatically by the BlockChyp SDK Generator. Changes to this
+ * file will be lost every time the code is regenerated.
+ */
+// TerminalsClient exposes the Terminal Management Endpoints for the Stax Payments
+// API. It is constructed by the root StaxPaymentsClient with a shared transport
+// (StaxPaymentsBaseClient), so every namespace shares one transient-credential
+// cache rather than exchanging credentials per namespace.
+var TerminalsClient = exports.TerminalsClient = /*#__PURE__*/function () {
+  function TerminalsClient(base) {
+    (0, _classCallCheck2["default"])(this, TerminalsClient);
+    this.base = base;
+  }
+
+  /**
+   * Tests connectivity with a payment terminal.
+   */
+  return (0, _createClass2["default"])(TerminalsClient, [{
+    key: "ping",
+    value: (function () {
+      var _ping = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(request) {
+        return _regenerator["default"].wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", this.base.routeTransaction('post', request, '/api/test', '/api/terminal-test'));
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function ping(_x) {
+        return _ping.apply(this, arguments);
+      }
+      return ping;
+    }()
+    /**
+     * Returns routing and location data for a payment terminal.
+     */
+    )
+  }, {
+    key: "locate",
+    value: function locate(request) {
+      return this.base._gatewayRequest('post', '/api/terminal-locate', request);
+    }
+    /**
+     * Clears the line item display and any in progress transaction.
+     */
+  }, {
+    key: "clear",
+    value: (function () {
+      var _clear = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(request) {
+        return _regenerator["default"].wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", this.base.routeTransaction('post', request, '/api/clear', '/api/terminal-clear'));
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function clear(_x2) {
+        return _clear.apply(this, arguments);
+      }
+      return clear;
+    }()
+    /**
+     * Returns the current status of a terminal.
+     */
+    )
+  }, {
+    key: "terminalStatus",
+    value: (function () {
+      var _terminalStatus = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(request) {
+        return _regenerator["default"].wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              return _context3.abrupt("return", this.base.routeTransaction('post', request, '/api/terminal-status', '/api/terminal-status'));
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function terminalStatus(_x3) {
+        return _terminalStatus.apply(this, arguments);
+      }
+      return terminalStatus;
+    }()
+    /**
+     * Captures and returns a signature.
+     */
+    )
+  }, {
+    key: "captureSignature",
+    value: (function () {
+      var _captureSignature = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(request) {
+        return _regenerator["default"].wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", this.base.routeTransaction('post', request, '/api/capture-signature', '/api/capture-signature'));
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function captureSignature(_x4) {
+        return _captureSignature.apply(this, arguments);
+      }
+      return captureSignature;
+    }()
+    /**
+     * Displays a new transaction on the terminal.
+     */
+    )
+  }, {
+    key: "newTransactionDisplay",
+    value: (function () {
+      var _newTransactionDisplay = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5(request) {
+        return _regenerator["default"].wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              return _context5.abrupt("return", this.base.routeTransaction('post', request, '/api/txdisplay', '/api/terminal-txdisplay'));
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function newTransactionDisplay(_x5) {
+        return _newTransactionDisplay.apply(this, arguments);
+      }
+      return newTransactionDisplay;
+    }()
+    /**
+     * Appends items to an existing transaction display. Subtotal, Tax, and Total are
+     * overwritten by the request. Items with the same description are combined into
+     * groups.
+     */
+    )
+  }, {
+    key: "updateTransactionDisplay",
+    value: (function () {
+      var _updateTransactionDisplay = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6(request) {
+        return _regenerator["default"].wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              return _context6.abrupt("return", this.base.routeTransaction('put', request, '/api/txdisplay', '/api/terminal-txdisplay'));
+            case 1:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function updateTransactionDisplay(_x6) {
+        return _updateTransactionDisplay.apply(this, arguments);
+      }
+      return updateTransactionDisplay;
+    }()
+    /**
+     * Displays a short message on the terminal.
+     */
+    )
+  }, {
+    key: "message",
+    value: (function () {
+      var _message = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7(request) {
+        return _regenerator["default"].wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              return _context7.abrupt("return", this.base.routeTransaction('post', request, '/api/message', '/api/message'));
+            case 1:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function message(_x7) {
+        return _message.apply(this, arguments);
+      }
+      return message;
+    }()
+    /**
+     * Asks the consumer a yes/no question.
+     */
+    )
+  }, {
+    key: "booleanPrompt",
+    value: (function () {
+      var _booleanPrompt = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8(request) {
+        return _regenerator["default"].wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              return _context8.abrupt("return", this.base.routeTransaction('post', request, '/api/boolean-prompt', '/api/boolean-prompt'));
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function booleanPrompt(_x8) {
+        return _booleanPrompt.apply(this, arguments);
+      }
+      return booleanPrompt;
+    }()
+    /**
+     * Asks the consumer a text based question.
+     */
+    )
+  }, {
+    key: "textPrompt",
+    value: (function () {
+      var _textPrompt = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee9(request) {
+        return _regenerator["default"].wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              return _context9.abrupt("return", this.base.routeTransaction('post', request, '/api/text-prompt', '/api/text-prompt'));
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function textPrompt(_x9) {
+        return _textPrompt.apply(this, arguments);
+      }
+      return textPrompt;
+    }()
+    /**
+     * Returns all terminals associated with the merchant account.
+     */
+    )
+  }, {
+    key: "terminals",
+    value: function terminals(request) {
+      return this.base._dashboardRequest('get', '/api/terminals', request);
+    }
+    /**
+     * Deactivates a terminal.
+     */
+  }, {
+    key: "deactivateTerminal",
+    value: function deactivateTerminal(request) {
+      return this.base._dashboardRequest('delete', '/api/terminal/' + request.terminalId, request);
+    }
+    /**
+     * Activates a terminal.
+     */
+  }, {
+    key: "activateTerminal",
+    value: (function () {
+      var _activateTerminal = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee0(request) {
+        return _regenerator["default"].wrap(function (_context0) {
+          while (1) switch (_context0.prev = _context0.next) {
+            case 0:
+              return _context0.abrupt("return", this.base._coreRequest('post', '/terminals', request));
+            case 1:
+            case "end":
+              return _context0.stop();
+          }
+        }, _callee0, this);
+      }));
+      function activateTerminal(_x0) {
+        return _activateTerminal.apply(this, arguments);
+      }
+      return activateTerminal;
+    }()
+    /**
+     * Reboot a payment terminal.
+     */
+    )
+  }, {
+    key: "reboot",
+    value: (function () {
+      var _reboot = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee1(request) {
+        return _regenerator["default"].wrap(function (_context1) {
+          while (1) switch (_context1.prev = _context1.next) {
+            case 0:
+              return _context1.abrupt("return", this.base.routeTransaction('post', request, '/api/reboot', '/api/terminal-reboot'));
+            case 1:
+            case "end":
+              return _context1.stop();
+          }
+        }, _callee1, this);
+      }));
+      function reboot(_x1) {
+        return _reboot.apply(this, arguments);
+      }
+      return reboot;
+    }())
+  }]);
+}();