@paydock/client-sdk 1.139.0-beta → 1.140.0-beta

package/bundles/index.cjs

@@ -1194,7 +1194,7 @@ SDK.headerKeys = Object.freeze({
   version: 'x-sdk-version',
   type: 'x-sdk-type'
 });
-SDK._version = 'v1.139.0-beta';
+SDK._version = 'v1.140.0-beta';
 
 function isFunction(value) {
     return typeof value === 'function';
@@ -18787,21 +18787,674 @@ var PaypalCheckoutButton = /*#__PURE__*/function (_CheckoutButton) {
   return _createClass(PaypalCheckoutButton);
 }(CheckoutButton);
 
+/**
+ * Operations that can fail during the wallet lifecycle.
+ * Used in {@link OnErrorPayload.context.operation} to identify what failed.
+ */
+exports.ERROR_OPERATION = void 0;
+(function (ERROR_OPERATION) {
+  /** General wallet lifecycle operation. */
+  ERROR_OPERATION["WALLET_OPERATION"] = "wallet_operation";
+  /** Loading or validating the wallet service configuration. */
+  ERROR_OPERATION["CONFIGURATION"] = "configuration";
+  /** A required event handler was not registered before calling load(). */
+  ERROR_OPERATION["HANDLER_REGISTRATION"] = "handler_registration";
+  /** Processing a shipping address or shipping option update. */
+  ERROR_OPERATION["SHIPPING_UPDATE"] = "shipping_update";
+})(exports.ERROR_OPERATION || (exports.ERROR_OPERATION = {}));
+
+/**
+ * Events emitted during the OpenWallet payment lifecycle.
+ */
 var EVENT$2;
 (function (EVENT) {
-  EVENT["ON_UPDATE"] = "onUpdate";
+  /** Emitted when the wallet button is clicked by the user. */
   EVENT["ON_CLICK"] = "onClick";
-  EVENT["ON_CHECKOUT_CLOSE"] = "onCheckoutClose";
+  /** Emitted when the OTT (One-Time Token) creation succeeds. */
   EVENT["SUCCESS"] = "success";
+  /** Emitted when the wallet is not available on the current device/browser. */
   EVENT["UNAVAILABLE"] = "unavailable";
+  /** Emitted when an error occurs during wallet operation. */
   EVENT["ERROR"] = "error";
-  EVENT["UPDATE"] = "update";
+  /** Emitted when the wallet button has been loaded and rendered in the DOM. */
   EVENT["LOADED"] = "loaded";
+  /** Emitted when the wallet checkout is closed/cancelled by the user (internal). */
   EVENT["CHECKOUT_CLOSE"] = "checkoutClose";
+  /** Emitted when the customer selects or updates their shipping address. */
   EVENT["ON_SHIPPING_ADDRESS_CHANGE"] = "onShippingAddressChange";
+  /** Emitted when the customer selects a shipping option. */
   EVENT["ON_SHIPPING_OPTIONS_CHANGE"] = "onShippingOptionsChange";
 })(EVENT$2 || (EVENT$2 = {}));
 
+/**
+ * @classdesc Abstract base class for Open Wallet buttons. **Do not instantiate directly.**
+ * Use {@link ApplePayOpenWalletButton} or {@link GooglePayOpenWalletButton} instead.
+ *
+ * Use one of the concrete implementations instead:
+ * - {@link ApplePayOpenWalletButton} for Apple Pay integration
+ * - {@link GooglePayOpenWalletButton} for Google Pay integration
+ *
+ * These subclasses inherit all event handlers and lifecycle methods documented below.
+ *
+ * @class OpenWalletButtons
+ * @abstract
+ * @hideconstructor
+ */
+var OpenWalletButtons = /*#__PURE__*/function () {
+  /** @private */
+  function OpenWalletButtons(selector, publicKeyOrAccessToken, serviceId, meta) {
+    _classCallCheck(this, OpenWalletButtons);
+    this.env = DEFAULT_ENV;
+    this.onShippingOptionsChangeHandlerRegistered = false;
+    this.eventEmitter = new EventEmitter();
+    this.container = new Container(selector);
+    this.api = new ApiInternal(publicKeyOrAccessToken, this.getApiAuthType(publicKeyOrAccessToken));
+    this.serviceId = serviceId;
+    this.meta = meta;
+    this.validateBaseMeta();
+    this.validateWalletMeta();
+  }
+  return _createClass(OpenWalletButtons, [{
+    key: "getApiAuthType",
+    value: function getApiAuthType(publicKeyOrAccessToken) {
+      if (AccessToken.validateJWT(publicKeyOrAccessToken)) {
+        return API_AUTH_TYPE.TOKEN;
+      }
+      return API_AUTH_TYPE.PUBLIC_KEY;
+    }
+    /**
+     * Validates the base metadata fields common to all wallet types:
+     * `meta` must exist, `amount` must be a number, `currency` and `country` must be strings.
+     *
+     * @private
+     * @throws {Error} If any base required field is missing or has an invalid type.
+     */
+  }, {
+    key: "validateBaseMeta",
+    value: function validateBaseMeta() {
+      if (!this.meta) {
+        throw new Error('Meta is required');
+      }
+      if (typeof this.meta.amount !== 'number') {
+        throw new Error('meta.amount needs to be numeric');
+      }
+      if (typeof this.meta.currency !== 'string') {
+        throw new Error('meta.currency needs to be a string');
+      }
+      if (typeof this.meta.country !== 'string') {
+        throw new Error('meta.country needs to be a string');
+      }
+    }
+  }, {
+    key: "getOpenWalletServiceConfig",
+    value: function getOpenWalletServiceConfig() {
+      return __awaiter(this, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee() {
+        var storageKey, cachedData, _JSON$parse, data, timestamp, oneDay, serviceConfigResponse, encodedData;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.p = _context.n) {
+            case 0:
+              storageKey = "serviceConfig-".concat(this.serviceId);
+              _context.p = 1;
+              cachedData = localStorage.getItem(storageKey);
+              if (!cachedData) {
+                _context.n = 5;
+                break;
+              }
+              _context.p = 2;
+              _JSON$parse = JSON.parse(atob(cachedData)), data = _JSON$parse.data, timestamp = _JSON$parse.timestamp;
+              oneDay = 86400000;
+              if (!(Date.now() - timestamp < oneDay)) {
+                _context.n = 3;
+                break;
+              }
+              return _context.a(2, JSON.parse(data));
+            case 3:
+              _context.n = 5;
+              break;
+            case 4:
+              _context.p = 4;
+              _context.v;
+              localStorage.removeItem(storageKey);
+            case 5:
+              _context.n = 7;
+              break;
+            case 6:
+              _context.p = 6;
+              _context.v;
+            case 7:
+              _context.n = 8;
+              return this.api.service().getConfig(this.serviceId);
+            case 8:
+              serviceConfigResponse = _context.v;
+              try {
+                encodedData = btoa(JSON.stringify({
+                  data: JSON.stringify(serviceConfigResponse),
+                  timestamp: Date.now()
+                }));
+                localStorage.setItem(storageKey, encodedData);
+              } catch (_error) {
+                // localStorage may be unavailable; proceed without caching
+              }
+              return _context.a(2, serviceConfigResponse);
+          }
+        }, _callee, this, [[2, 4], [1, 6]]);
+      }));
+    }
+  }, {
+    key: "handleOnError",
+    value: function handleOnError(error) {
+      var operation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : exports.ERROR_OPERATION.WALLET_OPERATION;
+      if (error) {
+        console.error('Wallet operation error:', error);
+      }
+      var errorData = {
+        event: EVENT$2.ERROR,
+        data: {
+          error: error,
+          context: {
+            operation: operation
+          }
+        }
+      };
+      this.eventEmitter.emit(EVENT$2.ERROR, errorData);
+    }
+    /**
+     * Loads and initializes the wallet button based on the service configuration.
+     * This method fetches the wallet service configuration, validates that the service
+     * type matches the expected wallet, and creates the appropriate wallet service instance.
+     * Bear in mind that you must call this method after setting up all event handlers.
+     *
+     * @example
+     * button.onClick((data) => { ... });
+     * button.onSuccess((data) => { ... });
+     * button.onError((error) => { ... });
+     * button.load();
+     */
+  }, {
+    key: "load",
+    value: function load() {
+      var _this = this;
+      this.getOpenWalletServiceConfig().then(function (serviceConfig) {
+        _this.validateServiceType(serviceConfig);
+        _this.walletService = _this.createWalletService(serviceConfig);
+        _this.walletService.load();
+      })["catch"](function (error) {
+        _this.handleOnError(error instanceof Error ? error : new Error(String(error)), exports.ERROR_OPERATION.CONFIGURATION);
+      });
+    }
+    /**
+     * Current method can change environment. By default environment = sandbox.
+     * Also we can change domain alias for this environment. By default domain_alias = paydock.com
+     * Bear in mind that you must set an environment before calling `button.load()`.
+     *
+     * @example
+     * button.setEnv('production', 'paydock.com');
+     *
+     * @param {string} env - The target environment: `'sandbox'` or `'production'`.
+     * @param {string} [alias] - Own domain alias.
+     */
+  }, {
+    key: "setEnv",
+    value: function setEnv(env, alias) {
+      this.env = env;
+      this.api.setEnv(env, alias);
+    }
+    /**
+     * Updates the wallet metadata after initialization.
+     * Use this when order information changes (e.g. amount, currency) after the button has been rendered.
+     * Bear in mind that this must be called before the next payment attempt takes effect.
+     *
+     * @example
+     * button.setMeta({ ...meta, amount: 29.99 });
+     *
+     * @param {ApplePayOpenWalletMeta | GooglePayOpenWalletMeta} meta - The updated metadata object. The concrete type depends on the button class.
+     */
+  }, {
+    key: "setMeta",
+    value: function setMeta(meta) {
+      this.meta = meta;
+      if (this.walletService) {
+        this.walletService.setMeta(meta);
+      }
+    }
+    /**
+     * Removes the wallet button from the DOM and cleans up resources.
+     * Call this method when the wallet button is no longer needed (e.g. navigating away from the payment page).
+     *
+     * @example
+     * button.destroy();
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (this.walletService) {
+        this.walletService.destroy();
+        this.walletService = undefined;
+      }
+    }
+    /**
+     * Callback for onClick method.
+     *
+     * @callback OnClickCallback
+     * @param {OnClickEventData} data - The click event data.
+     * @returns {boolean | void | Promise<boolean | void>} Return `false` to abort, or a Promise to defer.
+     */
+    /**
+     * Registers a callback function to be invoked when the wallet button gets clicked.
+     * The handler controls the wallet payment flow via its return value:
+     *
+     * - Return `void` (or nothing) to continue the payment flow normally.
+     * - Return `false` to abort the payment flow.
+     * - Return a `Promise<void>` to defer the wallet sheet until the promise resolves.
+     * - Return a `Promise<boolean>` — if it resolves to `false`, the flow is aborted.
+     * - Throwing an error (sync or async) also aborts the flow.
+     *
+     * Both synchronous and asynchronous (async) handlers are supported.
+     *
+     * **Note:** this callback may be called multiple times as the customer closes the payment
+     * checkout and re-clicks the button.
+     *
+     * @example
+     * // Synchronous usage — continue normally
+     * button.onClick((event) => {
+     *   performValidationLogic();
+     * });
+     *
+     * @example
+     * // Synchronous abort — return false to cancel the payment
+     * button.onClick((event) => {
+     *   if (!isOrderValid()) return false;
+     * });
+     *
+     * @example
+     * // Asynchronous usage — defer wallet sheet until the promise resolves
+     * button.onClick(async (event) => {
+     *   await fetch('/validate-order').then(res => res.json());
+     * });
+     *
+     * @param {OnClickCallback} handler - Function to be called when the wallet button is clicked.
+     */
+  }, {
+    key: "onClick",
+    value: function onClick(handler) {
+      if (typeof handler === 'function') {
+        this.eventEmitter.subscribe(EVENT$2.ON_CLICK, handler);
+        return;
+      }
+      this.handleOnError(new Error('onClick event handler is required.'), exports.ERROR_OPERATION.HANDLER_REGISTRATION);
+    }
+    /**
+     * Callback for onSuccess method.
+     *
+     * @callback OnSuccessCallback
+     * @param {OnCreateOTTSuccessfulEventData} data - The OTT creation result including the token, amount, and address data.
+     */
+    /**
+     * Registers a callback function to be invoked when the OTT (One-Time Token) creation was successful.
+     * Both synchronous and asynchronous (async) handlers are supported.
+     *
+     * **Important:** A handler is required. Do not perform thread blocking operations in callback such as `window.alert()` calls.
+     *
+     * **Error handling:** If the handler throws (sync or async), the error is logged and swallowed
+     * so that internal processing continues uninterrupted.
+     *
+     * @example
+     * button.onSuccess((event) => {
+     *   console.log('OTT created:', event.data.token.temp_token);
+     *   console.log('Amount:', event.data.amount);
+     * });
+     *
+     * @example
+     * // Async handler
+     * button.onSuccess(async (event) => {
+     *   await submitTokenToServer(event.data.token.temp_token);
+     * });
+     *
+     * @param {OnSuccessCallback} handler - Function to be called when the OTT creation was successful.
+     */
+  }, {
+    key: "onSuccess",
+    value: function onSuccess(handler) {
+      var _this2 = this;
+      if (typeof handler === 'function') {
+        this.eventEmitter.subscribe(EVENT$2.SUCCESS, function (data) {
+          return __awaiter(_this2, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee2() {
+            var _t3;
+            return _regenerator().w(function (_context2) {
+              while (1) switch (_context2.p = _context2.n) {
+                case 0:
+                  _context2.p = 0;
+                  _context2.n = 1;
+                  return handler(data);
+                case 1:
+                  _context2.n = 3;
+                  break;
+                case 2:
+                  _context2.p = 2;
+                  _t3 = _context2.v;
+                  console.warn('Merchant onSuccess handler threw (swallowed):', _t3);
+                case 3:
+                  return _context2.a(2);
+              }
+            }, _callee2, null, [[0, 2]]);
+          }));
+        });
+        return;
+      }
+      this.handleOnError(new Error('onSuccess event handler is required to receive the OTT token string.'), exports.ERROR_OPERATION.HANDLER_REGISTRATION);
+    }
+    /**
+     * Callback for onUnavailable method.
+     *
+     * @callback OnUnavailableCallback
+     * @param {OnUnavailableEventData} data - Data describing why the wallet is unavailable.
+     */
+    /**
+     * Registers a callback function to be invoked when the wallet is not available in the current context.
+     * This can happen when the wallet service is not supported on the current device or browser.
+     * Both synchronous and asynchronous (async) handlers are supported.
+     *
+     * **Error handling:** If the handler throws (sync or async), the error is logged and swallowed
+     * so that internal processing continues uninterrupted.
+     *
+     * @example
+     * button.onUnavailable((event) => {
+     *   console.log('Wallet not available:', event.data.reason);
+     * });
+     *
+     * @param {OnUnavailableCallback} handler - Function to be called when the wallet is not available in the current context.
+     */
+  }, {
+    key: "onUnavailable",
+    value: function onUnavailable(handler) {
+      var _this3 = this;
+      if (typeof handler === 'function') {
+        this.eventEmitter.subscribe(EVENT$2.UNAVAILABLE, function (data) {
+          return __awaiter(_this3, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee3() {
+            var _t4;
+            return _regenerator().w(function (_context3) {
+              while (1) switch (_context3.p = _context3.n) {
+                case 0:
+                  _context3.p = 0;
+                  _context3.n = 1;
+                  return handler(data);
+                case 1:
+                  _context3.n = 3;
+                  break;
+                case 2:
+                  _context3.p = 2;
+                  _t4 = _context3.v;
+                  console.warn('Merchant onUnavailable handler threw (swallowed):', _t4);
+                case 3:
+                  return _context3.a(2);
+              }
+            }, _callee3, null, [[0, 2]]);
+          }));
+        });
+        return;
+      }
+      this.handleOnError(new Error('onUnavailable event handler is required.'), exports.ERROR_OPERATION.HANDLER_REGISTRATION);
+    }
+    /**
+     * Callback for onError method.
+     *
+     * @callback OnErrorCallback
+     * @param {OnErrorEventData} data - The error event data including the Error object and context.
+     */
+    /**
+     * Registers a callback function to be invoked when an error occurs during wallet operation.
+     * This includes configuration issues, validation errors, and OTT creation failures.
+     * Both synchronous and asynchronous (async) handlers are supported.
+     *
+     * **Error handling:** If the handler throws (sync or async), the error is logged and swallowed
+     * so that internal processing continues uninterrupted.
+     *
+     * @example
+     * button.onError((event) => {
+     *   console.error('Wallet error:', event.data.error.message);
+     *   console.log('Context:', event.data.context);
+     * });
+     *
+     * @param {OnErrorCallback} handler - Function to be called when the wallet has an error.
+     */
+  }, {
+    key: "onError",
+    value: function onError(handler) {
+      var _this4 = this;
+      if (typeof handler === 'function') {
+        this.eventEmitter.subscribe(EVENT$2.ERROR, function (data) {
+          return __awaiter(_this4, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee4() {
+            var _t5;
+            return _regenerator().w(function (_context4) {
+              while (1) switch (_context4.p = _context4.n) {
+                case 0:
+                  _context4.p = 0;
+                  _context4.n = 1;
+                  return handler(data);
+                case 1:
+                  _context4.n = 3;
+                  break;
+                case 2:
+                  _context4.p = 2;
+                  _t5 = _context4.v;
+                  console.warn('Merchant onError handler threw (swallowed):', _t5);
+                case 3:
+                  return _context4.a(2);
+              }
+            }, _callee4, null, [[0, 2]]);
+          }));
+        });
+        return;
+      }
+      this.handleOnError(new Error('onError event handler is required.'), exports.ERROR_OPERATION.HANDLER_REGISTRATION);
+    }
+    /**
+     * Callback for onCancel method.
+     *
+     * @callback OnCancelCallback
+     * @param {OnCancelEventData} data - Data associated with the cancellation event.
+     */
+    /**
+     * Registers a callback function to be invoked when the wallet checkout is cancelled or closed by the user.
+     * This event is triggered when the user dismisses the wallet payment interface without completing the transaction.
+     * Both synchronous and asynchronous (async) handlers are supported.
+     *
+     * **Error handling:** If the handler throws (sync or async), the error is logged and swallowed
+     * so that internal processing continues uninterrupted.
+     *
+     * @example
+     * button.onCancel((event) => {
+     *   console.log('Wallet checkout cancelled', event);
+     * });
+     *
+     * @param {OnCancelCallback} handler - Function to be called when the wallet checkout is cancelled.
+     */
+  }, {
+    key: "onCancel",
+    value: function onCancel(handler) {
+      var _this5 = this;
+      if (typeof handler === 'function') {
+        this.eventEmitter.subscribe(EVENT$2.CHECKOUT_CLOSE, function (data) {
+          return __awaiter(_this5, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee5() {
+            var _t6;
+            return _regenerator().w(function (_context5) {
+              while (1) switch (_context5.p = _context5.n) {
+                case 0:
+                  _context5.p = 0;
+                  _context5.n = 1;
+                  return handler(data);
+                case 1:
+                  _context5.n = 3;
+                  break;
+                case 2:
+                  _context5.p = 2;
+                  _t6 = _context5.v;
+                  console.warn('Merchant onCancel handler threw (swallowed):', _t6);
+                case 3:
+                  return _context5.a(2);
+              }
+            }, _callee5, null, [[0, 2]]);
+          }));
+        });
+        return;
+      }
+      this.handleOnError(new Error('onCancel event handler is required.'), exports.ERROR_OPERATION.HANDLER_REGISTRATION);
+    }
+    /**
+     * Registers a callback function to be invoked when the wallet button has been loaded and rendered in the DOM.
+     * Both synchronous and asynchronous (async) handlers are supported.
+     *
+     * **Error handling:** If the handler throws (sync or async), the error is logged and swallowed
+     * so that internal processing continues uninterrupted.
+     *
+     * @example
+     * button.onLoaded((event) => {
+     *   console.log('Wallet button loaded');
+     * });
+     *
+     * @param {Function} handler - Function to be called when the wallet button is loaded.
+     */
+  }, {
+    key: "onLoaded",
+    value: function onLoaded(handler) {
+      var _this6 = this;
+      if (typeof handler === 'function') {
+        this.eventEmitter.subscribe(EVENT$2.LOADED, function (data) {
+          return __awaiter(_this6, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee6() {
+            var _t7;
+            return _regenerator().w(function (_context6) {
+              while (1) switch (_context6.p = _context6.n) {
+                case 0:
+                  _context6.p = 0;
+                  _context6.n = 1;
+                  return handler(data);
+                case 1:
+                  _context6.n = 3;
+                  break;
+                case 2:
+                  _context6.p = 2;
+                  _t7 = _context6.v;
+                  console.warn('Merchant onLoaded handler threw (swallowed):', _t7);
+                case 3:
+                  return _context6.a(2);
+              }
+            }, _callee6, null, [[0, 2]]);
+          }));
+        });
+        return;
+      }
+      this.handleOnError(new Error('onLoaded event handler is required.'), exports.ERROR_OPERATION.HANDLER_REGISTRATION);
+    }
+    /**
+     * Callback for onShippingAddressChange method.
+     *
+     * @callback OnShippingAddressChangeCallback
+     * @param {OnShippingAddressChangeEventData} data - The shipping address data from the wallet.
+     * @returns {OnShippingAddressChangeEventResponse | Promise<OnShippingAddressChangeEventResponse>} Address update result containing updated amount, shipping options, and optional error.
+     */
+    /**
+     * Registers a callback for when the customer selects or updates their shipping address.
+     * Use this method to listen for shipping address selection or input from customer when shipping is enabled.
+     * The event handler should return updated payment information including the new amount and
+     * available shipping options based on the selected address.
+     * Both synchronous and asynchronous (async) handlers are supported.
+     *
+     * In case of an address validation error, include the `error` field in the response
+     * to display an appropriate error in the wallet payment sheet.
+     *
+     * @example
+     * // Async handler
+     * button.onShippingAddressChange(async (data) => {
+     *   const response = await fetch('https://your-server.com/update-shipping-address', {
+     *     method: 'POST',
+     *     body: JSON.stringify(data),
+     *   });
+     *   const result = await response.json();
+     *   return {
+     *     amount: result.newAmount,
+     *     shipping_options: result.availableShippingOptions,
+     *   };
+     * });
+     *
+     * @example
+     * // Sync handler
+     * button.onShippingAddressChange((data) => {
+     *   return {
+     *     amount: calculateShipping(data.data.address_country),
+     *     shipping_options: getOptionsForCountry(data.data.address_country),
+     *   };
+     * });
+     *
+     * @param {OnShippingAddressChangeCallback} handler - Function to be called when the shipping address data is updated.
+     */
+  }, {
+    key: "onShippingAddressChange",
+    value: function onShippingAddressChange(handler) {
+      if (typeof handler === 'function') {
+        return this.eventEmitter.subscribe(EVENT$2.ON_SHIPPING_ADDRESS_CHANGE, handler);
+      }
+      this.handleOnError(new Error('onShippingAddressChange event handler is required.'), exports.ERROR_OPERATION.HANDLER_REGISTRATION);
+    }
+    /**
+     * Callback for onShippingOptionsChange method.
+     *
+     * @callback OnShippingOptionsChangeCallback
+     * @param {OnShippingOptionChangeEventData} data - The selected shipping option data.
+     * @returns {OnShippingOptionChangeEventResponse | Promise<OnShippingOptionChangeEventResponse>} Shipping options update result containing the updated amount.
+     */
+    /**
+     * Registers a callback for when the customer selects a shipping option.
+     * Use this method to listen for shipping option selection from customer when shipping is enabled.
+     * The event handler should return the updated payment amount based on the selected shipping option.
+     * Both synchronous and asynchronous (async) handlers are supported.
+     *
+     * @example
+     * // Async handler
+     * button.onShippingOptionsChange(async (data) => {
+     *   const response = await fetch('https://your-server.com/update-shipping-option', {
+     *     method: 'POST',
+     *     body: JSON.stringify({ shipping_option_id: data.data.shipping_option_id }),
+     *   });
+     *   const result = await response.json();
+     *   return {
+     *     amount: result.newTotalAmount,
+     *   };
+     * });
+     *
+     * @example
+     * // Sync handler
+     * button.onShippingOptionsChange((data) => {
+     *   return {
+     *     amount: lookupShippingCost(data.data.shipping_option_id),
+     *   };
+     * });
+     *
+     * @param {OnShippingOptionsChangeCallback} handler - Function to be called when the shipping options data is updated.
+     */
+  }, {
+    key: "onShippingOptionsChange",
+    value: function onShippingOptionsChange(handler) {
+      if (typeof handler === 'function') {
+        this.onShippingOptionsChangeHandlerRegistered = true;
+        return this.eventEmitter.subscribe(EVENT$2.ON_SHIPPING_OPTIONS_CHANGE, handler);
+      }
+      this.handleOnError(new Error('onShippingOptionsChange event handler is required.'), exports.ERROR_OPERATION.HANDLER_REGISTRATION);
+    }
+    /**
+     * Whether a shipping options change handler has been registered.
+     * Used internally by wallet services to validate shipping configuration.
+     *
+     * @private
+     * @returns {boolean} `true` if an `onShippingOptionsChange` handler has been registered.
+     */
+  }, {
+    key: "isShippingOptionsChangeHandlerRegistered",
+    get: function get() {
+      return this.onShippingOptionsChangeHandlerRegistered;
+    }
+  }]);
+}();
+
 var PAYLOAD_FORMAT;
 (function (PAYLOAD_FORMAT) {
   PAYLOAD_FORMAT["ENCRYPTED_STRING"] = "encrypted_string";
@@ -18813,7 +19466,48 @@ var SERVICE_GROUP;
   SERVICE_GROUP["WALLET"] = "wallet";
 })(SERVICE_GROUP || (SERVICE_GROUP = {}));
 
