@paydock/client-sdk 1.139.0 → 1.140.0-beta

package/bundles/widget.umd.js

@@ -1198,7 +1198,7 @@
     version: 'x-sdk-version',
     type: 'x-sdk-type'
   });
-  SDK._version = 'v1.139.0';
+  SDK._version = 'v1.140.0-beta';
 
   function isFunction(value) {
       return typeof value === 'function';
@@ -18791,21 +18791,674 @@
     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";
@@ -18817,7 +19470,48 @@
     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;
@@ -18826,8 +19520,16 @@
       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) {
@@ -18850,11 +19552,18 @@
           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) {
@@ -18869,6 +19578,14 @@
           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) {
@@ -18880,7 +19597,7 @@
                 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];
@@ -18889,40 +19606,60 @@
           }, _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 = '';
         }
       }
     }]);
@@ -18935,7 +19672,24 @@
   })(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);
@@ -18944,7 +19698,9 @@
       _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 () {
@@ -18958,7 +19714,7 @@
         });
       };
       _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,
@@ -18970,8 +19726,8 @@
         }), _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,
@@ -18984,8 +19740,8 @@
           }
         });
         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,
@@ -19026,22 +19782,39 @@
                   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'
+                    }
                   });
                 }));
             }
@@ -19058,11 +19831,36 @@
                   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'
                     }
                   });
@@ -19076,6 +19874,12 @@
     }
     _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;
@@ -19120,12 +19924,11 @@
     }, {
       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",
@@ -19203,10 +20006,10 @@
       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) {
@@ -19215,7 +20018,7 @@
           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);
           });
         });
@@ -19238,7 +20041,7 @@
         }
         applePayButton.addEventListener('click', this.onApplePayButtonClicked.bind(this));
         this.eventEmitter.emit(EVENT$2.LOADED, {
-          wallet: exports.WALLET_TYPES.APPLE_PAY
+          event: EVENT$2.LOADED
         });
       }
     }, {
@@ -19257,11 +20060,10 @@
       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) {
@@ -19274,24 +20076,29 @@
     }, {
       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",
@@ -19305,6 +20112,29 @@
           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() {
@@ -19451,19 +20281,139 @@
     }]);
   }(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) {
@@ -19487,6 +20437,13 @@
       }
     });
   };
+  /**
+   * 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 {
@@ -19496,6 +20453,14 @@
       };
     });
   };
+  /**
+   * 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;
@@ -19535,6 +20500,37 @@
       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;
@@ -19545,6 +20541,13 @@
       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;
@@ -19560,6 +20563,19 @@
     });
   };
 
+  /**
+   * 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) {
@@ -19586,7 +20602,24 @@
     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);
@@ -19657,7 +20690,7 @@
           googlePayJs.onload = function () {
             if (!window.google) {
               _this2.handleOnUnavailable('Google Pay not available');
-              reject();
+              reject(new Error('Google Pay not available'));
               return;
             }
             _this2.onScriptLoaded();
@@ -19665,7 +20698,7 @@
           };
           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);
         });
@@ -19735,6 +20768,9 @@
           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",
@@ -19756,51 +20792,55 @@
     }, {
       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',
@@ -19812,17 +20852,17 @@
             });
             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: {
@@ -19838,69 +20878,75 @@
     }, {
       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() {
@@ -19994,9 +21040,7 @@
         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,
@@ -20039,7 +21083,7 @@
             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();
         }
@@ -20047,12 +21091,11 @@
     }, {
       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",
@@ -20069,14 +21112,10 @@
     }, {
       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) {
@@ -20086,377 +21125,124 @@
           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);
 
   /**
    *
@@ -41463,6 +42249,7 @@
   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;
@@ -41476,6 +42263,7 @@
   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;