@paydock/client-sdk 1.139.0 → 1.140.0-beta

package/bundles/index.cjs.d.ts

@@ -2132,6 +2132,16 @@ declare enum SERVICE_GROUP {
     WALLET = "wallet"
 }
 
+/**
+ * Token types returned in the OTT (One-Time Token) creation response.
+ */
+declare enum TOKEN_TYPE {
+    /** FPAN - Funding Primary Account Number (Google Pay only). */
+    CARD = "card",
+    /** DPAN - Device Primary Account Number (Apple Pay & Google Pay). */
+    CARD_SCHEME_TOKEN = "card_scheme_token"
+}
+
 type WalletType = WALLET_TYPES;
 declare enum WALLET_TYPES {
     APPLE_PAY = "apple",
@@ -2140,7 +2150,7 @@ declare enum WALLET_TYPES {
 
 interface CreateOTTResponse {
     temp_token: string;
-    token_type: string;
+    token_type: TOKEN_TYPE;
 }
 interface Billing {
     address_line1: string;
@@ -2172,7 +2182,7 @@ interface CreateSessionRequest {
     service_id: string;
     session_id: string;
     request_shipping?: boolean;
-    store_name?: string;
+    store_name: string;
 }
 interface CreateSessionResponse {
     id: string;
@@ -3053,87 +3063,248 @@ declare class FraudPreventionService {
     private validateMode;
 }
 
-interface BaseEventData$1<T> {
-    event: string;
-    chargeId?: string;
-    data?: T | undefined;
+/**
+ * Operations that can fail during the wallet lifecycle.
+ * Used in {@link OnErrorPayload.context.operation} to identify what failed.
+ */
+declare enum ERROR_OPERATION {
+    /** General wallet lifecycle operation. */
+    WALLET_OPERATION = "wallet_operation",
+    /** Loading or validating the wallet service configuration. */
+    CONFIGURATION = "configuration",
+    /** A required event handler was not registered before calling load(). */
+    HANDLER_REGISTRATION = "handler_registration",
+    /** Processing a shipping address or shipping option update. */
+    SHIPPING_UPDATE = "shipping_update"
 }
 
+/**
+ * Events emitted during the OpenWallet payment lifecycle.
+ */
 declare enum EVENT$1 {
-    ON_UPDATE = "onUpdate",
+    /** Emitted when the wallet button is clicked by the user. */
     ON_CLICK = "onClick",
-    ON_CHECKOUT_CLOSE = "onCheckoutClose",
+    /** Emitted when the OTT (One-Time Token) creation succeeds. */
     SUCCESS = "success",
+    /** Emitted when the wallet is not available on the current device/browser. */
     UNAVAILABLE = "unavailable",
+    /** Emitted when an error occurs during wallet operation. */
     ERROR = "error",
-    UPDATE = "update",
+    /** Emitted when the wallet button has been loaded and rendered in the DOM. */
     LOADED = "loaded",
+    /** Emitted when the wallet checkout is closed/cancelled by the user (internal). */
     CHECKOUT_CLOSE = "checkoutClose",
+    /** Emitted when the customer selects or updates their shipping address. */
     ON_SHIPPING_ADDRESS_CHANGE = "onShippingAddressChange",
+    /** Emitted when the customer selects a shipping option. */
     ON_SHIPPING_OPTIONS_CHANGE = "onShippingOptionsChange"
 }
 type OpenWalletEventType = EVENT$1;
 
-interface OnClickEventData$1 {
-    request_type: string;
-    wallet_type?: string;
-    meta?: Record<string, unknown>;
+/**
+ * Base interface for all OpenWallet event data payloads.
+ * Every event emitted during the OpenWallet lifecycle carries an `event` identifier
+ * that corresponds to a value from the {@link EVENT} enum.
+ *
+ * All concrete event interfaces (e.g. {@link OnClickEventData}, {@link OnErrorEventData})
+ * extend this base.
+ */
+interface OpenWalletBaseEvent {
+    /** The event name identifier. */
+    event: EVENT$1;
+}
+/**
+ * Extended base interface for OpenWallet events that carry a typed data payload
+ * in addition to the event identifier.
+ *
+ * Used by events whose payload is wrapped in a `data` field
+ * (e.g. shipping change events, OTT error events).
+ *
+ * @template T - The type of the event-specific data payload.
+ */
+interface OpenWalletDataEvent<T> extends OpenWalletBaseEvent {
+    /** The event-specific data payload. */
+    data?: T | undefined;
 }
-interface OnCrateOTTSuccessfulEventData {
+
+/**
+ * Data emitted when the wallet button is clicked.
+ *
+ * The merchant's `onClick` handler controls the payment flow via its return value:
+ * - Return `void` / `undefined` to continue 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 also aborts the flow.
+ */
+interface OnClickEventData$1 extends OpenWalletBaseEvent {
+    event: EVENT$1.ON_CLICK;
+}
+/**
+ * Payload for the onSuccess event data.
+ */
+interface OnCreateOTTSuccessPayload {
+    /** The created OTT response containing the temporary token. */
     token: CreateOTTResponse;
+    /** The payment amount. */
     amount: number;
+    /** The shipping address and contact information, if provided. */
     shipping?: Shipping;
+    /** The billing address, if provided. */
     billing?: Billing;
 }
-interface OnCreateOTTErrorEventData extends BaseEventData$1<{
+/**
+ * Data emitted when the OTT (One-Time Token) creation is successful.
+ */
+interface OnCreateOTTSuccessfulEventData extends OpenWalletDataEvent<OnCreateOTTSuccessPayload> {
+    event: EVENT$1.SUCCESS;
+}
+/**
+ * Payload for the OTT error event data.
+ */
+interface OnCreateOTTErrorPayload {
+    /** Error message from the API. */
     message?: string;
+    /** Error code from the API. */
     code?: string;
-}> {
+}
+/**
+ * Data emitted when the OTT creation fails.
+ */
+interface OnCreateOTTErrorEventData extends OpenWalletDataEvent<OnCreateOTTErrorPayload> {
     event: EVENT$1.ERROR;
 }
-interface OnUnavailableEventData$1 {
-    wallet_type: string;
+/**
+ * Typed details for the unavailable event.
+ */
+interface OnUnavailableDetails {
+    /** The service ID that was checked. */
+    service_id: string;
+}
+/**
+ * Payload for the onUnavailable event data.
+ */
+interface OnUnavailablePayload {
+    /** A human-readable reason why the wallet is unavailable. */
     reason: string;
-    details?: Record<string, unknown>;
+    /** Additional details about the unavailability. */
+    details?: OnUnavailableDetails;
 }
-interface OnErrorEventData$1 {
+/**
+ * Data emitted when the wallet is not available on the current device or browser.
+ */
+interface OnUnavailableEventData$1 extends OpenWalletDataEvent<OnUnavailablePayload> {
+    event: EVENT$1.UNAVAILABLE;
+}
+/**
+ * Payload for the onError event data.
+ */
+interface OnErrorPayload {
+    /** The Error object describing what went wrong. */
     error: Error;
+    /** Context about the error. */
     context?: {
-        operation?: string;
-        wallet_type?: string;
+        /** The operation that failed. */
+        operation?: ERROR_OPERATION;
     };
 }
+/**
+ * Data emitted when an error occurs during wallet operation.
+ */
+interface OnErrorEventData$1 extends OpenWalletDataEvent<OnErrorPayload> {
+    event: EVENT$1.ERROR;
+}
+/**
+ * Data emitted when the wallet button has been loaded and rendered in the DOM.
+ * No payload — the specific wallet type is determined by the concrete button class.
+ */
+interface OnLoadedEventData extends OpenWalletBaseEvent {
+    event: EVENT$1.LOADED;
+}
+/**
+ * Data emitted when the wallet checkout is cancelled or closed by the user.
+ * No payload — matches WalletButtonsExpress `OnCloseEventData` convention.
+ */
+interface OnCancelEventData extends OpenWalletBaseEvent {
+    event: EVENT$1.CHECKOUT_CLOSE;
+}
 
+/**
+ * Base metadata required to configure an OpenWallet button.
+ */
 interface OpenWalletMeta {
+    /** The payment amount as a number (e.g. `19.99`). */
     amount: number;
+    /** The ISO 4217 currency code (e.g. `'AUD'`, `'USD'`). */
     currency: string;
+    /** The ISO 3166-1 alpha-2 country code (e.g. `'AU'`, `'US'`). */
     country: string;
+    /** Optional styling configuration for the wallet button. */
     style?: OpenWalletMetaStyles;
 }
+/**
+ * Styling options for the wallet button appearance.
+ */
 interface OpenWalletMetaStyles {
+    /** The button type variant (wallet-specific values). */
     button_type?: string;
+    /** The button color/style variant (wallet-specific values). */
     button_style?: string;
 }
 
-interface WalletPaymentSource {
-    load(): void;
-}
-
-interface BaseEventData<T> {
-    event: string;
-    data?: T | undefined;
+/**
+ * Internal contract for wallet-specific service providers (Apple Pay, Google Pay, etc.).
+ *
+ * This interface defines the operations that the wallet-specific button classes
+ * ({@link ApplePayOpenWalletButton}, {@link GooglePayOpenWalletButton}) delegate
+ * to the resolved wallet service after fetching the service configuration.
+ *
+ * **Note:** This is NOT the merchant-facing API. Merchants interact with
+ * {@link ApplePayOpenWalletButton} or {@link GooglePayOpenWalletButton} directly,
+ * which orchestrate these providers internally.
+ */
+interface IOpenWalletProvider {
+    /**
+     * Loads the wallet SDK, checks availability, and renders the wallet button.
+     * If the wallet is not available, emits the `unavailable` event instead.
+     */
+    load(): Promise<void>;
+    /**
+     * Removes the wallet button from the DOM and releases resources.
+     */
+    destroy(): void;
+    /**
+     * Updates the wallet metadata (e.g. when order amount or currency changes).
+     *
+     * @param meta - The updated metadata.
+     */
+    setMeta(meta: OpenWalletMeta): void;
 }
 
-interface OnShippingAddressChangeEventData$1 extends BaseEventData<AddressChangeEventData$1> {
+/**
+ * Event data emitted when the customer selects or updates their shipping address
+ * in the wallet payment sheet.
+ */
+interface OnShippingAddressChangeEventData$1 extends OpenWalletDataEvent<AddressChangeEventData$1> {
     event: EVENT$1.ON_SHIPPING_ADDRESS_CHANGE;
 }
+/**
+ * The shipping address data provided by the wallet.
+ */
 interface AddressChangeEventData$1 {
+    /** Postal/zip code of the shipping address. */
     address_postcode?: string;
+    /** City of the shipping address. */
     address_city?: string;
+    /** State or administrative area of the shipping address. */
     address_state?: string;
+    /** Country code of the shipping address. */
     address_country?: string;
+    /** Street address line 1 (Apple Pay only). */
     address_line1?: string;
+    /** Street address line 2 (Apple Pay only). */
     address_line2?: string;
+    /** Contact information for the shipping recipient (Apple Pay only). */
     contact?: {
         phone?: string;
         email?: string;
@@ -3142,212 +3313,1212 @@ interface AddressChangeEventData$1 {
     };
 }
 
+/**
+ * Event data emitted when the customer selects a shipping option
+ * in the wallet payment sheet.
+ */
+interface OnShippingOptionChangeEventData$1 extends OpenWalletDataEvent<ShippingOptionChangeEventData$1> {
+    event: EVENT$1.ON_SHIPPING_OPTIONS_CHANGE;
+}
+/**
+ * The selected shipping option data provided by the wallet.
+ */
+interface ShippingOptionChangeEventData$1 {
+    /** The unique identifier of the selected shipping option. */
+    shipping_option_id?: string;
+    /** The amount associated with the selected shipping option. */
+    amount?: string;
+    /** The display label of the selected shipping option. */
+    label?: string;
+    /** Additional detail text for the selected shipping option. */
+    detail?: string;
+}
+
+/**
+ * Response object returned by the merchant's `onShippingAddressChange` handler.
+ * Used to update the wallet payment sheet with new amounts, shipping options, or errors.
+ */
 interface OnShippingAddressChangeEventResponse$1 {
+    /** The updated payment amount based on the new shipping address. */
     amount?: number;
-    shipping_options?: IApplePayShippingOption$1[];
+    /**
+     * Updated list of available shipping options for the new address.
+     * The first item in the array is used as the default selected option.
+     */
+    shipping_options?: IShippingOption[];
+    /** Optional error to display in the wallet payment sheet if the address is invalid. */
+    error?: {
+        /** The error code identifying the type of address validation error. */
+        code: 'address_error' | 'country_error' | 'state_error' | 'zip_error' | 'shipping_contact_invalid' | 'billing_contact_invalid' | string;
+        /** The specific field that caused the error (for Apple Pay error display). */
+        field?: 'phone' | 'email' | 'name' | 'phonetic_name' | 'address_lines' | 'locality' | 'postal_code' | 'administrative_area' | 'country' | 'country_code';
+        /** A human-readable error message to display to the customer. */
+        message?: string;
+    };
+}
+
+/**
+ * Response object returned by the merchant's `onShippingOptionsChange` handler.
+ * Used to update the wallet payment sheet with a new total amount.
+ */
+interface OnShippingOptionChangeEventResponse$1 {
+    /** The updated total payment amount based on the selected shipping option. */
+    amount?: number;
+    /** Optional error to display in the wallet payment sheet if the option is invalid. */
+    error?: {
+        /** The error code identifying the type of shipping option error. */
+        code: 'method_unavailable' | 'store_unavailable' | string;
+        /** A human-readable error message. */
+        message?: string;
+    };
+}
+
+/**
+ * Conditional type that maps a shipping event data type to its corresponding response type.
+ *
+ * - `OnShippingAddressChangeEventData` maps to `OnShippingAddressChangeEventResponse`
+ * - `OnShippingOptionChangeEventData` maps to `OnShippingOptionChangeEventResponse`
+ *
+ * @template T - The shipping event data type.
+ */
+type ShippingEventToResponse$1<T> = T extends OnShippingAddressChangeEventData$1 ? OnShippingAddressChangeEventResponse$1 : T extends OnShippingOptionChangeEventData$1 ? OnShippingOptionChangeEventResponse$1 : never;
+
+/**
+ * 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}
+ */
+declare abstract class OpenWalletService implements IOpenWalletProvider {
+    protected api: ApiInternal;
+    protected eventEmitter: EventEmitter;
+    protected walletType: WalletType;
+    protected serviceId: string;
+    protected container: Container;
+    protected serviceType: SERVICE_TYPES;
+    /** The service group identifier used in OTT creation requests. */
+    protected readonly serviceGroup = SERVICE_GROUP.WALLET;
+    /**
+     * @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.
+     */
+    constructor(api: ApiInternal, eventEmitter: EventEmitter, walletType: WalletType, serviceId: string, container: Container, serviceType: SERVICE_TYPES);
+    /**
+     * Loads and renders the wallet button. Must be implemented by each wallet service.
+     */
+    abstract load(): Promise<void>;
+    /**
+     * Updates the wallet metadata. Must be implemented by each wallet service.
+     *
+     * @param meta - The updated metadata.
+     */
+    abstract setMeta(meta: OpenWalletMeta): void;
+    /**
+     * 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.
+     */
+    protected createOTT(data: CreateOTTData): Promise<CreateOTTResponse>;
+    /**
+     * 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.
+     */
+    protected handleMerchantOnShippingChangedEvent<T extends OnShippingAddressChangeEventData$1 | OnShippingOptionChangeEventData$1>(eventData: T): Promise<ShippingEventToResponse$1<T>>;
+    /**
+     * Emits the {@link EVENT.UNAVAILABLE} event when the wallet is not available.
+     *
+     * @param reason - A human-readable description of why the wallet is unavailable.
+     */
+    protected handleOnUnavailable(reason?: string): void;
+    /**
+     * 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}.
+     */
+    protected handleOnError(error: Error, operation?: ERROR_OPERATION): void;
+    /**
+     * Removes the wallet button element from the DOM.
+     * Call this to clean up resources when the button is no longer needed.
+     */
+    destroy(): void;
+}
+
+/**
+ * @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
+ */
+declare abstract class OpenWalletButtons<TMeta extends OpenWalletMeta = OpenWalletMeta> {
+    protected container: Container;
+    protected api: ApiInternal;
+    protected env: string;
+    protected serviceId: string;
+    protected meta: TMeta;
+    protected eventEmitter: EventEmitter;
+    protected walletService: OpenWalletService | undefined;
+    private onShippingOptionsChangeHandlerRegistered;
+    /** @private */
+    abstract readonly walletType: WalletType;
+    /** @private */
+    constructor(selector: string, publicKeyOrAccessToken: string, serviceId: string, meta: TMeta);
+    /**
+     * Creates the wallet-specific service instance for this button.
+     * Each concrete subclass implements this to instantiate its specific wallet service.
+     *
+     * @param serviceConfig - The service configuration response from the API.
+     * @returns The wallet service instance.
+     */
+    protected abstract createWalletService(serviceConfig: GetConfigResponse): OpenWalletService;
+    /**
+     * Validates that the service configuration type matches the expected wallet type.
+     * Each concrete subclass implements this to ensure the service ID corresponds
+     * to the correct wallet type.
+     *
+     * @param serviceConfig - The service configuration response from the API.
+     * @throws {Error} If the service type does not match the expected wallet type.
+     */
+    protected abstract validateServiceType(serviceConfig: GetConfigResponse): void;
+    /**
+     * Validates wallet-specific metadata requirements.
+     * Each concrete subclass implements this to enforce its own required fields
+     * (e.g. Apple Pay requires `amount_label`).
+     *
+     * Called automatically during construction after base meta validation.
+     *
+     * @throws {Error} If any wallet-specific required field is missing or invalid.
+     */
+    protected abstract validateWalletMeta(): void;
+    private getApiAuthType;
+    /**
+     * 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.
+     */
+    private validateBaseMeta;
+    protected getOpenWalletServiceConfig(): Promise<GetConfigResponse>;
+    protected handleOnError(error: Error, operation?: ERROR_OPERATION): void;
+    /**
+     * 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();
+     */
+    load(): void;
+    /**
+     * 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.
+     */
+    setEnv(env: string, alias?: string): void;
+    /**
+     * 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.
+     */
+    setMeta(meta: TMeta): void;
+    /**
+     * 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();
+     */
+    destroy(): void;
+    /**
+     * 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.
+     */
+    onClick(handler: (data: OnClickEventData$1) => boolean | undefined | Promise<boolean | undefined>): void;
+    /**
+     * 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.
+     */
+    onSuccess(handler: (data: OnCreateOTTSuccessfulEventData) => void | Promise<void>): void;
+    /**
+     * 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.
+     */
+    onUnavailable(handler: (data: OnUnavailableEventData$1) => void | Promise<void>): void;
+    /**
+     * 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.
+     */
+    onError(handler: (data: OnErrorEventData$1) => void | Promise<void>): void;
+    /**
+     * 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.
+     */
+    onCancel(handler: (data: OnCancelEventData) => void | Promise<void>): void;
+    /**
+     * 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.
+     */
+    onLoaded(handler: (data: OnLoadedEventData) => void | Promise<void>): void;
+    /**
+     * 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.
+     */
+    onShippingAddressChange(handler: (data: OnShippingAddressChangeEventData$1) => OnShippingAddressChangeEventResponse$1 | Promise<OnShippingAddressChangeEventResponse$1>): () => void;
+    /**
+     * 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.
+     */
+    onShippingOptionsChange(handler: (data: OnShippingOptionChangeEventData$1) => OnShippingOptionChangeEventResponse$1 | Promise<OnShippingOptionChangeEventResponse$1>): () => void;
+    /**
+     * 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.
+     */
+    get isShippingOptionsChangeHandlerRegistered(): boolean;
+}
+
+type ApplePayMerchantCapability = 
+/**
+ * Required. This value must be supplied.
+ */
+'supports3DS'
+/**
+ * Include this value only if you support China Union Pay transactions.
+ */
+ | 'supportsEMV'
+/**
+ * Optional. If present, only transactions that are categorized as credit cards are allowed.
+ */
+ | 'supportsCredit'
+/**
+ * Optional. If present, only transactions that are categorized as debit cards are allowed.
+ */
+ | 'supportsDebit';
+type ApplePayContactField = 'email' | 'name' | 'phone' | 'postalAddress';
+interface ApplePayPaymentContact {
+    /**
+     * An email address for the contact.
+     */
+    email_address?: string | undefined;
+    /**
+     * The contact's family name.
+     */
+    family_name?: string | undefined;
+    /**
+     * The contact's given name.
+     */
+    given_name?: string | undefined;
+    /**
+     * A phone number for the contact.
+     */
+    phone_number?: string | undefined;
+    /**
+     * The phonetic spelling of the contact's family name.
+     */
+    phonetic_family_name?: string | undefined;
+    /**
+     * The phonetic spelling of the contact's given name.
+     */
+    phonetic_given_name?: string | undefined;
+    /**
+     * The street portion of the address for the contact.
+     */
+    address_lines?: string[] | undefined;
+    /**
+     * The city for the contact.
+     */
+    locality?: string | undefined;
+    /**
+     * Additional information associated with the location, typically defined at the city or town level (such as district or neighborhood), in a postal address.
+     */
+    sub_locality?: string | undefined;
+    /**
+     * The state for the contact.
+     */
+    administrative_area?: string | undefined;
+    /**
+     * The subadministrative area (such as a county or other region) in a postal address.
+     */
+    sub_administrative_area?: string | undefined;
+    /**
+     * The zip code or postal code, where applicable, for the contact.
+     */
+    postal_code?: string | undefined;
+    /**
+     * The name of the country for the contact.
+     */
+    country?: string | undefined;
+    /**
+     * The contact's two-letter ISO 3166 country code.
+     */
+    country_code?: string | undefined;
+}
+type ApplePayShippingContactEditingMode = 
+/**
+ * The user can edit the shipping contact on the payment sheet.
+ */
+'available'
+/**
+ * The user can’t edit the shipping contact on the payment sheet.
+ */
+ | 'storePickup'
+/**
+ * The user can edit the shipping contact on the payment sheet.
+ * @deprecated Use ApplePayShippingContactEditingMode.available instead.
+ */
+ | 'enabled';
+type ApplePayLineItemType = 
+/**
+ * A line item representing the known, final cost.
+ */
+'final'
+/**
+ * A line item representing an estimated or unknown cost.
+ */
+ | 'pending';
+/**
+ * A type that indicates the time a payment occurs in a transaction.
+ */
+type ApplePayPaymentTiming = 
+/**
+ * A value that specifies that the payment occurs when the transaction is complete.
+ */
+'immediate'
+/**
+ * A value that specifies that the payment occurs in the future.
+ */
+ | 'deferred'
+/**
+ * A value that specifies that the payment occurs on a regular basis.
+ */
+ | 'recurring'
+/**
+ * A value that specifies that the payment occurs automatically when the account falls below the automaticReloadPaymentThresholdAmount amount.
+ */
+ | 'automaticReload';
+/**
+ * A type that indicates calendrical units, such as year, month, day, and hour.
+ */
+type ApplePayRecurringPaymentDateUnit = 
+/**
+ * A value that specifies the year unit.
+ */
+'year'
+/**
+ * A value that specifies the month unit.
+ */
+ | 'month'
+/**
+ * A value that specifies the day unit.
+ */
+ | 'day'
+/**
+ * A value that specifies the hour unit.
+ */
+ | 'hour'
+/**
+ * A value that specifies the minute unit.
+ */
+ | 'minute';
+/**
+ * Defines a line item in a payment request - for example, total, tax, discount, or grand total.
+ */
+interface ApplePayLineItem {
+    /**
+     * A short, localized description of the line item.
+     */
+    label: string;
+    /**
+     * The line item's amount.
+     */
+    amount: string;
+    /**
+     * A value that indicates if the line item is final or pending.
+     */
+    type?: ApplePayLineItemType | undefined;
+    /**
+     * The time that the payment occurs as part of a successful transaction.
+     */
+    payment_timing?: ApplePayPaymentTiming;
+    /**
+     * The date of the first payment.
+     */
+    recurring_payment_start_date?: Date;
+    /**
+     * The amount of time — in calendar units, such as day, month, or year — that represents a fraction of the total payment interval.
+     */
+    recurring_payment_interval_unit?: ApplePayRecurringPaymentDateUnit;
+    /**
+     * The number of interval units that make up the total payment interval.
+     */
+    recurring_payment_interval_count?: number;
+    /**
+     * The date of the final payment.
+     */
+    recurring_payment_end_date?: Date;
+    /**
+     * The date, in the future, of the payment.
+     */
+    deferred_payment_date?: Date;
+    /**
+     * The balance an account reaches before the merchant applies the automatic reload amount.
+     */
+    automatic_reload_payment_threshold_amount?: string;
+}
+/**
+ * A type that indicates how purchased items are to be shipped.
+ */
+type ApplePayShippingType = 'shipping' | 'delivery' | 'storePickup' | 'servicePickup';
+/**
+ * When specifying a range using date components, provide all elements of the ApplePayDateComponents down to the level of granularity that you want to expose.
+ * For example, if you specify a range of days, be sure to include values for both months and years in addition to days in the ApplePayDateComponents.
+ *
+ * Apple Pay on the Web uses the Gregorian calendar when processing dates.
+ */
+interface ApplePayDateComponents {
+    /**
+     * A number that represents a day.
+     */
+    days: number;
+    /**
+     * A number between 1 and 12 that represents a month.
+     */
+    months: number;
+    /**
+     * A number that represents a year.
+     */
+    years: number;
+    /**
+     * A number that represents an hour.
+     */
+    hours: number;
+}
+/**
+ * A dictionary that specifies the start and end dates for a range of time.
+ */
+interface ApplePayDateComponentsRange {
+    /**
+     * The start date and time of the range.
+     */
+    start_date_components: ApplePayDateComponents;
+    /**
+     * The end date and time of the range.
+     */
+    end_date_components: ApplePayDateComponents;
+}
+/**
+ * Defines a shipping method for delivering physical goods.
+ */
+interface ApplePayShippingMethod {
+    /**
+     * A short description of the shipping method.
+     */
+    label: string;
+    /**
+     * A further description of the shipping method.
+     */
+    detail: string;
+    /**
+     * The amount associated with this shipping method.
+     */
+    amount: string;
+    /**
+     * A client-defined identifier.
+     */
+    identifier: string;
+    /**
+     * A dictionary that specifies the start and end dates for a range of time.
+     */
+    date_components_range?: ApplePayDateComponentsRange;
+}
+/**
+ * Use ApplePayPaymentTokenContext to authorize a payment amount for each payment token in a multimerchant payment request.
+ * To enable multiple merchants for a transaction, use one ApplePayPaymentTokenContext object for each merchant.
+ *
+ * You can optionally associate each payment token with the merchant’s top-level domain.
+ */
+interface ApplePayPaymentTokenContext {
+    /**
+     * The Apply Pay merchant identifier.
+     */
+    merchant_identifier: string;
+    /**
+     * An external identifier for the merchant.
+     */
+    external_identifier: string;
+    /**
+     * The merchant's display name that the Apple Pay server associates with the payment token.
+     */
+    merchant_name: string;
+    /**
+     * The merchant's top-level domain that the Apple Pay server associates with the payment token.
+     */
+    merchant_domain?: string;
+    /**
+     * The amount to authorize for the payment token context.
+     */
+    amount: string;
 }
-
-interface OnShippingOptionChangeEventData$1 extends BaseEventData<ShippingOptionChangeEventData$1> {
-    event: EVENT$1.ON_SHIPPING_OPTIONS_CHANGE;
+/**
+ * Use an ApplePayAutomaticReloadPaymentRequest object to provide the user with payment details and a way to manage payment methods for an automatic reload payment.
+ * You can optionally display a billing agreement and set up merchant token life-cycle notifications for the request.
+ * For more information about the merchant token life-cycle notifications, see Apple Pay Merchant Token Management API.
+ *
+ * Apple Pay issues an Apple Pay Merchant Token if the user’s payment network supports merchant-specific payment tokens.
+ * Otherwise, Apple Pay issues a device token for the payment request.
+ */
+interface ApplePayAutomaticReloadPaymentRequest {
+    /**
+     * A description of the automatic reload payment that Apple Pay displays in the payment sheet.
+     */
+    payment_description: string;
+    /**
+     * A line item that contains the reload amount and balance threshold for the automatic reload payment.
+     */
+    automatic_reload_billing: ApplePayLineItem;
+    /**
+     * A localized billing agreement that the payment sheet displays to the user before the user authorizes the payment.
+     */
+    billing_agreement?: string;
+    /**
+     * A URL to a web page where the user can update or delete the payment method for the automatic reload payment.
+     */
+    management_url: string;
+    /**
+     * A URL you provide to receive life-cycle notifications from the Apple Pay servers about the Apple Pay merchant token for the recurring payment.
+     */
+    token_notification_url?: string;
 }
-interface ShippingOptionChangeEventData$1 {
-    shipping_option_id?: string;
-    amount?: string;
-    label?: string;
-    detail?: string;
+/**
+ * A dictionary that represents a request to set up a recurring payment, typically a subscription.
+ *
+ * Important
+ * You must include the recurringPaymentRequest property in the ApplePayPaymentRequest object to specify a request for a recurring payment.
+ * Use an ApplePayRecurringPaymentRequest object to provide the user with payment details and a way to manage payment methods for a recurring payment.
+ * You can optionally display a billing agreement and set up merchant token life-cycle notifications for the request.
+ */
+interface ApplePayRecurringPaymentRequest {
+    /**
+     * A description of the recurring payment that Apple Pay displays to the user in the payment sheet.
+     */
+    payment_description: string;
+    /**
+     * A localized billing agreement that the payment sheet displays to the user before the user authorizes the payment.
+     */
+    billing_agreement?: string;
+    /**
+     * The regular billing cycle for the recurring payment, including start and end dates, an interval, and an interval count.
+     */
+    regular_billing: ApplePayLineItem;
+    /**
+     * The trial billing cycle for the recurring payment.
+     */
+    trial_billing?: ApplePayLineItem;
+    /**
+     * A URL to a web page where the user can update or delete the payment method for the recurring payment.
+     */
+    management_url: string;
+    /**
+     * A URL you provide for receiving life-cycle notifications from the Apple Pay servers about the Apple Pay merchant token for the recurring payment.
+     */
+    token_notification_url?: string;
 }
-
-interface OnShippingOptionChangeEventResponse$1 {
-    amount?: number;
+/**
+ * A dictionary that represents a request to set up a deferred payment, such as a hotel booking or a pre-order.
+ */
+interface ApplePayDeferredPaymentRequest {
+    /**
+     * The localized billing agreement the framework displays to the user prior to payment authorization.
+     */
+    billing_agreement?: string | undefined;
+    /**
+     * A dictionary that contains details about the deferred payment.
+     */
+    deferred_billing: ApplePayLineItem;
+    /**
+     * The date and time at the destination location of the payment.
+     */
+    free_cancellation_date?: Date | undefined;
+    /**
+     * The time zone at the destination location of the payment.
+     */
+    free_cancellation_date_time_zone?: string | undefined;
+    /**
+     * A URL that links to a page on your web site where the user can manage the payment method for the deferred payment, including deleting it.
+     */
+    management_url: string;
+    /**
+     * A description of the deferred payment.
+     */
+    payment_description: string;
+    /**
+     * A URL to receive life-cycle notifications for the merchant-specific payment token the system issues for the request, if applicable.
+     */
+    token_notification_url?: string | undefined;
 }
-
-declare class OpenWalletButtons implements WalletPaymentSource {
-    protected container: Container;
-    protected api: ApiInternal;
-    protected env: string;
-    protected serviceId: string;
-    protected meta: OpenWalletMeta;
-    protected eventEmitter: EventEmitter;
-    readonly walletType: WalletType;
-    constructor(selector: string, publicKeyOrAccessToken: string, serviceId: string, meta: OpenWalletMeta, requiredMetaFields: string[]);
-    private getApiAuthType;
-    private validateRequiredMetaFields;
-    private getOpenWalletServiceConfig;
-    private handleOnError;
+/**
+ * Values you use to enable or disable Apple Pay Later for a specific transaction.
+ */
+type ApplePayLaterAvailability = 
+/**
+ * Apple Pay Later is available.
+ * This is the default.
+ */
+'available'
+/**
+ * Apple Pay Later is unavailable because one or more ineligible or prohibited items are in the shopping cart, such as gift cards
+ */
+ | 'unavailableItemIneligible'
+/**
+ * Apple Pay Later is unavailable because there’s a recurring payment or subscription in the shopping cart.
+ */
+ | 'unavailableRecurringTransaction';
+interface ApplePayPaymentRequest {
     /**
-     * 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();
+     * An array of the payment capabilities that the merchant supports, such as credit or debit.
+     * The value must at least contain ApplePayMerchantCapability.supports3DS.
      */
-    load(): void;
+    merchant_capabilities: ApplePayMerchantCapability[];
     /**
-     * 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
+     * The payment networks supported by the merchant.
      */
-    setEnv(env: string, alias?: string): void;
+    supported_networks: string[];
     /**
-     * Callback for onClick method.
-     *
-     * @callback OnClickCallback
-     * @param {OnClickEventData} data
+     * The merchant's two-letter ISO 3166 country code.
      */
+    country_code: string;
     /**
+     * The billing information that you require from the user in order to process the transaction.
+     */
+    required_billing_contact_fields?: ApplePayContactField[] | undefined;
     /**
-     * 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.
+     * Billing contact information for the user.
      */
-    onClick(handler: (data: OnClickEventData$1) => void): () => void;
+    billing_contact?: ApplePayPaymentContact | undefined;
     /**
-     * Callback for onSuccess method.
-     *
-     * @callback OnSuccessCallback
-     * @param {OnCrateOTTSuccessfulEventData} data
-     * @return {Promise<string>} OTT (One Time Token) string result
+     * The shipping information that you require from the user in order to fulfill the order.
      */
+    required_shipping_contact_fields?: ApplePayContactField[] | undefined;
     /**
-     * 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.
+     * Shipping contact information for the user.
      */
-    onSuccess(handler?: (data: OnCrateOTTSuccessfulEventData) => void): () => void;
+    shipping_contact?: ApplePayPaymentContact | undefined;
     /**
-     * Callback for onUnavailable method.
-     *
-     * @callback OnUnavailableCallback
-     * @param {OnUnavailableEventData} data
+     * Optional user-defined data.
      */
+    application_data?: string | undefined;
     /**
-     * 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.
+     * A list of ISO 3166 country codes for limiting payments to cards from specific countries.
      */
-    onUnavailable(handler?: (data: OnUnavailableEventData$1) => void): Promise<unknown> | (() => void);
+    supported_countries?: string[] | undefined;
     /**
-     * Callback for onError method.
-     *
-     * @callback OnErrorCallback
-     * @param {OnErrorEventData} data
+     * A Boolean value that determines whether the payment sheet displays the coupon code field.
      */
+    supports_coupon_code?: boolean | undefined;
     /**
-     * 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.
+     * The initial coupon code for the payment request.
      */
-    onError(handler?: (data: OnErrorEventData$1) => void): Promise<unknown> | (() => void);
+    coupon_code?: string | undefined;
     /**
-     * Callback for onCancel method.
-     *
-     * @callback OnCancelCallback
-     * @param {any} data
+     * A value that indicates whether the shipping mode prevents the user from editing the shipping address.
      */
+    shipping_contact_editing_mode?: ApplePayShippingContactEditingMode;
     /**
-     * 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.
+     * A line item representing the total for the payment.
      */
-    onCancel(handler?: (data: any) => void): Promise<unknown> | (() => void);
+    total: ApplePayLineItem;
     /**
-     * Callback for onShippingAddressChange method.
+     * A set of line items that explain recurring payments and/or additional charges.
+     */
+    line_items?: ApplePayLineItem[] | undefined;
+    /**
+     * The three-letter ISO 4217 currency code for the payment.
+     */
+    currency_code: string;
+    /**
+     * How the items are to be shipped.
+     */
+    shipping_type?: ApplePayShippingType | undefined;
+    /**
+     * A set of shipping method objects that describe the available shipping methods.
+     */
+    shipping_methods?: ApplePayShippingMethod[] | undefined;
+    /**
+     * An array of payment token contexts that requests multiple payment tokens to support a multimerchant payment.
+     */
+    multi_token_contexts?: ApplePayPaymentTokenContext[];
+    /**
+     * A property that requests an automatic reload payment, such as a store card top-up.
+     */
+    automatic_reload_payment_request?: ApplePayAutomaticReloadPaymentRequest;
+    /**
+     * This property is optional. Use it to indicate that the payment request is for a recurring payment.
+     * Apple Pay issues an Apple Pay Merchant Token if the user's payment network supports merchant-specific payment tokens.
+     * Otherwise, Apple Pay issues a device token for the payment request.
      *
-     * @callback OnShippingAddressChangeCallback
-     * @param {OnShippingAddressChangeEventData} data
-     * @return {Promise<OnShippingAddressChangeEventResponse>} Address update result containing updated amount and/or shipping options
+     * Important
+     * You can't use this property with multi_token_contexts or automatic_reload_payment_request properties.
+     * Simultaneous use of these properties results in an error and cancels the payment request.
      */
+    recurring_payment_request?: ApplePayRecurringPaymentRequest;
     /**
-     * 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.
+     * A property that requests a deferred payment, such as a hotel booking or a pre-order.
+     */
+    deferred_payment_request?: ApplePayDeferredPaymentRequest;
+    /**
+     * A value that indicates whether Apple Pay Later is available for a transaction.
+     */
+    apple_pay_later_availability?: ApplePayLaterAvailability;
+}
+
+type ApplePayButtonStyle$1 = 'black' | 'white' | 'white-outline';
+
+type ApplePayButtonType$1 = 'add-money' | 'book' | 'buy' | 'check-out' | 'continue' | 'contribute' | 'donate' | 'order' | 'pay' | 'plain' | 'reload' | 'rent' | 'set-up' | 'subscribe' | 'support' | 'tip' | 'top-up';
+
+declare global {
+    interface Window {
+        ApplePaySession: ApplePaySession;
+    }
+}
+interface ApplePayOpenWalletMetaStyles extends OpenWalletMetaStyles {
+    button_type?: ApplePayButtonType$1;
+    button_style?: ApplePayButtonStyle$1;
+}
+interface ApplePayOpenWalletMeta extends OpenWalletMeta, ApplePayPaymentRequest {
+    amount_label: string;
+    store_name: string;
+    /** Whether shipping address collection is required. */
+    request_shipping?: boolean;
+    /**
+     * Available shipping options to display in the payment sheet.
+     * The first item in the array is used as the default selected option.
+     * Requires `request_shipping` to be `true`.
+     */
+    shipping_options?: IApplePayShippingOption$1[];
+    show_billing_address?: boolean;
+    style?: ApplePayOpenWalletMetaStyles;
+    apple_pay_capabilities?: Array<'credentials_available' | 'credentials_status_unknown' | 'credentials_unavailable'>;
+}
+
+/**
+ * @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();
+ */
+declare class ApplePayOpenWalletButton extends OpenWalletButtons<ApplePayOpenWalletMeta> {
+    /** @private */
+    readonly walletType: WalletType;
+    /**
+     * Validates Apple Pay-specific required metadata fields.
+     * Apple Pay requires `amount_label` and `store_name` to be present and strings.
      *
-     * @example
-     * button.onShippingAddressChange(async (data) => {
-     *     const responseData = await fetch('https://your-server.com/update-shipping-address');
-     *     return {
-     *       amount: responseData.newAmount,
-     *       shipping_options: responseData.availableShippingOptions
-     *     };
-     * });
+     * @private
+     * @throws {Error} If `amount_label` is missing or not a string.
+     * @throws {Error} If `store_name` is missing or not a string.
+     */
+    protected validateWalletMeta(): void;
+    /**
+     * Validates that the service configuration type is Apple 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 Apple Pay.
      */
-    onShippingAddressChange(handler?: (data: OnShippingAddressChangeEventData$1) => Promise<OnShippingAddressChangeEventResponse$1>): () => void;
+    protected validateServiceType(serviceConfig: GetConfigResponse): void;
     /**
-     * Callback for onShippingOptionsChange method.
+     * Creates an Apple Pay wallet service instance.
      *
-     * @callback OnShippingOptionsChangeCallback
-     * @param {OnShippingOptionChangeEventData} data
-     * @return {Promise<OnShippingOptionChangeEventResponse>} Shipping options update result containing updated amount
+     * @private
+     * @param serviceConfig - The service configuration response from the API.
+     * @returns The Apple Pay wallet service instance.
      */
+    protected createWalletService(serviceConfig: GetConfigResponse): OpenWalletService;
+}
+
+type GooglePayButtonColor = 'default' | 'black' | 'white';
+
+type GooglePayButtonSizeMode = 'static' | 'fill';
+
+type GooglePayButtonType = 'book' | 'buy' | 'checkout' | 'donate' | 'order' | 'pay' | 'plain' | 'subscribe';
+
+type GooglePayAuthMethod = 'PAN_ONLY' | 'CRYPTOGRAM_3DS';
+type GooglePayCardNetwork = 'AMEX' | 'DISCOVER' | 'ELECTRON' | 'ELO' | 'ELO_DEBIT' | 'INTERAC' | 'JCB' | 'MAESTRO' | 'MASTERCARD' | 'VISA';
+type BillingAddressFormat = 'MIN' | 'FULL';
+interface GooglePayOpenWalletMetaStyles extends OpenWalletMetaStyles {
+    button_type?: GooglePayButtonType;
+    button_size_mode?: GooglePayButtonSizeMode;
+    button_color?: GooglePayButtonColor;
+}
+interface GooglePayOpenWalletMeta extends OpenWalletMeta {
+    merchant_name?: string;
+    /** Whether shipping address collection is required. */
+    request_shipping?: boolean;
+    show_billing_address?: boolean;
     /**
-     * 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.
+     * Available shipping options to display in the payment sheet.
+     * The first item in the array is used as the default selected option.
+     * Requires `request_shipping` to be `true`.
+     */
+    shipping_options?: IGooglePayShippingOption[];
+    amount_label?: string;
+    style?: GooglePayOpenWalletMetaStyles;
+    card_config?: GooglePayCardConfig;
+}
+interface GooglePayCardConfig {
+    type: 'CARD' | 'PAYPAL';
+    parameters: {
+        allowed_auth_methods: GooglePayAuthMethod[];
+        allowed_card_networks: GooglePayCardNetwork[];
+        allow_prepaid_cards?: boolean;
+        allow_credit_cards?: boolean;
+        assurance_details_required?: boolean;
+        billing_address_required?: boolean;
+        billing_address_parameters?: {
+            format: BillingAddressFormat;
+            phone_number_required?: boolean;
+        };
+        card_network_parameters?: {
+            card_network: GooglePayCardNetwork;
+            acquirer_bin?: string;
+            acquirer_merchant_id?: string;
+        }[];
+    };
+    tokenization_specification?: {
+        type: 'PAYMENT_GATEWAY';
+        parameters: {
+            [key: string]: string;
+        };
+    } | {
+        type: 'DIRECT';
+        parameters: {
+            protocol_version: string;
+            public_key: string;
+        };
+    };
+}
+
+/**
+ * @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();
+ */
+declare class GooglePayOpenWalletButton extends OpenWalletButtons<GooglePayOpenWalletMeta> {
+    /** @private */
+    readonly walletType: WalletType;
+    /**
+     * Validates Google Pay-specific required metadata fields.
+     * Google Pay has no additional required fields beyond the base (amount, currency, country).
+     * @private
+     */
+    protected validateWalletMeta(): void;
+    /**
+     * Validates that the service configuration type is Google Pay.
      *
-     * @example
-     * button.onShippingOptionsChange(async (data) => {
-     *     const responseData = await fetch('https://your-server.com/update-shipping-option');
-     *     return {
-     *       amount: responseData.newTotalAmount
-     *     };
-     * });
+     * @private
+     * @param serviceConfig - The service configuration response from the API.
+     * @throws {Error} If the service type is not Google Pay.
+     */
+    protected validateServiceType(serviceConfig: GetConfigResponse): void;
+    /**
+     * Creates a Google Pay wallet service instance.
      *
-     * @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.
      */
-    onShippingOptionsChange(handler?: (data: OnShippingOptionChangeEventData$1) => Promise<OnShippingOptionChangeEventResponse$1>): () => void;
+    protected createWalletService(serviceConfig: GetConfigResponse): OpenWalletService;
 }
 
 declare const TYPE: {
@@ -4633,26 +5804,32 @@ declare enum EVENT {
     ON_SHIPPING_OPTIONS_CHANGE = "onShippingOptionsChange"
 }
 
-interface OnClickEventData extends BaseEventData$1<undefined> {
+interface BaseEventData<T> {
+    event: string;
+    chargeId?: string;
+    data?: T | undefined;
+}
+
+interface OnClickEventData extends BaseEventData<undefined> {
     event: EVENT.ON_CLICK;
 }
 
-interface OnCloseEventData extends BaseEventData$1<undefined> {
+interface OnCloseEventData extends BaseEventData<undefined> {
     event: EVENT.ON_CHECKOUT_CLOSE;
 }
 
-interface OnErrorEventData extends BaseEventData$1<Error> {
+interface OnErrorEventData extends BaseEventData<Error> {
     event: EVENT.ERROR;
 }
 
-interface OnPaymentErrorEventData extends BaseEventData$1<{
+interface OnPaymentErrorEventData extends BaseEventData<{
     message?: string;
     code?: string;
 }> {
     event: EVENT.PAYMENT_ERROR;
 }
 
-interface OnPaymentSuccessfulEventData extends BaseEventData$1<{
+interface OnPaymentSuccessfulEventData extends BaseEventData<{
     id: string;
     amount: number;
     currency: string;
@@ -4665,7 +5842,7 @@ interface OnPaymentInReviewEventData extends Omit<OnPaymentSuccessfulEventData,
     event: EVENT.PAYMENT_IN_REVIEW;
 }
 
-interface OnShippingAddressChangeEventData extends BaseEventData$1<AddressChangeEventData> {
+interface OnShippingAddressChangeEventData extends BaseEventData<AddressChangeEventData> {
     event: EVENT.ON_SHIPPING_ADDRESS_CHANGE;
 }
 interface AddressChangeEventData {
@@ -4692,7 +5869,7 @@ interface OnShippingAddressChangeEventResponse {
     };
 }
 
-interface OnShippingOptionChangeEventData extends BaseEventData$1<ShippingOptionChangeEventData> {
+interface OnShippingOptionChangeEventData extends BaseEventData<ShippingOptionChangeEventData> {
     event: EVENT.ON_SHIPPING_OPTIONS_CHANGE;
 }
 interface ShippingOptionChangeEventData {
@@ -4711,7 +5888,7 @@ interface OnShippingOptionChangeEventResponse {
     };
 }
 
-interface OnUnavailableEventData extends BaseEventData$1<undefined> {
+interface OnUnavailableEventData extends BaseEventData<undefined> {
     event: EVENT.UNAVAILABLE;
 }
 
@@ -5363,4 +6540,4 @@ declare global {
     }
 }
 
-export { AfterpayCheckoutButton, AfterpayOnSiteMessaging, Api, ApplePayWalletButtonExpress, CHECKOUT_BUTTON_EVENT, Canvas3ds, Checkout, CheckoutActionCode, type CheckoutResponse, ClickToPay, Configuration, type CreateOTTData, type CreateOTTRequest, type CreateOTTResponse, type CreateSessionRequest, type CreateSessionResponse, ELEMENT, EVENT$2 as EVENT, Builder$1 as ExternalCheckoutBuilder, Checker as ExternalCheckoutChecker, FORM_FIELD, FRAUD_PREVENTION_EVENTS, type FraudPreventionEvent, type FraudPreventionEventType, type FraudPreventionProvider, FraudPreventionService, HtmlMultiWidget, HtmlPaymentSourceWidget, HtmlWidget, type ICheckout, type IClickToPayMeta, type IDetails, type IElementStyleInput, type IEventCheckoutFinishData, type IEventData, type IPayPalMeta, type IStyles$1 as IStyles, type ITexts, type IWalletMeta, type IWalletOnClickEvent, type IWalletPaymentSuccessfulEvent, type IWalletUnavailableEvent, type IWalletUpdateData, type IWalletUpdateEvent, InstructionDebugger, MultiWidget, type OTTResponse, type OnClickEventData$1 as OnClickEventData, type OnCrateOTTSuccessfulEventData, type OnCreateOTTErrorEventData, type OnErrorEventData$1 as OnErrorEventData, type OnUnavailableEventData$1 as OnUnavailableEventData, OpenWalletButtons, type OpenWalletEventType, type OpenWalletMeta, PAYMENT_TYPE, PURPOSE, PayPalDataCollector, PayPalSavePaymentSourceWidget, Builder as PaymentSourceBuilder, PaymentSourceWidget, PaypalCheckoutButton, PaypalWalletButtonExpress, STYLABLE_ELEMENT, STYLABLE_ELEMENT_STATE, STYLE, SUPPORTED_CARD_TYPES, TEXT, TRIGGER, TYPE, VAULT_DISPLAY_STYLE, type VaultDisplayStyle, VaultDisplayWidget, WALLET_TYPES, WalletButtons, type WalletPaymentSource, type WalletType, ZipmoneyCheckoutButton };
+export { AfterpayCheckoutButton, AfterpayOnSiteMessaging, Api, ApplePayOpenWalletButton, ApplePayWalletButtonExpress, type Billing, CHECKOUT_BUTTON_EVENT, Canvas3ds, Checkout, CheckoutActionCode, type CheckoutResponse, ClickToPay, Configuration, type CreateOTTData, type CreateOTTRequest, type CreateOTTResponse, type CreateSessionRequest, type CreateSessionResponse, ELEMENT, ERROR_OPERATION, EVENT$2 as EVENT, Builder$1 as ExternalCheckoutBuilder, Checker as ExternalCheckoutChecker, FORM_FIELD, FRAUD_PREVENTION_EVENTS, type FraudPreventionEvent, type FraudPreventionEventType, type FraudPreventionProvider, FraudPreventionService, GooglePayOpenWalletButton, HtmlMultiWidget, HtmlPaymentSourceWidget, HtmlWidget, type ICheckout, type IClickToPayMeta, type IDetails, type IElementStyleInput, type IEventCheckoutFinishData, type IEventData, type IOpenWalletProvider, type IPayPalMeta, type IStyles$1 as IStyles, type ITexts, type IWalletMeta, type IWalletOnClickEvent, type IWalletPaymentSuccessfulEvent, type IWalletUnavailableEvent, type IWalletUpdateData, type IWalletUpdateEvent, InstructionDebugger, MultiWidget, type OTTResponse, type OnCancelEventData, type OnClickEventData$1 as OnClickEventData, type OnCreateOTTErrorEventData, type OnCreateOTTErrorPayload, type OnCreateOTTSuccessPayload, type OnCreateOTTSuccessfulEventData, type OnErrorEventData$1 as OnErrorEventData, type OnErrorPayload, type OnLoadedEventData, type OnUnavailableDetails, type OnUnavailableEventData$1 as OnUnavailableEventData, type OnUnavailablePayload, type OpenWalletBaseEvent, OpenWalletButtons, type OpenWalletDataEvent, type OpenWalletEventType, type OpenWalletMeta, PAYMENT_TYPE, PURPOSE, PayPalDataCollector, PayPalSavePaymentSourceWidget, Builder as PaymentSourceBuilder, PaymentSourceWidget, PaypalCheckoutButton, PaypalWalletButtonExpress, STYLABLE_ELEMENT, STYLABLE_ELEMENT_STATE, STYLE, SUPPORTED_CARD_TYPES, type Shipping, TEXT, TOKEN_TYPE, TRIGGER, TYPE, VAULT_DISPLAY_STYLE, type VaultDisplayStyle, VaultDisplayWidget, WALLET_TYPES, WalletButtons, type WalletType, ZipmoneyCheckoutButton };