+/**
+ * Recursively removes properties with `undefined` or `null` values from an object.
+ * Returns `undefined` if the resulting object has no remaining properties.
+ */
+function stripEmpty(obj) {
+  if (!obj || _typeof$1(obj) !== 'object') return undefined;
+  var result = {};
+  for (var _i = 0, _Object$entries = Object.entries(obj); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    if (value != null) {
+      if (_typeof$1(value) === 'object' && !Array.isArray(value)) {
+        var nested = stripEmpty(value);
+        if (nested !== undefined) {
+          result[key] = nested;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+/**
+ * Abstract base class for wallet-specific OpenWallet service implementations.
+ *
+ * Provides shared functionality for OTT creation, shipping event handling,
+ * error/unavailable emission, and DOM cleanup. Concrete implementations
+ * (e.g. Apple Pay, Google Pay) extend this class and implement {@link load} and {@link setMeta}.
+ *
+ * @implements {IOpenWalletProvider}
+ */
 var OpenWalletService = /*#__PURE__*/function () {
+  /**
+   * @param api - API client for backend communication.
+   * @param eventEmitter - Shared event emitter for wallet lifecycle events.
+   * @param walletType - The wallet type identifier (e.g. `'apple'`, `'google'`).
+   * @param serviceId - The service ID for the wallet configuration.
+   * @param container - The DOM container that holds the wallet button.
+   * @param serviceType - The service type from the API configuration.
+   */
   function OpenWalletService(api, eventEmitter, walletType, serviceId, container, serviceType) {
     _classCallCheck(this, OpenWalletService);
     this.api = api;
@@ -18822,8 +19516,16 @@ var OpenWalletService = /*#__PURE__*/function () {
     this.serviceId = serviceId;
     this.container = container;
     this.serviceType = serviceType;
+    /** The service group identifier used in OTT creation requests. */
     this.serviceGroup = SERVICE_GROUP.WALLET;
   }
+  /**
+   * Creates a One-Time Token (OTT) by sending the payment data to the API.
+   * Emits {@link EVENT.SUCCESS} on success or {@link EVENT.ERROR} on failure.
+   *
+   * @param data - The payment data including amount, shipping, billing, card info, and ref token.
+   * @returns A promise resolving to the OTT response.
+   */
   return _createClass(OpenWalletService, [{
     key: "createOTT",
     value: function createOTT(data) {
@@ -18846,11 +19548,18 @@ var OpenWalletService = /*#__PURE__*/function () {
         payload_format: PAYLOAD_FORMAT.ENCRYPTED_STRING
       };
       return this.api.paymentSource().createOTT(requestData).then(function (response) {
+        var cleanShipping = stripEmpty(shipping);
+        var cleanBilling = stripEmpty(billing);
         _this.eventEmitter.emit(EVENT$2.SUCCESS, {
-          token: response,
-          amount: amount,
-          shipping: shipping,
-          billing: billing
+          event: EVENT$2.SUCCESS,
+          data: _extends(_extends({
+            token: response,
+            amount: amount
+          }, cleanShipping && {
+            shipping: cleanShipping
+          }), cleanBilling && {
+            billing: cleanBilling
+          })
         });
         return response;
       })["catch"](function (err) {
@@ -18865,6 +19574,14 @@ var OpenWalletService = /*#__PURE__*/function () {
         throw err;
       });
     }
+    /**
+     * Delegates a shipping change event to the merchant's registered handler
+     * and returns the merchant's response.
+     *
+     * @param eventData - The shipping address or option change event data.
+     * @returns A promise resolving to the merchant's shipping update response.
+     * @throws {Error} If no handler is registered or the handler returns no result.
+     */
   }, {
     key: "handleMerchantOnShippingChangedEvent",
     value: function handleMerchantOnShippingChangedEvent(eventData) {
@@ -18876,7 +19593,7 @@ var OpenWalletService = /*#__PURE__*/function () {
               return _context.a(2, this.eventEmitter.emitWithResult(eventData.event, eventData).then(function (result) {
                 if (!result || result.length === 0) {
                   var error = new Error('No result from shippingUpdate event');
-                  _this2.handleOnError(error);
+                  _this2.handleOnError(error, exports.ERROR_OPERATION.SHIPPING_UPDATE);
                   throw error;
                 }
                 return result[0];
@@ -18885,40 +19602,60 @@ var OpenWalletService = /*#__PURE__*/function () {
         }, _callee, this);
       }));
     }
+    /**
+     * Emits the {@link EVENT.UNAVAILABLE} event when the wallet is not available.
+     *
+     * @param reason - A human-readable description of why the wallet is unavailable.
+     */
   }, {
     key: "handleOnUnavailable",
     value: function handleOnUnavailable() {
       var reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Wallet not available';
       var unavailableData = {
-        wallet_type: this.walletType,
-        reason: reason,
-        details: {
-          service_id: this.serviceId
+        event: EVENT$2.UNAVAILABLE,
+        data: {
+          reason: reason,
+          details: {
+            service_id: this.serviceId
+          }
         }
       };
       this.eventEmitter.emit(EVENT$2.UNAVAILABLE, unavailableData);
     }
+    /**
+     * Emits the {@link EVENT.ERROR} event and logs the error to the console.
+     *
+     * @param error - The error that occurred.
+     * @param operation - The operation that failed. Defaults to {@link ERROR_OPERATION.WALLET_OPERATION}.
+     */
   }, {
     key: "handleOnError",
     value: function handleOnError(error) {
-      var errorData = {
-        error: error,
-        context: {
-          operation: 'wallet_operation',
-          wallet_type: this.walletType
-        }
-      };
+      var operation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : exports.ERROR_OPERATION.WALLET_OPERATION;
       if (error) {
         console.error('Wallet operation error:', error);
       }
+      var errorData = {
+        event: EVENT$2.ERROR,
+        data: {
+          error: error,
+          context: {
+            operation: operation
+          }
+        }
+      };
       this.eventEmitter.emit(EVENT$2.ERROR, errorData);
     }
+    /**
+     * Removes the wallet button element from the DOM.
+     * Call this to clean up resources when the button is no longer needed.
+     */
   }, {
     key: "destroy",
     value: function destroy() {
       var element = this.container.getElement();
-      if (element === null || element === void 0 ? void 0 : element.parentNode) {
-        element.parentNode.removeChild(element);
+      if (element) {
+        element.innerHTML = '';
       }
     }
   }]);
@@ -18931,7 +19668,24 @@ exports.WALLET_TYPES = void 0;
 })(exports.WALLET_TYPES || (exports.WALLET_TYPES = {}));
 
 var DEFAULT_APPLE_PAY_CAPABILITIES$1 = ['paymentCredentialsAvailable'];
+/**
+ * Apple Pay implementation of the OpenWallet service.
+ *
+ * Handles loading the Apple Pay SDK, checking device/browser availability,
+ * rendering the Apple Pay button, and managing the full Apple Pay payment session
+ * lifecycle including merchant validation, payment authorization, and shipping updates.
+ *
+ * @extends OpenWalletService
+ */
 var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
+  /**
+   * @param api - API client for backend communication.
+   * @param eventEmitter - Shared event emitter for wallet lifecycle events.
+   * @param serviceId - The service ID for the Apple Pay configuration.
+   * @param container - The DOM container that will hold the Apple Pay button.
+   * @param meta - Apple Pay-specific metadata (amount, currency, shipping config, etc.).
+   * @param serviceConfig - The service configuration response from the API.
+   */
   function ApplePayOpenWalletService(api, eventEmitter, serviceId, container, meta, serviceConfig) {
     var _this;
     _classCallCheck(this, ApplePayOpenWalletService);
@@ -18940,7 +19694,9 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
     _this.serviceConfig = serviceConfig;
     _this.latestShippingData = {};
     _this.onCancelPayment = function () {
-      return _this.eventEmitter.emit(EVENT$2.CHECKOUT_CLOSE);
+      return _this.eventEmitter.emit(EVENT$2.CHECKOUT_CLOSE, {
+        event: EVENT$2.CHECKOUT_CLOSE
+      });
     };
     _this.onValidateMerchant = function () {
       _this.handleMerchantOnButtonClickEvent().then(function () {
@@ -18954,7 +19710,7 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
       });
     };
     _this.onPaymentAuthorized = function (event) {
-      var _a;
+      var _a, _b, _c, _d, _e;
       var _event$payment = event.payment,
         token = _event$payment.token,
         billingContact = _event$payment.billingContact,
@@ -18966,8 +19722,8 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
       }), _this.hasShippingOptions() && {
         options: _this.meta.shipping_options
       }), {
-        address_line1: shippingContact === null || shippingContact === void 0 ? void 0 : shippingContact.addressLines[0],
-        address_line2: shippingContact === null || shippingContact === void 0 ? void 0 : shippingContact.addressLines[1],
+        address_line1: (_b = shippingContact === null || shippingContact === void 0 ? void 0 : shippingContact.addressLines) === null || _b === void 0 ? void 0 : _b[0],
+        address_line2: (_c = shippingContact === null || shippingContact === void 0 ? void 0 : shippingContact.addressLines) === null || _c === void 0 ? void 0 : _c[1],
         address_country: shippingContact === null || shippingContact === void 0 ? void 0 : shippingContact.countryCode,
         address_city: shippingContact === null || shippingContact === void 0 ? void 0 : shippingContact.locality,
         address_postcode: shippingContact === null || shippingContact === void 0 ? void 0 : shippingContact.postalCode,
@@ -18980,8 +19736,8 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
         }
       });
       var billing = {
-        address_line1: billingContact === null || billingContact === void 0 ? void 0 : billingContact.addressLines[0],
-        address_line2: billingContact === null || billingContact === void 0 ? void 0 : billingContact.addressLines[1],
+        address_line1: (_d = billingContact === null || billingContact === void 0 ? void 0 : billingContact.addressLines) === null || _d === void 0 ? void 0 : _d[0],
+        address_line2: (_e = billingContact === null || billingContact === void 0 ? void 0 : billingContact.addressLines) === null || _e === void 0 ? void 0 : _e[1],
         address_country: billingContact === null || billingContact === void 0 ? void 0 : billingContact.countryCode,
         address_city: billingContact === null || billingContact === void 0 ? void 0 : billingContact.locality,
         address_postcode: billingContact === null || billingContact === void 0 ? void 0 : billingContact.postalCode,
@@ -19022,22 +19778,39 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
                 event: EVENT$2.ON_SHIPPING_ADDRESS_CHANGE,
                 data: this.parseShippingContactUpdateEvent(data)
               }).then(function (response) {
-                var _a;
+                var _a, _b;
                 var mappedNewShippingMethods = [];
-                if (((_a = response === null || response === void 0 ? void 0 : response.shipping_options) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                  _this2.meta.shipping_options = response.shipping_options;
-                  _this2.selectedShippingOption = response.shipping_options[0];
+                var errors = [];
+                if ((_a = response === null || response === void 0 ? void 0 : response.error) === null || _a === void 0 ? void 0 : _a.code) {
+                  errors.push(_this2.formatErrorFields(response.error));
+                }
+                if (((_b = response === null || response === void 0 ? void 0 : response.shipping_options) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                  var appleShippingOptions = response.shipping_options;
+                  _this2.meta.shipping_options = appleShippingOptions;
+                  _this2.selectedShippingOption = appleShippingOptions[0];
                   _this2.latestShippingData.shippingMethod = _this2.formatShippingOptions([_this2.selectedShippingOption])[0];
-                  mappedNewShippingMethods = _this2.parseShippingMethod(response.shipping_options);
+                  mappedNewShippingMethods = _this2.parseShippingMethod(appleShippingOptions);
+                }
+                if (response.amount !== undefined) {
+                  _this2.meta.amount = response.amount;
                 }
-                _this2.meta.amount = response.amount;
                 _this2.paymentSession.completeShippingContactSelection({
                   newTotal: {
                     label: _this2.meta.amount_label,
-                    amount: String(response.amount),
+                    amount: String(_this2.meta.amount),
                     type: 'final'
                   },
-                  newShippingMethods: mappedNewShippingMethods
+                  newShippingMethods: mappedNewShippingMethods,
+                  errors: errors
+                });
+              })["catch"](function () {
+                // No handler registered or handler threw — auto-accept with current data
+                _this2.paymentSession.completeShippingContactSelection({
+                  newTotal: {
+                    label: _this2.meta.amount_label,
+                    amount: String(_this2.meta.amount),
+                    type: 'final'
+                  }
                 });
               }));
           }
@@ -19054,11 +19827,36 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
                 event: EVENT$2.ON_SHIPPING_OPTIONS_CHANGE,
                 data: this.parseShippingMethodUpdateEvent(data)
               }).then(function (response) {
-                _this3.meta.amount = response.amount;
+                var _a;
+                if ((_a = response === null || response === void 0 ? void 0 : response.error) === null || _a === void 0 ? void 0 : _a.code) {
+                  // Apple Pay's completeShippingMethodSelection does not support errors,
+                  // so emit the error to the merchant and complete with current data.
+                  _this3.handleOnError(new Error(response.error.message || 'Shipping method update error'), exports.ERROR_OPERATION.SHIPPING_UPDATE);
+                  _this3.paymentSession.completeShippingMethodSelection({
+                    newTotal: {
+                      label: _this3.meta.amount_label,
+                      amount: String(_this3.meta.amount),
+                      type: 'final'
+                    }
+                  });
+                  return;
+                }
+                if (response.amount !== undefined) {
+                  _this3.meta.amount = response.amount;
+                }
+                _this3.paymentSession.completeShippingMethodSelection({
+                  newTotal: {
+                    label: _this3.meta.amount_label,
+                    amount: String(_this3.meta.amount),
+                    type: 'final'
+                  }
+                });
+              })["catch"](function () {
+                // No handler registered or handler threw — auto-accept with current data
                 _this3.paymentSession.completeShippingMethodSelection({
                   newTotal: {
                     label: _this3.meta.amount_label,
-                    amount: String(response.amount),
+                    amount: String(_this3.meta.amount),
                     type: 'final'
                   }
                 });
@@ -19072,6 +19870,12 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
   }
   _inherits(ApplePayOpenWalletService, _OpenWalletService);
   return _createClass(ApplePayOpenWalletService, [{
+    key: "setMeta",
+    value: function setMeta(meta) {
+      this.meta = _extends(_extends({}, this.meta), meta);
+      this.adaptMeta();
+    }
+  }, {
     key: "adaptMeta",
     value: function adaptMeta() {
       var _a;
@@ -19116,12 +19920,11 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
   }, {
     key: "getMetaStyles",
     value: function getMetaStyles() {
-      var _a, _b, _c;
+      var _a, _b;
       if (((_a = this.meta) === null || _a === void 0 ? void 0 : _a.style) && _typeof$1((_b = this.meta) === null || _b === void 0 ? void 0 : _b.style) === 'object') {
-        var metaStyles = JSON.parse(JSON.stringify((_c = this.meta) === null || _c === void 0 ? void 0 : _c.style));
-        return metaStyles;
+        return JSON.parse(JSON.stringify(this.meta.style));
       }
-      return null;
+      return undefined;
     }
   }, {
     key: "isShippingRequired",
@@ -19199,10 +20002,10 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
     key: "checkAvailability",
     value: function checkAvailability() {
       var _this6 = this;
-      return new Promise(function (resolve, _reject) {
+      return new Promise(function (resolve) {
         var _a;
         if (!window.ApplePaySession || !ApplePaySession) {
-          resolve(false);
+          return resolve(false);
         }
         var formattedCapabilities = DEFAULT_APPLE_PAY_CAPABILITIES$1;
         if (((_a = _this6.meta.apple_pay_capabilities) === null || _a === void 0 ? void 0 : _a.length) > 0) {
@@ -19211,7 +20014,7 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
         ApplePaySession.applePayCapabilities(_this6.getMerchantId()).then(function (capabilities) {
           var canMakePayment = formattedCapabilities.includes(capabilities === null || capabilities === void 0 ? void 0 : capabilities.paymentCredentialStatus);
           resolve(canMakePayment);
-        })["catch"](function (_err) {
+        })["catch"](function () {
           resolve(false);
         });
       });
@@ -19234,7 +20037,7 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
       }
       applePayButton.addEventListener('click', this.onApplePayButtonClicked.bind(this));
       this.eventEmitter.emit(EVENT$2.LOADED, {
-        wallet: exports.WALLET_TYPES.APPLE_PAY
+        event: EVENT$2.LOADED
       });
     }
   }, {
@@ -19253,11 +20056,10 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
     value: function getMerchantSession() {
       var _this7 = this;
       return new Promise(function (resolve, reject) {
-        var _a;
         return _this7.api.paymentSource().createSession(_extends({
           service_id: _this7.serviceId,
           session_id: window.location.hostname,
-          store_name: (_a = _this7.meta.store_name) !== null && _a !== void 0 ? _a : ''
+          store_name: _this7.meta.store_name
         }, _this7.isShippingRequired() && {
           request_shipping: _this7.meta.request_shipping
         })).then(function (res) {
@@ -19270,24 +20072,29 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
   }, {
     key: "handleMerchantOnButtonClickEvent",
     value: function handleMerchantOnButtonClickEvent() {
-      var _this8 = this;
-      return new Promise(function (resolve, reject) {
-        var merchantResult;
-        _this8.eventEmitter.emit(EVENT$2.ON_CLICK, {
-          attachResult: function attachResult(value) {
-            merchantResult = value;
-          }
-        });
-        if (merchantResult instanceof Promise) {
-          merchantResult.then(resolve)["catch"](reject);
-        } else {
-          if (merchantResult === false) {
-            reject();
-          } else {
-            resolve();
+      return __awaiter(this, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee4() {
+        var results;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              _context4.n = 1;
+              return this.eventEmitter.emitWithResult(EVENT$2.ON_CLICK, {
+                event: EVENT$2.ON_CLICK
+              });
+            case 1:
+              results = _context4.v;
+              if (!results.some(function (r) {
+                return r === false;
+              })) {
+                _context4.n = 2;
+                break;
+              }
+              throw new Error('onClick handler aborted the payment flow');
+            case 2:
+              return _context4.a(2);
           }
-        }
-      });
+        }, _callee4, this);
+      }));
     }
   }, {
     key: "formatCapabilities",
@@ -19301,6 +20108,29 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
         return fieldMap[capability] || capability;
       });
     }
+  }, {
+    key: "formatErrorFields",
+    value: function formatErrorFields(error) {
+      var fieldMap = {
+        phone: 'phoneNumber',
+        email: 'emailAddress',
+        phonetic_name: 'phoneticName',
+        address_lines: 'addressLines',
+        address_city: 'locality',
+        address_postcode: 'postalCode',
+        address_state: 'administrativeArea',
+        address_country: 'country',
+        address_country_code: 'countryCode'
+      };
+      var contactField = fieldMap[error.field] || error.field;
+      var codeMap = {
+        address_error: 'addressUnserviceable',
+        shipping_contact_invalid: 'shippingContactInvalid',
+        billing_contact_invalid: 'billingContactInvalid'
+      };
+      var code = codeMap[error.code] || 'unknown';
+      return new ApplePayError(code, contactField, error.message);
+    }
   }, {
     key: "createButtonStyle",
     value: function createButtonStyle() {
@@ -19447,19 +20277,139 @@ var ApplePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
   }]);
 }(OpenWalletService);
 
+/**
+ * @classdesc Apple Pay wallet button that creates One-Time Tokens (OTT) via Apple Pay.
+ *
+ * Provides a fully typed Apple Pay integration with Apple Pay-specific metadata
+ * and validates that the service configuration corresponds to an Apple Pay service.
+ * On `load()`, the button fetches the service configuration and raises an error via `onError`
+ * if the service type does not match Apple Pay.
+ *
+ * @class ApplePayOpenWalletButton
+ * @extends OpenWalletButtons
+ *
+ * @param {string} selector - CSS selector of the HTML element that will contain the Apple Pay button.
+ * @param {string} publicKeyOrAccessToken - Public key or access token for API authentication.
+ * @param {string} serviceId - The Apple Pay service ID configured in PayDock dashboard.
+ * @param {ApplePayOpenWalletMeta} meta - Apple Pay-specific metadata (amount, currency, country, amount_label, store_name, style, apple_pay_capabilities, etc.).
+ *
+ * @example
+ * const button = new ApplePayOpenWalletButton(
+ *   '#wallet-container',
+ *   publicKeyOrAccessToken,
+ *   serviceId,
+ *   {
+ *     amount: 100,
+ *     currency: 'AUD',
+ *     country: 'AU',
+ *     amount_label: 'TOTAL',
+ *     store_name: 'My Store',
+ *     apple_pay_capabilities: ['credentials_available'],
+ *   },
+ * );
+ * button.setEnv('sandbox');
+ * button.onSuccess((data) => console.log('OTT:', data.token));
+ * button.onError((error) => console.error('Error:', error));
+ * button.load();
+ */
+var ApplePayOpenWalletButton = /*#__PURE__*/function (_OpenWalletButtons) {
+  function ApplePayOpenWalletButton() {
+    var _this;
+    _classCallCheck(this, ApplePayOpenWalletButton);
+    _this = _callSuper(this, ApplePayOpenWalletButton, arguments);
+    /** @private */
+    _this.walletType = exports.WALLET_TYPES.APPLE_PAY;
+    return _this;
+  }
+  /**
+   * Validates Apple Pay-specific required metadata fields.
+   * Apple Pay requires `amount_label` and `store_name` to be present and strings.
+   *
+   * @private
+   * @throws {Error} If `amount_label` is missing or not a string.
+   * @throws {Error} If `store_name` is missing or not a string.
+   */
+  _inherits(ApplePayOpenWalletButton, _OpenWalletButtons);
+  return _createClass(ApplePayOpenWalletButton, [{
+    key: "validateWalletMeta",
+    value: function validateWalletMeta() {
+      if (typeof this.meta.amount_label !== 'string' || this.meta.amount_label.trim() === '') {
+        throw new Error("meta.amount_label is required for Apple Pay and must be a non-empty string (e.g. 'TOTAL').");
+      }
+      if (typeof this.meta.store_name !== 'string' || this.meta.store_name.trim() === '') {
+        throw new Error('meta.store_name is required for Apple Pay and must be a non-empty string.');
+      }
+    }
+    /**
+     * Validates that the service configuration type is Apple Pay.
+     *
+     * @private
+     * @param serviceConfig - The service configuration response from the API.
+     * @throws {Error} If the service type is not Apple Pay.
+     */
+  }, {
+    key: "validateServiceType",
+    value: function validateServiceType(serviceConfig) {
+      if (serviceConfig.type !== SERVICE_TYPES.APPLE_PAY) {
+        throw new Error("Service configuration type '".concat(serviceConfig.type, "' does not match expected wallet type '").concat(exports.WALLET_TYPES.APPLE_PAY, "'. ") + "Ensure the service ID '".concat(this.serviceId, "' corresponds to an Apple Pay service."));
+      }
+    }
+    /**
+     * Creates an Apple Pay wallet service instance.
+     *
+     * @private
+     * @param serviceConfig - The service configuration response from the API.
+     * @returns The Apple Pay wallet service instance.
+     */
+  }, {
+    key: "createWalletService",
+    value: function createWalletService(serviceConfig) {
+      return new ApplePayOpenWalletService(this.api, this.eventEmitter, this.serviceId, this.container, this.meta, serviceConfig);
+    }
+  }]);
+}(OpenWalletButtons);
+
+/**
+ * Token types returned in the OTT (One-Time Token) creation response.
+ */
+exports.TOKEN_TYPE = void 0;
+(function (TOKEN_TYPE) {
+  /** FPAN - Funding Primary Account Number (Google Pay only). */
+  TOKEN_TYPE["CARD"] = "card";
+  /** DPAN - Device Primary Account Number (Apple Pay & Google Pay). */
+  TOKEN_TYPE["CARD_SCHEME_TOKEN"] = "card_scheme_token";
+})(exports.TOKEN_TYPE || (exports.TOKEN_TYPE = {}));
+
+/** URL for the Google Pay JavaScript SDK. */
 var GOOGLE_PAY_SCRIPT_URL = 'https://pay.google.com/gp/p/js/pay.js';
+/** The default gateway identifier for Paydock. */
 var GOOGLE_PAY_GATEWAY = 'paydock';
+/** Google Pay API version configuration. */
 var GOOGLE_PAY_API_CONFIG = {
   apiVersion: 2,
   apiVersionMinor: 0
 };
+/** Default allowed authentication methods for Google Pay card payments. */
 var GOOGLE_PAY_AUTH_METHODS = ['PAN_ONLY', 'CRYPTOGRAM_3DS'];
+/** Default allowed card networks for Google Pay payments. */
 var GOOGLE_PAY_CARD_NETWORKS = ['AMEX', 'DISCOVER', 'INTERAC', 'JCB', 'MASTERCARD', 'VISA'];
-var GOOGLE_EVENT_TO_WALLET_EVENT = {
+/**
+ * Maps Google Pay callback triggers to OpenWallet event names.
+ * Used to translate shipping-related Google Pay events to the unified event system.
+ */
+({
   SHIPPING_ADDRESS: EVENT$2.ON_SHIPPING_ADDRESS_CHANGE,
   SHIPPING_OPTION: EVENT$2.ON_SHIPPING_OPTIONS_CHANGE
-};
+});
 
+/**
+ * Parses intermediate payment data from Google Pay into a normalized format
+ * for use in shipping address/option change events.
+ *
+ * @param data - The intermediate payment data from the Google Pay callback.
+ * @param meta - The current Google Pay wallet metadata.
+ * @returns Parsed shipping address and selected shipping option data.
+ */
 var parseUpdateData = function parseUpdateData(data, meta) {
   var _a, _b, _c, _d, _e;
   var shippingOption = (_a = meta === null || meta === void 0 ? void 0 : meta.shipping_options) === null || _a === void 0 ? void 0 : _a.find(function (o) {
@@ -19483,6 +20433,13 @@ var parseUpdateData = function parseUpdateData(data, meta) {
     }
   });
 };
+/**
+ * Converts an array of shipping options from the internal format
+ * to Google Pay's `SelectionOption` format.
+ *
+ * @param shipping_options - The shipping options in internal format.
+ * @returns An array of Google Pay selection options.
+ */
 var formatShippingOptions = function formatShippingOptions(shipping_options) {
   return shipping_options.map(function (option) {
     return {
@@ -19492,6 +20449,14 @@ var formatShippingOptions = function formatShippingOptions(shipping_options) {
     };
   });
 };
+/**
+ * Maps Google Pay payment data to the format required for OTT creation.
+ * Extracts billing/shipping addresses, card info, and the tokenization token.
+ *
+ * @param paymentData - The payment data from Google Pay's `onPaymentAuthorized` callback.
+ * @param meta - The current Google Pay wallet metadata.
+ * @returns The data required to create an OTT.
+ */
 var mapGooglePayData = function mapGooglePayData(paymentData, meta) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3;
   var billingAddressLine1 = (_c = (_b = (_a = paymentData.paymentMethodData) === null || _a === void 0 ? void 0 : _a.info) === null || _b === void 0 ? void 0 : _b.billingAddress) === null || _c === void 0 ? void 0 : _c.address1;
@@ -19531,6 +20496,37 @@ var mapGooglePayData = function mapGooglePayData(paymentData, meta) {
     ref_token: paymentData.paymentMethodData.tokenizationData.token
   };
 };
+/**
+ * Maps a Paydock-defined shipping error code to the corresponding
+ * Google Pay {@link google.payments.api.ErrorReason}.
+ *
+ * @param errorCode - The error code from the merchant's shipping change response.
+ * @returns The Google Pay error reason string.
+ */
+var mapShippingErrorCodeToGooglePayReason = function mapShippingErrorCodeToGooglePayReason(errorCode) {
+  switch (errorCode) {
+    case 'country_error':
+    case 'state_error':
+      return 'SHIPPING_ADDRESS_UNSERVICEABLE';
+    case 'address_error':
+    case 'zip_error':
+    case 'shipping_contact_invalid':
+      return 'SHIPPING_ADDRESS_INVALID';
+    case 'method_unavailable':
+    case 'store_unavailable':
+      return 'SHIPPING_OPTION_INVALID';
+    case 'billing_contact_invalid':
+    default:
+      return 'OTHER_ERROR';
+  }
+};
+/**
+ * Maps billing address parameters from internal snake_case format
+ * to Google Pay's camelCase format.
+ *
+ * @param billingAddressParams - The billing address parameters in internal format.
+ * @returns Google Pay billing address parameters, or `undefined` if input is falsy.
+ */
 var mapBillingAddressParameters = function mapBillingAddressParameters(billingAddressParams) {
   if (!billingAddressParams) {
     return undefined;
@@ -19541,6 +20537,13 @@ var mapBillingAddressParameters = function mapBillingAddressParameters(billingAd
     phoneNumberRequired: billingAddressParams.phone_number_required
   });
 };
+/**
+ * Maps card network parameters from internal snake_case format
+ * to Google Pay's camelCase format.
+ *
+ * @param cardNetworkParams - The card network parameters in internal format.
+ * @returns Google Pay card network parameters, or `undefined` if input is falsy.
+ */
 var mapCardNetworkParameters = function mapCardNetworkParameters(cardNetworkParams) {
   if (!cardNetworkParams) {
     return undefined;
@@ -19556,6 +20559,19 @@ var mapCardNetworkParameters = function mapCardNetworkParameters(cardNetworkPara
   });
 };
 
+/**
+ * Validates a Google Pay card configuration object.
+ *
+ * Checks that required fields are present and correctly structured:
+ * - `allowed_auth_methods` must be a non-empty array.
+ * - `allowed_card_networks` must be a non-empty array.
+ * - If a `tokenization_specification` is provided:
+ *   - `DIRECT` requires `protocol_version` and `public_key`.
+ *   - `PAYMENT_GATEWAY` requires non-empty `parameters`.
+ *
+ * @param cardConfig - The Google Pay card configuration to validate.
+ * @returns An array of human-readable error messages. Empty array means valid.
+ */
 var validateCardConfiguration = function validateCardConfiguration(cardConfig) {
   var errors = [];
   if (!cardConfig.parameters.allowed_auth_methods || cardConfig.parameters.allowed_auth_methods.length === 0) {
@@ -19582,7 +20598,24 @@ var validateCardConfiguration = function validateCardConfiguration(cardConfig) {
   return errors;
 };
 
+/**
+ * Google Pay implementation of the OpenWallet service.
+ *
+ * Handles loading the Google Pay SDK, checking device/browser availability,
+ * rendering the Google Pay button, and managing the full payment lifecycle
+ * including payment authorization, shipping address/option changes, and OTT creation.
+ *
+ * @extends OpenWalletService
+ */
 var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
+  /**
+   * @param api - API client for backend communication.
+   * @param eventEmitter - Shared event emitter for wallet lifecycle events.
+   * @param serviceId - The service ID for the Google Pay configuration.
+   * @param container - The DOM container that will hold the Google Pay button.
+   * @param meta - Google Pay-specific metadata (amount, currency, card config, etc.).
+   * @param serviceConfig - The service configuration response from the API.
+   */
   function GooglePayOpenWalletService(api, eventEmitter, serviceId, container, meta, serviceConfig) {
     var _this;
     _classCallCheck(this, GooglePayOpenWalletService);
@@ -19653,7 +20686,7 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
         googlePayJs.onload = function () {
           if (!window.google) {
             _this2.handleOnUnavailable('Google Pay not available');
-            reject();
+            reject(new Error('Google Pay not available'));
             return;
           }
           _this2.onScriptLoaded();
@@ -19661,7 +20694,7 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
         };
         googlePayJs.onerror = function () {
           _this2.handleOnUnavailable('Failed to load Google Pay script');
-          reject();
+          reject(new Error('Failed to load Google Pay script'));
         };
         document.head.appendChild(googlePayJs);
       });
@@ -19731,6 +20764,9 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
         buttonColor: ((_c = this.getMetaStyles()) === null || _c === void 0 ? void 0 : _c.button_color) || 'default'
       });
       button.appendChild(googlePayButton);
+      this.eventEmitter.emit(EVENT$2.LOADED, {
+        event: EVENT$2.LOADED
+      });
     }
   }, {
     key: "onGooglePayButtonClicked",
@@ -19752,51 +20788,55 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
   }, {
     key: "handleMerchantOnButtonClickEvent",
     value: function handleMerchantOnButtonClickEvent() {
-      var _this6 = this;
-      return new Promise(function (resolve, reject) {
-        var merchantResult;
-        _this6.eventEmitter.emit(EVENT$2.ON_CLICK, {
-          request_type: 'google_pay_button_click',
-          wallet_type: _this6.walletType,
-          meta: _this6.meta,
-          attachResult: function attachResult(value) {
-            merchantResult = value;
-          }
-        });
-        if (merchantResult instanceof Promise) {
-          merchantResult.then(resolve)["catch"](reject);
-        } else {
-          if (merchantResult === false) {
-            reject();
-          } else {
-            resolve();
+      return __awaiter(this, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee3() {
+        var results;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              _context3.n = 1;
+              return this.eventEmitter.emitWithResult(EVENT$2.ON_CLICK, {
+                event: EVENT$2.ON_CLICK
+              });
+            case 1:
+              results = _context3.v;
+              if (!results.some(function (r) {
+                return r === false;
+              })) {
+                _context3.n = 2;
+                break;
+              }
+              throw new Error('onClick handler aborted the payment flow');
+            case 2:
+              return _context3.a(2);
           }
-        }
-      });
+        }, _callee3, this);
+      }));
     }
   }, {
     key: "loadPaymentData",
     value: function loadPaymentData() {
-      return __awaiter(this, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee3() {
-        var _this7 = this;
-        return _regenerator().w(function (_context3) {
-          while (1) switch (_context3.n) {
+      return __awaiter(this, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee4() {
+        var _this6 = this;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
             case 0:
-              return _context3.a(2, this.paymentsClient.loadPaymentData(this.createPaymentDataRequest())["catch"](function (err) {
-                _this7.eventEmitter.emit(EVENT$2.ON_CHECKOUT_CLOSE);
-                _this7.processingButtonClick = false;
+              return _context4.a(2, this.paymentsClient.loadPaymentData(this.createPaymentDataRequest())["catch"](function (err) {
+                _this6.eventEmitter.emit(EVENT$2.CHECKOUT_CLOSE, {
+                  event: EVENT$2.CHECKOUT_CLOSE
+                });
+                _this6.processingButtonClick = false;
                 throw err;
               }));
           }
-        }, _callee3, this);
+        }, _callee4, this);
       }));
     }
   }, {
     key: "onPaymentAuthorized",
     value: function onPaymentAuthorized(paymentData) {
-      var _this8 = this;
+      var _this7 = this;
       var onPaymentAuthorizedResponse = new Promise(function (resolve) {
-        if (_this8.isProcessingAuthorization) {
+        if (_this7.isProcessingAuthorization) {
           console.warn('Duplicate payment authorization detected. Ignoring.');
           resolve({
             transactionState: 'ERROR',
@@ -19808,17 +20848,17 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
           });
           return;
         }
-        _this8.isProcessingAuthorization = true;
-        _this8.createOTT(mapGooglePayData(paymentData, _this8.meta)).then(function () {
-          _this8.processingButtonClick = false;
-          _this8.isProcessingAuthorization = false;
+        _this7.isProcessingAuthorization = true;
+        _this7.createOTT(mapGooglePayData(paymentData, _this7.meta)).then(function () {
+          _this7.processingButtonClick = false;
+          _this7.isProcessingAuthorization = false;
           resolve({
             transactionState: 'SUCCESS'
           });
         })["catch"](function (error) {
           var _a;
-          _this8.processingButtonClick = false;
-          _this8.isProcessingAuthorization = false;
+          _this7.processingButtonClick = false;
+          _this7.isProcessingAuthorization = false;
           resolve({
             transactionState: 'ERROR',
             error: {
@@ -19834,69 +20874,75 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
   }, {
     key: "onPaymentDataChanged",
     value: function onPaymentDataChanged(intermediatePaymentData) {
-      var _this9 = this;
-      var _a, _b, _c, _d, _e, _f, _g, _h;
+      var _this8 = this;
+      var _a, _b, _c;
       var returnPromise = new Promise(function (res, rej) {
-        _this9.latestShippingChangePromiseResolve = res;
-        _this9.latestShippingChangePromiseReject = rej;
+        _this8.latestShippingChangePromiseResolve = res;
+        _this8.latestShippingChangePromiseReject = rej;
       });
-      if (intermediatePaymentData.callbackTrigger === 'INITIALIZE') {
-        return Promise.resolve(_extends({
-          newTransactionInfo: {
-            totalPriceStatus: 'FINAL',
-            totalPriceLabel: this.meta.amount_label,
-            totalPrice: (_a = this.meta.amount) === null || _a === void 0 ? void 0 : _a.toString(),
-            currencyCode: (_b = this.meta.currency) === null || _b === void 0 ? void 0 : _b.toUpperCase(),
-            countryCode: (_c = this.meta.country) === null || _c === void 0 ? void 0 : _c.toUpperCase()
-          }
-        }, this.hasShippingOptions() && {
-          newShippingOptionParameters: {
-            defaultSelectedOptionId: (_e = (_d = this.meta.shipping_options) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.id,
-            shippingOptions: formatShippingOptions(this.meta.shipping_options)
-          }
-        }));
-      }
       var parsedUpdateData = parseUpdateData(intermediatePaymentData, this.meta);
       var eventData;
-      var eventType = GOOGLE_EVENT_TO_WALLET_EVENT[intermediatePaymentData.callbackTrigger];
-      if (eventType === EVENT$2.ON_SHIPPING_ADDRESS_CHANGE) {
+      var callbackIntent;
+      if (intermediatePaymentData.callbackTrigger === 'INITIALIZE' || intermediatePaymentData.callbackTrigger === 'SHIPPING_ADDRESS') {
+        callbackIntent = 'SHIPPING_ADDRESS';
         eventData = {
-          event: eventType,
+          event: EVENT$2.ON_SHIPPING_ADDRESS_CHANGE,
           data: parsedUpdateData.shipping
         };
-      } else if (eventType === EVENT$2.ON_SHIPPING_OPTIONS_CHANGE) {
+      } else if (intermediatePaymentData.callbackTrigger === 'SHIPPING_OPTION') {
+        callbackIntent = 'SHIPPING_OPTION';
         eventData = {
-          event: eventType,
+          event: EVENT$2.ON_SHIPPING_OPTIONS_CHANGE,
           data: {
-            shipping_option_id: (_f = parsedUpdateData.selected_shipping_option) === null || _f === void 0 ? void 0 : _f.id,
-            label: (_g = parsedUpdateData.selected_shipping_option) === null || _g === void 0 ? void 0 : _g.label,
-            detail: (_h = parsedUpdateData.selected_shipping_option) === null || _h === void 0 ? void 0 : _h.detail
+            shipping_option_id: (_a = parsedUpdateData.selected_shipping_option) === null || _a === void 0 ? void 0 : _a.id,
+            label: (_b = parsedUpdateData.selected_shipping_option) === null || _b === void 0 ? void 0 : _b.label,
+            detail: (_c = parsedUpdateData.selected_shipping_option) === null || _c === void 0 ? void 0 : _c.detail
           }
         };
       } else {
-        this.update({
-          success: false
-        });
+        // Unknown callback trigger — auto-accept with current data
+        this.autoAcceptWithCurrentData();
         return returnPromise;
       }
-      if (eventData) {
-        this.handleMerchantOnShippingChangedEvent(eventData).then(function (response) {
-          _this9.update({
-            success: true,
-            body: _extends({
-              amount: response.amount
-            }, 'shipping_options' in response && response.shipping_options && {
-              shipping_options: response.shipping_options
-            })
-          });
-        })["catch"](function () {
-          _this9.update({
-            success: false
+      this.handleMerchantOnShippingChangedEvent(eventData).then(function (response) {
+        var _a;
+        if ((_a = response === null || response === void 0 ? void 0 : response.error) === null || _a === void 0 ? void 0 : _a.code) {
+          _this8.update({
+            success: false,
+            error: {
+              reason: mapShippingErrorCodeToGooglePayReason(response.error.code),
+              message: response.error.message || 'Shipping update error',
+              intent: callbackIntent
+            }
           });
+          return;
+        }
+        _this8.update({
+          success: true,
+          body: _extends({
+            amount: response.amount
+          }, 'shipping_options' in response && response.shipping_options && {
+            shipping_options: response.shipping_options
+          })
         });
-      }
+      })["catch"](function () {
+        // No handler registered or handler threw — auto-accept with current data
+        _this8.autoAcceptWithCurrentData();
+      });
       return returnPromise;
     }
+  }, {
+    key: "autoAcceptWithCurrentData",
+    value: function autoAcceptWithCurrentData() {
+      this.update({
+        success: true,
+        body: _extends({
+          amount: this.meta.amount
+        }, this.hasShippingOptions() && {
+          shipping_options: this.meta.shipping_options
+        })
+      });
+    }
   }, {
     key: "createRequest",
     value: function createRequest() {
@@ -19990,9 +21036,7 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
       var validationErrors = validateCardConfiguration(cardConfig);
       if (validationErrors.length > 0) {
         var errorMessage = validationErrors.join(', ');
-        this.handleOnError({
-          message: errorMessage
-        });
+        this.handleOnError(new Error(errorMessage), exports.ERROR_OPERATION.CONFIGURATION);
       }
       var parameters = {
         allowedAuthMethods: cardConfig.parameters.allowed_auth_methods,
@@ -20035,7 +21079,7 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
           parameters: this.buildCardParameters(cardConfig)
         };
       } catch (error) {
-        console.error('Invalid Google Pay card configuration:', error.message);
+        console.error('Invalid Google Pay card configuration:', error instanceof Error ? error.message : error);
         console.warn('Falling back to default card configuration');
         return this.getDefaultCardConfiguration();
       }
@@ -20043,12 +21087,11 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
   }, {
     key: "getMetaStyles",
     value: function getMetaStyles() {
-      var _a, _b, _c;
+      var _a, _b;
       if (((_a = this.meta) === null || _a === void 0 ? void 0 : _a.style) && _typeof$1((_b = this.meta) === null || _b === void 0 ? void 0 : _b.style) === 'object') {
-        var metaStyles = JSON.parse(JSON.stringify((_c = this.meta) === null || _c === void 0 ? void 0 : _c.style));
-        return metaStyles;
+        return JSON.parse(JSON.stringify(this.meta.style));
       }
-      return null;
+      return undefined;
     }
   }, {
     key: "isShippingRequired",
@@ -20065,14 +21108,10 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
   }, {
     key: "update",
     value: function update(data) {
-      var _a, _b, _c, _d, _e, _f;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
       if (!this.latestShippingChangePromiseResolve || !this.latestShippingChangePromiseReject) {
         return;
       }
-      if (!data.success) {
-        this.latestShippingChangePromiseReject();
-        return;
-      }
       var newAmount = ((_a = data === null || data === void 0 ? void 0 : data.body) === null || _a === void 0 ? void 0 : _a.amount) || this.meta.amount;
       var newShippingOptions = (_b = data === null || data === void 0 ? void 0 : data.body) === null || _b === void 0 ? void 0 : _b.shipping_options;
       if (newAmount) {
@@ -20082,377 +21121,124 @@ var GooglePayOpenWalletService = /*#__PURE__*/function (_OpenWalletService) {
         this.meta.shipping_options = newShippingOptions;
         this.selectedShippingOption = newShippingOptions ? newShippingOptions[0] : undefined;
       }
-      var paymentDataRequestUpdate = _extends({
+      if (!data.success) {
+        this.latestShippingChangePromiseResolve({
+          newTransactionInfo: {
+            totalPriceStatus: 'FINAL',
+            totalPriceLabel: this.meta.amount_label,
+            totalPrice: (_c = this.meta.amount) === null || _c === void 0 ? void 0 : _c.toString(),
+            currencyCode: (_d = this.meta.currency) === null || _d === void 0 ? void 0 : _d.toUpperCase(),
+            countryCode: (_e = this.meta.country) === null || _e === void 0 ? void 0 : _e.toUpperCase()
+          },
+          error: {
+            reason: ((_f = data.error) === null || _f === void 0 ? void 0 : _f.reason) || 'OTHER_ERROR',
+            message: ((_g = data.error) === null || _g === void 0 ? void 0 : _g.message) || 'An error occurred',
+            intent: ((_h = data.error) === null || _h === void 0 ? void 0 : _h.intent) || 'SHIPPING_ADDRESS'
+          }
+        });
+        return;
+      }
+      this.latestShippingChangePromiseResolve(_extends({
         newTransactionInfo: {
           totalPriceStatus: 'FINAL',
           totalPriceLabel: this.meta.amount_label,
-          totalPrice: (_c = this.meta.amount) === null || _c === void 0 ? void 0 : _c.toString(),
-          currencyCode: (_d = this.meta.currency) === null || _d === void 0 ? void 0 : _d.toUpperCase(),
-          countryCode: (_e = this.meta.country) === null || _e === void 0 ? void 0 : _e.toUpperCase()
+          totalPrice: (_j = this.meta.amount) === null || _j === void 0 ? void 0 : _j.toString(),
+          currencyCode: (_k = this.meta.currency) === null || _k === void 0 ? void 0 : _k.toUpperCase(),
+          countryCode: (_l = this.meta.country) === null || _l === void 0 ? void 0 : _l.toUpperCase()
         }
       }, this.isShippingRequired() && this.hasShippingOptions() && newShippingOptions && {
         newShippingOptionParameters: {
-          defaultSelectedOptionId: (_f = this.selectedShippingOption) === null || _f === void 0 ? void 0 : _f.id,
+          defaultSelectedOptionId: (_m = this.selectedShippingOption) === null || _m === void 0 ? void 0 : _m.id,
           shippingOptions: formatShippingOptions(this.meta.shipping_options)
         }
-      });
-      this.latestShippingChangePromiseResolve(paymentDataRequestUpdate);
+      }));
     }
   }]);
 }(OpenWalletService);
 
-var OpenWalletButtons = /*#__PURE__*/function () {
-  function OpenWalletButtons(selector, publicKeyOrAccessToken, serviceId, meta, requiredMetaFields) {
-    _classCallCheck(this, OpenWalletButtons);
-    this.env = DEFAULT_ENV;
-    this.eventEmitter = new EventEmitter();
-    this.container = new Container(selector);
-    this.api = new ApiInternal(publicKeyOrAccessToken, this.getApiAuthType(publicKeyOrAccessToken));
-    this.serviceId = serviceId;
-    this.meta = meta;
-    this.validateRequiredMetaFields(requiredMetaFields);
+/**
+ * @classdesc Google Pay wallet button that creates One-Time Tokens (OTT) via Google Pay.
+ *
+ * Provides a fully typed Google Pay integration with Google Pay-specific metadata
+ * and validates that the service configuration corresponds to a Google Pay service.
+ * On `load()`, the button fetches the service configuration and raises an error via `onError`
+ * if the service type does not match Google Pay.
+ *
+ * @class GooglePayOpenWalletButton
+ * @extends OpenWalletButtons
+ *
+ * @param {string} selector - CSS selector of the HTML element that will contain the Google Pay button.
+ * @param {string} publicKeyOrAccessToken - Public key or access token for API authentication.
+ * @param {string} serviceId - The Google Pay service ID configured in PayDock dashboard.
+ * @param {GooglePayOpenWalletMeta} meta - Google Pay-specific metadata (amount, currency, country, card_config, merchant_name, style, etc.).
+ *
+ * @example
+ * const button = new GooglePayOpenWalletButton(
+ *   '#wallet-container',
+ *   publicKeyOrAccessToken,
+ *   serviceId,
+ *   {
+ *     amount: 100,
+ *     currency: 'AUD',
+ *     country: 'AU',
+ *     merchant_name: 'Your Store',
+ *   },
+ * );
+ * button.setEnv('sandbox');
+ * button.onSuccess((data) => console.log('OTT:', data.token));
+ * button.onError((error) => console.error('Error:', error));
+ * button.load();
+ */
+var GooglePayOpenWalletButton = /*#__PURE__*/function (_OpenWalletButtons) {
+  function GooglePayOpenWalletButton() {
+    var _this;
+    _classCallCheck(this, GooglePayOpenWalletButton);
+    _this = _callSuper(this, GooglePayOpenWalletButton, arguments);
+    /** @private */
+    _this.walletType = exports.WALLET_TYPES.GOOGLE_PAY;
+    return _this;
   }
-  return _createClass(OpenWalletButtons, [{
-    key: "getApiAuthType",
-    value: function getApiAuthType(publicKeyOrAccessToken) {
-      if (AccessToken.validateJWT(publicKeyOrAccessToken)) {
-        return API_AUTH_TYPE.TOKEN;
-      }
-      return API_AUTH_TYPE.PUBLIC_KEY;
-    }
-  }, {
-    key: "validateRequiredMetaFields",
-    value: function validateRequiredMetaFields(requiredFields) {
-      var _iterator = _createForOfIteratorHelper(requiredFields),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var field = _step.value;
-          if (!(field in this.meta) || this.meta[field] === undefined) {
-            throw new Error("Required meta field '".concat(field, "' is missing"));
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-    }
-  }, {
-    key: "getOpenWalletServiceConfig",
-    value: function getOpenWalletServiceConfig() {
-      var _this = this;
-      var storageKey = "serviceConfig-".concat(this.serviceId);
-      var cachedData = localStorage.getItem(storageKey);
-      return new Promise(function (resolve, reject) {
-        if (cachedData) {
-          try {
-            var _JSON$parse = JSON.parse(atob(cachedData)),
-              data = _JSON$parse.data,
-              timestamp = _JSON$parse.timestamp;
-            var oneDay = 86400000;
-            if (Date.now() - timestamp < oneDay) {
-              return resolve(JSON.parse(data));
-            }
-          } catch (_error) {
-            localStorage.removeItem(storageKey);
-          }
-        }
-        _this.api.service().getConfig(_this.serviceId).then(function (serviceConfigResponse) {
-          try {
-            var encodedData = btoa(JSON.stringify({
-              data: JSON.stringify(serviceConfigResponse),
-              timestamp: Date.now()
-            }));
-            localStorage.setItem(storageKey, encodedData);
-            return resolve(serviceConfigResponse);
-          } catch (_error) {
-            return resolve(serviceConfigResponse);
-          }
-        })["catch"](reject);
-      });
-    }
-  }, {
-    key: "handleOnError",
-    value: function handleOnError(error) {
-      var errorData = {
-        error: error,
-        context: {
-          operation: 'wallet_operation',
-          wallet_type: this.walletType
-        }
-      };
-      if (error) {
-        console.error('Wallet operation error:', error);
-      }
-      this.eventEmitter.emit(EVENT$2.ERROR, errorData);
-    }
-    /**
-     * Loads and initializes the wallet button based on the service configuration.
-     * This method fetches the wallet service configuration and creates the appropriate wallet service instance.
-     * Bear in mind that you must call this method after setting up all event handlers.
-     *
-     * @example
-     * button.load();
-     */
-  }, {
-    key: "load",
-    value: function load() {
-      var _this2 = this;
-      this.getOpenWalletServiceConfig().then(function (serviceConfig) {
-        var walletService;
-        switch (serviceConfig.type) {
-          case SERVICE_TYPES.APPLE_PAY:
-            walletService = new ApplePayOpenWalletService(_this2.api, _this2.eventEmitter, _this2.serviceId, _this2.container, _this2.meta, serviceConfig);
-            break;
-          case SERVICE_TYPES.GOOGLE_PAY:
-            walletService = new GooglePayOpenWalletService(_this2.api, _this2.eventEmitter, _this2.serviceId, _this2.container, _this2.meta, serviceConfig);
-            break;
-        }
-        if (!walletService) {
-          _this2.handleOnError(new Error("Invalid service type: ".concat(serviceConfig.type)));
-          return;
-        }
-        walletService.load();
-      })["catch"](function (error) {
-        _this2.handleOnError(error);
-      });
-    }
-    /**
-     * Current method can change environment. By default environment = sandbox.
-     * Also we can change domain alias for this environment. By default domain_alias = paydock.com
-     * Bear in mind that you must set an environment before calling `button.load()`.
-     *
-     * @example
-     * button.setEnv('production', 'paydock.com');
-     * @param {string} env - sandbox, production
-     * @param {string} [alias] - Own domain alias
-     */
-  }, {
-    key: "setEnv",
-    value: function setEnv(env, alias) {
-      this.env = env;
-      this.api.setEnv(env, alias);
-    }
-    /**
-     * Callback for onClick method.
-     *
-     * @callback OnClickCallback
-     * @param {OnClickEventData} data
-     */
-    /**
-    /**
-     * Registers a callback function to be invoked when the wallet button gets clicked.
-     * There are two operational modes supported, Synchronous and Asynchronous.
-     * When asynchronous operations need to occur on the callback handler, attaching the Promise via `attachResult` is required to have the wallet wait for a result.
-     * When synchronous operations occur on the callback handler, attaching a boolean result via `attachResult` is optional to control the execution flow.
-     * Note this is supported for Paypal, GooglePay and ApplePay wallet buttons at the moment.
-     *
-     * @example
-     * button.onClick((data) => {
-     *      performValidationLogic();
-     * });
-     *
-     * @param {listener} handler - Function to be called when the wallet button is clicked.
-     */
-  }, {
-    key: "onClick",
-    value: function onClick(handler) {
-      if (typeof handler === 'function') {
-        return this.eventEmitter.subscribe(EVENT$2.ON_CLICK, handler);
-      }
-    }
-    /**
-     * Callback for onSuccess method.
-     *
-     * @callback OnSuccessCallback
-     * @param {OnCrateOTTSuccessfulEventData} data
-     * @return {Promise<string>} OTT (One Time Token) string result
-     */
-    /**
-     * If the OTT creation was successful, the function passed as parameter will be called.
-     * Important: Do not perform thread blocking operations in callback such as window.alert() calls.
-     *
-     * @example
-     * button.onSuccess((data) => {
-     *      console.log('OTT creation successful!', data);
-     * });
-     *
-     * @example
-     * button.onSuccess().then((data) => console.log('OTT creation successful!', data));
-     *
-     * @param {OnSuccessCallback} [handler] - Function to be called when the OTT creation was successful.
-     */
-  }, {
-    key: "onSuccess",
-    value: function onSuccess(handler) {
-      if (typeof handler === 'function') {
-        return this.eventEmitter.subscribe(EVENT$2.SUCCESS, handler);
-      }
-      this.handleOnError(new Error('onSuccess event handler is required to receive the OTT token string.'));
-    }
-    /**
-     * Callback for onUnavailable method.
-     *
-     * @callback OnUnavailableCallback
-     * @param {OnUnavailableEventData} data
-     */
-    /**
-     * Registers a callback function to be invoked when the wallet is not available in the current context.
-     * This can happen when the wallet service is not supported on the current device or browser.
-     *
-     * @example
-     * button.onUnavailable((data) => {
-     *      console.log('Wallet not available', data);
-     * });
-     *
-     * @example
-     * button.onUnavailable().then((data) => console.log('Wallet not available', data));
-     *
-     * @param {OnUnavailableCallback} [handler] - Function to be called when the wallet is not available in the current context.
-     */
-  }, {
-    key: "onUnavailable",
-    value: function onUnavailable(handler) {
-      var _this3 = this;
-      if (typeof handler === 'function') {
-        return this.eventEmitter.subscribe(EVENT$2.UNAVAILABLE, handler);
-      }
-      return new Promise(function (resolve) {
-        return _this3.eventEmitter.subscribe(EVENT$2.UNAVAILABLE, function (data) {
-          return resolve(data);
-        });
-      });
-    }
-    /**
-     * Callback for onError method.
-     *
-     * @callback OnErrorCallback
-     * @param {OnErrorEventData} data
-     */
-    /**
-     * Registers a callback function to be invoked when an error that is not related to payment execution occurs.
-     * For example, if there are configuration issues or validation errors during wallet initialization.
-     *
-     * @example
-     * button.onError((error) => {
-     *      console.log('OpenWallet error', error);
-     * });
-     *
-     * @example
-     * button.onError().then((error) => console.log('OpenWallet error', error));
-     *
-     * @param {OnErrorCallback} [handler] - Function to be called when the OpenWallet has an error.
-     */
-  }, {
-    key: "onError",
-    value: function onError(handler) {
-      var _this4 = this;
-      if (typeof handler === 'function') {
-        return this.eventEmitter.subscribe(EVENT$2.ERROR, handler);
-      }
-      return new Promise(function (resolve) {
-        return _this4.eventEmitter.subscribe(EVENT$2.ERROR, function (data) {
-          return resolve(data);
-        });
-      });
-    }
-    /**
-     * Callback for onCancel method.
-     *
-     * @callback OnCancelCallback
-     * @param {any} data
-     */
-    /**
-     * Registers a callback function to be invoked when the wallet checkout is cancelled or closed by the user.
-     * This event is triggered when the user dismisses the wallet payment interface without completing the transaction.
-     *
-     * @example
-     * button.onCancel((data) => {
-     *      console.log('Wallet checkout cancelled', data);
-     * });
-     *
-     * @example
-     * button.onCancel().then((data) => console.log('Wallet checkout cancelled', data));
-     *
-     * @param {OnCancelCallback} [handler] - Function to be called when the wallet checkout is cancelled.
-     */
-  }, {
-    key: "onCancel",
-    value: function onCancel(handler) {
-      var _this5 = this;
-      if (typeof handler === 'function') {
-        return this.eventEmitter.subscribe(EVENT$2.CHECKOUT_CLOSE, handler);
-      }
-      return new Promise(function (resolve) {
-        return _this5.eventEmitter.subscribe(EVENT$2.CHECKOUT_CLOSE, function (data) {
-          return resolve(data);
-        });
-      });
+  /**
+   * Validates Google Pay-specific required metadata fields.
+   * Google Pay has no additional required fields beyond the base (amount, currency, country).
+   * @private
+   */
+  _inherits(GooglePayOpenWalletButton, _OpenWalletButtons);
+  return _createClass(GooglePayOpenWalletButton, [{
+    key: "validateWalletMeta",
+    value: function validateWalletMeta() {
+      // Google Pay has no additional required meta fields beyond the base.
+      // Optional fields (merchant_name, card_config, etc.) are validated
+      // at runtime by the Google Pay SDK.
     }
     /**
-     * Callback for onShippingAddressChange method.
-     *
-     * @callback OnShippingAddressChangeCallback
-     * @param {OnShippingAddressChangeEventData} data
-     * @return {Promise<OnShippingAddressChangeEventResponse>} Address update result containing updated amount and/or shipping options
-     */
-    /**
-     * If shipping address data is updated, the function passed as parameter will be called.
-     * Use this method to listen for shipping address selection or input from customer when shipping is enabled.
-     * The event handler should return updated payment information including the new amount and available shipping options based on the selected address.
-     *
-     * @example
-     * button.onShippingAddressChange(async (data) => {
-     *     const responseData = await fetch('https://your-server.com/update-shipping-address');
-     *     return {
-     *       amount: responseData.newAmount,
-     *       shipping_options: responseData.availableShippingOptions
-     *     };
-     * });
+     * Validates that the service configuration type is Google Pay.
      *
-     * @param {OnShippingAddressChangeCallback} [handler] - Function to be called when the shipping address data is updated.
+     * @private
+     * @param serviceConfig - The service configuration response from the API.
+     * @throws {Error} If the service type is not Google Pay.
      */
   }, {
-    key: "onShippingAddressChange",
-    value: function onShippingAddressChange(handler) {
-      if (typeof handler === 'function') {
-        return this.eventEmitter.subscribe(EVENT$2.ON_SHIPPING_ADDRESS_CHANGE, handler);
+    key: "validateServiceType",
+    value: function validateServiceType(serviceConfig) {
+      if (serviceConfig.type !== SERVICE_TYPES.GOOGLE_PAY) {
+        throw new Error("Service configuration type '".concat(serviceConfig.type, "' does not match expected wallet type '").concat(exports.WALLET_TYPES.GOOGLE_PAY, "'. ") + "Ensure the service ID '".concat(this.serviceId, "' corresponds to a Google Pay service."));
       }
-      this.handleOnError(new Error('onShippingAddressChange event handler is required.'));
     }
     /**
-     * Callback for onShippingOptionsChange method.
+     * Creates a Google Pay wallet service instance.
      *
-     * @callback OnShippingOptionsChangeCallback
-     * @param {OnShippingOptionChangeEventData} data
-     * @return {Promise<OnShippingOptionChangeEventResponse>} Shipping options update result containing updated amount
-     */
-    /**
-     * If shipping options data is updated, the function passed as parameter will be called.
-     * Use this method to listen for shipping option selection from customer when shipping is enabled.
-     * The event handler should return the updated payment amount based on the selected shipping option.
-     *
-     * @example
-     * button.onShippingOptionsChange(async (data) => {
-     *     const responseData = await fetch('https://your-server.com/update-shipping-option');
-     *     return {
-     *       amount: responseData.newTotalAmount
-     *     };
-     * });
-     *
-     * @param {OnShippingOptionsChangeCallback} [handler] - Function to be called when the shipping options data is updated.
+     * @private
+     * @param serviceConfig - The service configuration response from the API.
+     * @returns The Google Pay wallet service instance.
      */
   }, {
-    key: "onShippingOptionsChange",
-    value: function onShippingOptionsChange(handler) {
-      if (typeof handler === 'function') {
-        return this.eventEmitter.subscribe(EVENT$2.ON_SHIPPING_OPTIONS_CHANGE, handler);
-      }
-      this.handleOnError(new Error('onShippingOptionsChange event handler is required.'));
+    key: "createWalletService",
+    value: function createWalletService(serviceConfig) {
+      return new GooglePayOpenWalletService(this.api, this.eventEmitter, this.serviceId, this.container, this.meta, serviceConfig);
     }
   }]);
-}();
+}(OpenWalletButtons);
 
 /**
  *
@@ -41459,6 +42245,7 @@ var browser = /*#__PURE__*/Object.freeze({
 exports.AfterpayCheckoutButton = AfterpayCheckoutButton;
 exports.AfterpayOnSiteMessaging = AfterpayOnSiteMessaging;
 exports.Api = Api;
+exports.ApplePayOpenWalletButton = ApplePayOpenWalletButton;
 exports.ApplePayWalletButtonExpress = ApplePayWalletButtonExpress;
 exports.CHECKOUT_BUTTON_EVENT = CHECKOUT_BUTTON_EVENT;
 exports.Canvas3ds = Canvas3ds;
@@ -41472,6 +42259,7 @@ exports.ExternalCheckoutChecker = Checker;
 exports.FORM_FIELD = FORM_FIELD$1;
 exports.FRAUD_PREVENTION_EVENTS = FRAUD_PREVENTION_EVENTS;
 exports.FraudPreventionService = FraudPreventionService;
+exports.GooglePayOpenWalletButton = GooglePayOpenWalletButton;
 exports.HtmlMultiWidget = HtmlMultiWidget;
 exports.HtmlPaymentSourceWidget = HtmlPaymentSourceWidget;
 exports.HtmlWidget = HtmlWidget;