@xsolla/payment-client-core 0.2.44 → 0.2.46

package/fesm2022/xsolla-payment-client-core.mjs

@@ -1,10 +1,10 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Inject, Pipe, isDevMode, NgModule } from '@angular/core';
+import { InjectionToken, Injectable, Inject, isDevMode, Pipe, NgModule } from '@angular/core';
 import { firstValueFrom, lastValueFrom, map, Subject, BehaviorSubject, filter as filter$1, takeUntil, skip, take, of, interval, throwError } from 'rxjs';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpHeaders, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { UntypedFormGroup, Validators, UntypedFormControl, FormGroup, ReactiveFormsModule } from '@angular/forms';
 import JSEncrypt from 'jsencrypt';
-import { UntypedFormGroup, Validators, UntypedFormControl, ReactiveFormsModule } from '@angular/forms';
 import { filter, map as map$1, tap, debounce, debounceTime, catchError } from 'rxjs/operators';
 import * as i1$1 from '@angular/router';
 import { CommonModule } from '@angular/common';
@@ -540,6 +540,7 @@ var FieldNames;
     FieldNames["description"] = "description";
     FieldNames["email"] = "email";
     FieldNames["psEmail"] = "psEmail";
+    FieldNames["psAccountCountry"] = "psAccountCountry";
     FieldNames["bazitemail"] = "bazitemail";
     FieldNames["euCheck"] = "eu_check";
     FieldNames["extraCvv"] = "extra_cvv";
@@ -595,6 +596,8 @@ var FieldNames;
     FieldNames["payInstanceAccountId"] = "payInstanceAccountId";
     FieldNames["getApplePaySessionUrl"] = "getApplePaySessionUrl";
     FieldNames["payViaCheckoutUrl"] = "payViaCheckoutUrl";
+    FieldNames["googlePayInitData"] = "googlePayInitData";
+    FieldNames["googlePayPaymentData"] = "googlePayPaymentData";
 })(FieldNames || (FieldNames = {}));
 
 class SubmitResponse {
@@ -685,6 +688,145 @@ var InputEventName;
 
 const googlePayPid = 3431;
 
+var ErrorTags;
+(function (ErrorTags) {
+    ErrorTags["APP"] = "appError";
+    ErrorTags["HTTP"] = "httpError";
+    ErrorTags["JS"] = "jsError";
+    ErrorTags["WS"] = "webSocket";
+    ErrorTags["ENCRYPT"] = "encrypt";
+    ErrorTags["APPLEPAY"] = "applepay";
+    ErrorTags["HEADLESS_UI"] = "headlessUi";
+    ErrorTags["GOOGLEPAY"] = "googlepay";
+    ErrorTags["PAYTM"] = "paytm";
+})(ErrorTags || (ErrorTags = {}));
+
+class TaggedError extends Error {
+    constructor(message, tags) {
+        super(message);
+        this.tags = [];
+        this.parentTag = ErrorTags.HEADLESS_UI;
+        this.tags = this.childTag
+            ? [this.parentTag, this.childTag]
+            : [this.parentTag];
+        if (tags) {
+            const newTags = tags.filter((t, i, arr) => !this.tags.includes(t) && arr.indexOf(t) == i);
+            this.tags = [...this.tags, ...newTags];
+        }
+    }
+}
+
+class ElkLoggerService {
+    constructor(window, settingsService, http, ngZone) {
+        this.window = window;
+        this.settingsService = settingsService;
+        this.http = http;
+        this.ngZone = ngZone;
+        this.vendors = new RegExp('node_modules\\/(@angular|zone).*.js$');
+        this.stackTrace = this.loadStackTrace();
+    }
+    handleError(error) {
+        this.ngZone.runOutsideAngular(() => {
+            if (isDevMode()) {
+                console.error(error);
+                return;
+            }
+            this.parseError(error).catch(console.log);
+        });
+    }
+    log(message, tags, extra) {
+        const logTags = [ErrorTags.HEADLESS_UI, ...tags];
+        if (isDevMode()) {
+            console.log(message, tags);
+            return;
+        }
+        const logMessage = {
+            additionalInfo: this.getAdditionalInfo(),
+            extra,
+            message,
+        };
+        this.sendLog(logMessage, logTags);
+    }
+    async parseError(error) {
+        const errorObj = error instanceof TaggedError
+            ? error
+            : new TaggedError(error.message || error.toString());
+        errorObj.trace = await this.getErrorTrace(errorObj);
+        errorObj.additionalInfo = this.getAdditionalInfo();
+        const { tags } = errorObj;
+        const cleanError = this.removeErrorMetaFields(errorObj);
+        this.sendLog(cleanError, tags);
+        return errorObj;
+    }
+    async loadStackTrace() {
+        const library = await import('stacktrace-js');
+        return library.default;
+    }
+    async getErrorTrace(error) {
+        const stackTrace = await this.stackTrace;
+        const stackFramesArr = await stackTrace.fromError(error);
+        const filteredFramesArr = stackFramesArr.filter(({ fileName }) => fileName && !this.vendors.test(fileName));
+        return filteredFramesArr
+            .map((stackFrame) => stackFrame.toString())
+            .join('\n');
+    }
+    getAdditionalInfo() {
+        const extractUrlHost = (url) => url.replace(/^https?:\/\/([^/?#]+).*$/i, '$1');
+        return {
+            location: {
+                url: this.window.location.href,
+            },
+            project: {
+                id: this.settingsService.project.id,
+            },
+            referrer: {
+                url: this.window.document.referrer,
+            },
+            viewport: {
+                width: this.window.document.documentElement.clientWidth,
+                height: this.window.document.documentElement.clientHeight,
+            },
+            cdn_address: this.settingsService.settings.cdnUrl
+                ? extractUrlHost(this.settingsService.settings.cdnUrl)
+                : 'none',
+            country: this.settingsService.user.country.value,
+            local: this.settingsService.user.country.localized_name,
+        };
+    }
+    removeErrorMetaFields(error) {
+        const metaPropList = [
+            'parentTag',
+            'childTag',
+            'RESTRICTED_KEYS_REGEXP',
+            'tags',
+        ];
+        Object.keys(error).forEach((key) => {
+            if (metaPropList.includes(key))
+                delete error[key];
+        });
+        // implementing own 'message' property from prototype
+        return { ...error, message: error.message };
+    }
+    sendLog(message, tags) {
+        const url = `https://logs-01.xsolla.com/tag/${tags.join(',')}`;
+        firstValueFrom(this.http.post(url, message, {
+            headers: new HttpHeaders().set('Content-Type', 'text/plain'),
+            responseType: 'text',
+        })).catch((err) => console.error('Elk Logger: request error', err));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, deps: [{ token: windowToken }, { token: SettingsService }, { token: i1.HttpClient }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: SettingsService }, { type: i1.HttpClient }, { type: i0.NgZone }] });
+
 const initializeResponseFactoryToken = new InjectionToken('InitializeResponse');
 const initializeResponseFactoryProvider = {
     provide: initializeResponseFactoryToken,
@@ -1923,34 +2065,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: UnescapeHtmlPipe }] });
 
-var ErrorTags;
-(function (ErrorTags) {
-    ErrorTags["APP"] = "appError";
-    ErrorTags["HTTP"] = "httpError";
-    ErrorTags["JS"] = "jsError";
-    ErrorTags["WS"] = "webSocket";
-    ErrorTags["ENCRYPT"] = "encrypt";
-    ErrorTags["APPLEPAY"] = "applepay";
-    ErrorTags["HEADLESS_UI"] = "headlessUi";
-    ErrorTags["GOOGLEPAY"] = "googlepay";
-    ErrorTags["PAYTM"] = "paytm";
-})(ErrorTags || (ErrorTags = {}));
-
-class TaggedError extends Error {
-    constructor(message, tags) {
-        super(message);
-        this.tags = [];
-        this.parentTag = ErrorTags.HEADLESS_UI;
-        this.tags = this.childTag
-            ? [this.parentTag, this.childTag]
-            : [this.parentTag];
-        if (tags) {
-            const newTags = tags.filter((t, i, arr) => !this.tags.includes(t) && arr.indexOf(t) == i);
-            this.tags = [...this.tags, ...newTags];
-        }
-    }
-}
-
 class EncryptCreditCardError extends TaggedError {
     constructor(message, tags) {
         tags = tags ? [...tags, ErrorTags.ENCRYPT] : [ErrorTags.ENCRYPT];
@@ -2939,6 +3053,8 @@ class SyncRequest extends XpsApiPartRequest {
         this.addXpsParameters({
             ...fieldsValues,
             change_element: changedField.name,
+            fix_command: changedField.javascript?.change?.staticParams?.fix_command ??
+                this.xps_fix_command,
         });
     }
     getFieldsValues(changedField, fields, form) {
@@ -3070,13 +3186,13 @@ class SyncService extends EmitDataService {
         const control = this.form.get(field.name);
         return control?.errors ?? null;
     }
-    async request(field) {
+    async request(field, fields, form) {
         const paymentSettingsParams = this.paymentSettingsService.getPaymentSettingsParams(this.paymentConfiguration);
         const requestParams = this.requestFactory({
             token: this.settingsService.token,
             changedField: field,
-            fields: this.fields,
-            form: this.form,
+            fields: fields ?? this.fields,
+            form: form ?? this.form,
             ...paymentSettingsParams,
         });
         const encryptedRequest = this.encryptCreditCardService.encryptCreditCard(requestParams);
@@ -5149,6 +5265,9 @@ class FinanceDetailsService extends EmitDataService {
             super.emit(financeDetails);
         }
     }
+    getDetailsFromSummary(summary) {
+        return this.summaryFinanceDetailsAdapterService.getFinanceDetails(summary);
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FinanceDetailsService, deps: [{ token: SessionService }, { token: SummaryFinanceDetailsAdapterService }, { token: StatusFinanceDetailsAdapterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FinanceDetailsService, providedIn: 'root' }); }
 }
@@ -5368,166 +5487,55 @@ class WsError extends TaggedError {
     }
 }
 
-class ElkLoggerService {
-    constructor(window, settingsService, http, ngZone) {
-        this.window = window;
-        this.settingsService = settingsService;
-        this.http = http;
-        this.ngZone = ngZone;
-        this.vendors = new RegExp('node_modules\\/(@angular|zone).*.js$');
-        this.stackTrace = this.loadStackTrace();
+class CentrifugoWebSocketService {
+    static { this.reconnectionTimeoutIncrementFactor = 2; }
+    static { this.timeoutsMs = {
+        reconnection: 1000,
+        reconnectionMaxDeviation: 1000,
+    }; }
+    constructor(elkLoggerService) {
+        this.elkLoggerService = elkLoggerService;
+        this.type = WebSocketClientType.centrifugo;
+        this.reconnectionTimerId = null;
+        this.isConnectionOpen = false;
+        this.isConnecting = false;
+        this.incomingMessages$ = new Subject();
+        this.successfulReconnectionEventsProxy$ = new Subject();
     }
-    handleError(error) {
-        this.ngZone.runOutsideAngular(() => {
-            if (isDevMode()) {
-                console.error(error);
-                return;
-            }
-            this.parseError(error).catch(console.log);
-        });
+    async open(url, channel) {
+        if (url === this.url && channel === this.channel) {
+            return;
+        }
+        try {
+            this.url = url;
+            this.channel = channel;
+            await this.createConnection(url, channel);
+        }
+        catch (error) {
+            // @ts-expect-error error is unknown
+            const message = (error?.message || error);
+            const unknownError = new WsError(`unknown websocket error: ${message}`, channel);
+            this.elkLoggerService.handleError(unknownError);
+        }
     }
-    log(message, tags, extra) {
-        const logTags = [ErrorTags.HEADLESS_UI, ...tags];
-        if (isDevMode()) {
-            console.log(message, tags);
+    close() {
+        this.clearReconnectionTimer();
+        if (!this.isConnectionOpen) {
             return;
         }
-        const logMessage = {
-            additionalInfo: this.getAdditionalInfo(),
-            extra,
-            message,
-        };
-        this.sendLog(logMessage, logTags);
+        this.connection.disconnect();
     }
-    async parseError(error) {
-        const errorObj = error instanceof TaggedError
-            ? error
-            : new TaggedError(error.message || error.toString());
-        errorObj.trace = await this.getErrorTrace(errorObj);
-        errorObj.additionalInfo = this.getAdditionalInfo();
-        const { tags } = errorObj;
-        const cleanError = this.removeErrorMetaFields(errorObj);
-        this.sendLog(cleanError, tags);
-        return errorObj;
+    get messages$() {
+        return (this.incomingMessages$
+            .asObservable()
+            // event don't respect type from argument, it's weird
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            .pipe(map$1((event) => event.data)));
     }
-    async loadStackTrace() {
-        const library = await import('stacktrace-js');
-        return library.default;
-    }
-    async getErrorTrace(error) {
-        const stackTrace = await this.stackTrace;
-        const stackFramesArr = await stackTrace.fromError(error);
-        const filteredFramesArr = stackFramesArr.filter(({ fileName }) => fileName && !this.vendors.test(fileName));
-        return filteredFramesArr
-            .map((stackFrame) => stackFrame.toString())
-            .join('\n');
-    }
-    getAdditionalInfo() {
-        const extractUrlHost = (url) => url.replace(/^https?:\/\/([^/?#]+).*$/i, '$1');
-        return {
-            location: {
-                url: this.window.location.href,
-            },
-            project: {
-                id: this.settingsService.project.id,
-            },
-            referrer: {
-                url: this.window.document.referrer,
-            },
-            viewport: {
-                width: this.window.document.documentElement.clientWidth,
-                height: this.window.document.documentElement.clientHeight,
-            },
-            cdn_address: this.settingsService.settings.cdnUrl
-                ? extractUrlHost(this.settingsService.settings.cdnUrl)
-                : 'none',
-            country: this.settingsService.user.country.value,
-            local: this.settingsService.user.country.localized_name,
-        };
-    }
-    removeErrorMetaFields(error) {
-        const metaPropList = [
-            'parentTag',
-            'childTag',
-            'RESTRICTED_KEYS_REGEXP',
-            'tags',
-        ];
-        Object.keys(error).forEach((key) => {
-            if (metaPropList.includes(key))
-                delete error[key];
-        });
-        // implementing own 'message' property from prototype
-        return { ...error, message: error.message };
-    }
-    sendLog(message, tags) {
-        const url = `https://logs-01.xsolla.com/tag/${tags.join(',')}`;
-        firstValueFrom(this.http.post(url, message, {
-            headers: new HttpHeaders().set('Content-Type', 'text/plain'),
-            responseType: 'text',
-        })).catch((err) => console.error('Elk Logger: request error', err));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, deps: [{ token: windowToken }, { token: SettingsService }, { token: i1.HttpClient }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [windowToken]
-                }] }, { type: SettingsService }, { type: i1.HttpClient }, { type: i0.NgZone }] });
-
-class CentrifugoWebSocketService {
-    static { this.reconnectionTimeoutIncrementFactor = 2; }
-    static { this.timeoutsMs = {
-        reconnection: 1000,
-        reconnectionMaxDeviation: 1000,
-    }; }
-    constructor(elkLoggerService) {
-        this.elkLoggerService = elkLoggerService;
-        this.type = WebSocketClientType.centrifugo;
-        this.reconnectionTimerId = null;
-        this.isConnectionOpen = false;
-        this.isConnecting = false;
-        this.incomingMessages$ = new Subject();
-        this.successfulReconnectionEventsProxy$ = new Subject();
-    }
-    async open(url, channel) {
-        if (url === this.url && channel === this.channel) {
-            return;
-        }
-        try {
-            this.url = url;
-            this.channel = channel;
-            await this.createConnection(url, channel);
-        }
-        catch (error) {
-            // @ts-expect-error error is unknown
-            const message = (error?.message || error);
-            const unknownError = new WsError(`unknown websocket error: ${message}`, channel);
-            this.elkLoggerService.handleError(unknownError);
-        }
-    }
-    close() {
-        this.clearReconnectionTimer();
-        if (!this.isConnectionOpen) {
-            return;
-        }
-        this.connection.disconnect();
-    }
-    get messages$() {
-        return (this.incomingMessages$
-            .asObservable()
-            // event don't respect type from argument, it's weird
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            .pipe(map$1((event) => event.data)));
-    }
-    subscribeOnSuccessfulReconnection(next) {
-        return this.successfulReconnectionEventsProxy$
-            .asObservable()
-            .subscribe(next);
+    subscribeOnSuccessfulReconnection(next) {
+        return this.successfulReconnectionEventsProxy$
+            .asObservable()
+            .subscribe(next);
     }
     clearReconnectionTimer() {
         if (this.reconnectionTimerId) {
@@ -6117,6 +6125,88 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
                 }]
         }] });
 
+class InitializeSpecialButtonActionCreator {
+    constructor(elkLoggerService) {
+        this.elkLoggerService = elkLoggerService;
+        this.type = 'special_button';
+        this.pids = [googlePayPid];
+        this.sdkPaymentMethodsName = new Map([
+            [googlePayPid, 'google-pay'],
+        ]);
+    }
+    getActionData(response) {
+        return {
+            type: this.type,
+            data: {
+                buttonName: this.getPaymentMethodName(response.paymentForm?.pid),
+            },
+        };
+    }
+    isSuitable(response) {
+        if (!response.paymentForm)
+            return false;
+        const hasGooglePayInitDataField = response.paymentForm.fields.some((field) => field.name === FieldNames.googlePayInitData);
+        return (this.pids.includes(response.paymentForm.pid) && hasGooglePayInitDataField);
+    }
+    getPaymentMethodName(pid = 0) {
+        const buttonName = this.sdkPaymentMethodsName.get(pid);
+        if (!buttonName) {
+            this.elkLoggerService.log('No special button for provided pid', [ErrorTags.GOOGLEPAY], {
+                pid,
+            });
+            throw new Error('Special button not found');
+        }
+        return buttonName;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeSpecialButtonActionCreator, deps: [{ token: ElkLoggerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeSpecialButtonActionCreator }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeSpecialButtonActionCreator, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: ElkLoggerService }] });
+
+const initializeNextActionsToken = new InjectionToken('InitializeNextActions');
+const initializeNextActions = [
+    InitializeSpecialButtonActionCreator,
+];
+
+class InitializeNextActionService {
+    constructor(initializeNextActionTokens, injector) {
+        this.initializeNextActionTokens = initializeNextActionTokens;
+        this.injector = injector;
+        this.initializeNextActionsList = [];
+        this.fillNextActionsList();
+    }
+    getNextAction(response) {
+        const nextAction = this.findNextAction(response);
+        if (!nextAction)
+            return null;
+        return nextAction.getActionData(response);
+    }
+    fillNextActionsList() {
+        this.initializeNextActionTokens.forEach((nextAction) => {
+            const item = this.injector.get(nextAction);
+            this.initializeNextActionsList.push(item);
+        });
+    }
+    findNextAction(response) {
+        return this.initializeNextActionsList.find((nextAction) => {
+            return nextAction.isSuitable(response);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeNextActionService, deps: [{ token: initializeNextActionsToken }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeNextActionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeNextActionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [initializeNextActionsToken]
+                }] }, { type: i0.Injector }] });
+
 var ThreeDsStatusWebSocketTypes;
 (function (ThreeDsStatusWebSocketTypes) {
     ThreeDsStatusWebSocketTypes["status3DS_changed"] = "status3DS_changed";
@@ -6608,7 +6698,8 @@ class PaymentService {
     get formResponseValue() {
         return this._formResponse$.getValue();
     }
-    constructor(initializeService, submitService, syncService, formService, statusService, financeDetailsService, creditCardStateService, nextActionService, controlConfigService, threeDsService, formMessagesService, settingsService, countryService, checkStatusActionCreator, printInstructionService) {
+    constructor(elkLoggerService, initializeService, submitService, syncService, formService, statusService, financeDetailsService, creditCardStateService, nextActionService, initializeNextActionService, controlConfigService, threeDsService, formMessagesService, settingsService, countryService, checkStatusActionCreator, printInstructionService) {
+        this.elkLoggerService = elkLoggerService;
         this.initializeService = initializeService;
         this.submitService = submitService;
         this.syncService = syncService;
@@ -6617,6 +6708,7 @@ class PaymentService {
         this.financeDetailsService = financeDetailsService;
         this.creditCardStateService = creditCardStateService;
         this.nextActionService = nextActionService;
+        this.initializeNextActionService = initializeNextActionService;
         this.controlConfigService = controlConfigService;
         this.threeDsService = threeDsService;
         this.formMessagesService = formMessagesService;
@@ -6661,6 +6753,7 @@ class PaymentService {
         return {
             fields: this.fields.filter((field) => field?.isVisible === "1" /* XpsBoolean.true */),
             isFormAutoSubmitted: isNeedAutoSubmit,
+            nextAction: this.initializeNextActionService.getNextAction(this.data),
         };
     }
     async submit() {
@@ -6692,6 +6785,26 @@ class PaymentService {
         this.syncService.setup(this.form, this.fields, this.config);
         return this.nextActionService.getNextAction(submitResponse);
     }
+    async submitWithFields(fields) {
+        if (!this.form) {
+            this.elkLoggerService.log('submit error: trying to submit with no form', [
+                ErrorTags.GOOGLEPAY,
+            ]);
+            throw new Error('form is empty!');
+        }
+        this.isSavingMethodMode = this.fields.some(({ name, value }) => name === 'savePsAccountOnly' && value === "1" /* XpsBoolean.true */);
+        const submitResponse = await this.submitService.request(fields ?? this.fields, this.form, this.config);
+        this.data = submitResponse;
+        this.emitFormResponse(this.data);
+        if (!this.isSavingMethodMode) {
+            this.emitFinanceDetails(submitResponse.summary);
+        }
+        this.emitFormMessages(submitResponse.messages);
+        this.fields = this.getFields();
+        this.form = this.formService.createForm(this.fields);
+        this.syncService.setup(this.form, this.fields, this.config);
+        return submitResponse;
+    }
     getFields() {
         if (this.data instanceof SubmitResponse) {
             return this.data.fields ?? [];
@@ -6709,17 +6822,21 @@ class PaymentService {
             status: control.status,
         };
     }
-    getInitialDataForSdkPaymentSystems() {
-        if (!isSubmitResponse(this.data)) {
+    async getInitialDataForSdkPaymentSystems() {
+        if (!this.data) {
             throw new Error('Should submit form first');
         }
-        return {
-            data: this.data.parameters.checkout.data.data,
+        const sdkPaymentData = this.getSdkPaymentDataFromResponse(this.data);
+        return Promise.resolve({
+            data: sdkPaymentData.checkoutData,
             sandbox: this.settingsService.isSandboxMode()
                 ? "1" /* XpsBoolean.true */
                 : "0" /* XpsBoolean.false */,
             country: this.countryService.getCountry(),
-        };
+            fields: sdkPaymentData.fields,
+            submitResponse: isSubmitResponse(this.data) ? this.data : null,
+            summary: sdkPaymentData.summary,
+        });
     }
     getQrCode() {
         if (!isSubmitResponse(this.data)) {
@@ -6771,6 +6888,9 @@ class PaymentService {
         }
         return this.syncService.validate(field);
     }
+    async calculateField(changedField, fields) {
+        return this.syncService.request(changedField, fields, new FormGroup({}));
+    }
     runThreeDs() {
         if (!isSubmitResponse(this.data)) {
             throw new Error('Should submit form first');
@@ -6975,7 +7095,21 @@ class PaymentService {
             (visibleFields.length === 0 &&
                 suitablePids.includes(response.paymentForm.pid)));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentService, deps: [{ token: InitializeService }, { token: SubmitService }, { token: SyncService }, { token: FormService }, { token: StatusService }, { token: FinanceDetailsService }, { token: CreditCardStateService }, { token: NextActionService }, { token: ControlConfigService }, { token: ThreeDsService }, { token: FormMessagesService }, { token: SettingsService }, { token: CountryService }, { token: CheckStatusActionCreator }, { token: PrintInstructionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    getSdkPaymentDataFromResponse(data) {
+        if (isSubmitResponse(data)) {
+            return {
+                checkoutData: data.parameters.checkout.data.data,
+                fields: data.fields,
+                summary: data.summary,
+            };
+        }
+        return {
+            checkoutData: null,
+            fields: data.paymentForm?.fields ?? [],
+            summary: data.paymentForm?.summary ?? null,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentService, deps: [{ token: ElkLoggerService }, { token: InitializeService }, { token: SubmitService }, { token: SyncService }, { token: FormService }, { token: StatusService }, { token: FinanceDetailsService }, { token: CreditCardStateService }, { token: NextActionService }, { token: InitializeNextActionService }, { token: ControlConfigService }, { token: ThreeDsService }, { token: FormMessagesService }, { token: SettingsService }, { token: CountryService }, { token: CheckStatusActionCreator }, { token: PrintInstructionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentService, decorators: [{
@@ -6983,7 +7117,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: InitializeService }, { type: SubmitService }, { type: SyncService }, { type: FormService }, { type: StatusService }, { type: FinanceDetailsService }, { type: CreditCardStateService }, { type: NextActionService }, { type: ControlConfigService }, { type: ThreeDsService }, { type: FormMessagesService }, { type: SettingsService }, { type: CountryService }, { type: CheckStatusActionCreator }, { type: PrintInstructionService }] });
+        }], ctorParameters: () => [{ type: ElkLoggerService }, { type: InitializeService }, { type: SubmitService }, { type: SyncService }, { type: FormService }, { type: StatusService }, { type: FinanceDetailsService }, { type: CreditCardStateService }, { type: NextActionService }, { type: InitializeNextActionService }, { type: ControlConfigService }, { type: ThreeDsService }, { type: FormMessagesService }, { type: SettingsService }, { type: CountryService }, { type: CheckStatusActionCreator }, { type: PrintInstructionService }] });
 
 const euCountries = new Set([
     'AT',
@@ -7653,7 +7787,12 @@ class CoreLibraryService {
             deleteSavedMethod: async (id, type) => this.editSavedMethodsService.deleteSavedMethodRequest(id, type),
         };
         this.sdkPaymentSystems = {
-            getInitialData: () => this.paymentService.getInitialDataForSdkPaymentSystems(),
+            getInitialData: async () => this.paymentService.getInitialDataForSdkPaymentSystems(),
+        };
+        this.finance = {
+            getDetailsFromSummary: (summary) => {
+                return this.financeDetailsService.getDetailsFromSummary(summary);
+            },
         };
     }
     async init(configuration) {
@@ -7666,6 +7805,12 @@ class CoreLibraryService {
     async getStatus(url) {
         return this.statusService.getStatusWithUrlSearchParams(url);
     }
+    async calculateField(changedField, fields) {
+        return this.paymentService.calculateField(changedField, fields);
+    }
+    async submit(fields) {
+        return this.paymentService.submitWithFields(fields);
+    }
     sendAnalytics(action, type, options) {
         this.userBehaviourAnalyticsService.send(action, type, options);
     }
@@ -7752,6 +7897,9 @@ class CoreLibraryService {
     get formResponseValue() {
         return this.paymentService.formResponseValue;
     }
+    get projectSettings() {
+        return this.settingsService.project;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CoreLibraryService, deps: [{ token: SettingsService }, { token: CountryService }, { token: PaymentMethodsService }, { token: SavedMethodsService }, { token: UserBalanceService }, { token: PaymentConfigService }, { token: PaymentService }, { token: DeviceFingerPrintService }, { token: FinanceDetailsService }, { token: LegalService }, { token: StatusService }, { token: NextActionService }, { token: CreditCardService }, { token: CreditCardStateService }, { token: FormMessagesService }, { token: EditSavedMethodsService }, { token: UserBehaviourAnalyticsService }, { token: PerformanceService }, { token: CombinedPaymentMethodsService }, { token: CountriesApiService }, { token: SendInstructionService }, { token: ScriptTrackerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CoreLibraryService, providedIn: 'root' }); }
 }
@@ -7916,6 +8064,176 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
                 }]
         }] });
 
+const applePayVersion = 3;
+
+var ApplePayErrors;
+(function (ApplePayErrors) {
+    ApplePayErrors["paymentError"] = "Apple Pay: payment error";
+    ApplePayErrors["deviceIsNotCapableError"] = "Apple Pay: device is not capable";
+    ApplePayErrors["cancelled"] = "Apple Pay: payment cancelled";
+    ApplePayErrors["merchantValidationError"] = "Apple Pay: merchant validation error";
+    ApplePayErrors["braintreeInitializeError"] = "Apple Pay: Braintree library is not initialized";
+})(ApplePayErrors || (ApplePayErrors = {}));
+
+class ApplePaySessionHandlerAbstract {
+    constructor() {
+        this.payment = new Subject();
+        this._errorSubject = new Subject();
+    }
+    get error$() {
+        return this._errorSubject.asObservable();
+    }
+    get payment$() {
+        return this.payment.asObservable();
+    }
+    emitError(error) {
+        this._errorSubject.next(error);
+    }
+    buildPaymentRequest(params) {
+        return {
+            total: {
+                label: params.totalLabel,
+                amount: params.totalAmount,
+            },
+            currencyCode: params.currencyCode,
+            countryCode: params.countryCode,
+            merchantCapabilities: params.merchantCapabilities,
+            requiredBillingContactFields: params.requiredBillingContactFields,
+            requiredShippingContactFields: params.requiredShippingContactFields,
+            supportedNetworks: params.supportedNetworks,
+        };
+    }
+}
+
+class BraintreeHandler extends ApplePaySessionHandlerAbstract {
+    constructor(window, elkLoggerService) {
+        super();
+        this.window = window;
+        this.elkLoggerService = elkLoggerService;
+        this.paymentClient = null;
+    }
+    setClient(client) {
+        this.paymentClient = client;
+    }
+    startSession(params, iframeIntegrationEnabled) {
+        if (!this.paymentClient) {
+            console.error(ApplePayErrors.braintreeInitializeError);
+            this.elkLoggerService.log(ApplePayErrors.braintreeInitializeError, [
+                ErrorTags.APPLEPAY,
+            ]);
+            return;
+        }
+        const request = this.buildPaymentRequest(params);
+        const applePayRequest = this.paymentClient.createPaymentRequest(request);
+        const session = new this.window.ApplePaySession(applePayVersion, applePayRequest);
+        session.onvalidatemerchant = (event) => {
+            const validationParams = {
+                validationURL: event.validationURL,
+                displayName: params.totalLabel,
+            };
+            if (iframeIntegrationEnabled && params.topLevelDomain) {
+                // @ts-expect-error unknown property
+                validationParams.domainName = params.topLevelDomain;
+            }
+            this.paymentClient
+                ?.performValidation(validationParams)
+                .then((merchantSession) => {
+                session.completeMerchantValidation(merchantSession);
+            })
+                .catch((error) => {
+                console.error(ApplePayErrors.merchantValidationError, error);
+                session.abort();
+            });
+        };
+        session.onpaymentauthorized = (event) => {
+            this.paymentClient
+                ?.tokenize({ token: event.payment.token })
+                .then((response) => {
+                this.payment.next(JSON.stringify({
+                    token: response?.nonce ?? '',
+                    email: event.payment.billingContact?.emailAddress ?? null,
+                    postalCode: event.payment.billingContact?.postalCode ?? null,
+                }));
+                session.completePayment(this.window.ApplePaySession.STATUS_SUCCESS);
+            })
+                .catch((error) => {
+                console.error('Apple Pay: Tokenization error', error);
+                session.completePayment(this.window.ApplePaySession.STATUS_FAILURE);
+            });
+        };
+        session.oncancel = () => {
+            console.error(ApplePayErrors.cancelled);
+            this.emitError(ApplePayErrors.cancelled);
+        };
+        session.begin();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: BraintreeHandler, deps: [{ token: windowToken }, { token: ElkLoggerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: BraintreeHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: BraintreeHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: ElkLoggerService }] });
+
+class CheckoutHandler extends ApplePaySessionHandlerAbstract {
+    constructor(window, http) {
+        super();
+        this.window = window;
+        this.http = http;
+    }
+    startSession(params, iframeIntegrationEnabled) {
+        const request = this.buildPaymentRequest(params);
+        const session = new this.window.ApplePaySession(applePayVersion, request);
+        session.onvalidatemerchant = (event) => {
+            const validationParams = {
+                validationURL: event.validationURL,
+                accountId: params.payInstanceAccountId,
+                isSandbox: params.isSandbox,
+            };
+            if (iframeIntegrationEnabled && params.topLevelDomain) {
+                // @ts-expect-error unknown property
+                validationParams.domainName = params.topLevelDomain;
+            }
+            this.http
+                .post(params.getApplePaySessionUrl, JSON.stringify(validationParams), {
+                headers: new HttpHeaders().set('Content-Type', 'application/json'),
+            })
+                .subscribe({
+                next: (response) => {
+                    session.completeMerchantValidation(response.merchantSession);
+                },
+                error: (error) => {
+                    console.error(ApplePayErrors.merchantValidationError, error);
+                    session.abort();
+                },
+            });
+        };
+        session.onpaymentauthorized = (event) => {
+            this.payment.next(JSON.stringify({
+                token: event.payment.token ?? '',
+                email: event.payment.billingContact?.emailAddress ?? null,
+                postalCode: event.payment.billingContact?.postalCode ?? null,
+            }));
+            session.completePayment(this.window.ApplePaySession.STATUS_SUCCESS);
+        };
+        session.oncancel = () => {
+            console.error(ApplePayErrors.cancelled);
+            this.emitError(ApplePayErrors.cancelled);
+        };
+        session.begin();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CheckoutHandler, deps: [{ token: windowToken }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CheckoutHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CheckoutHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: i1.HttpClient }] });
+
 class CoreLibraryModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CoreLibraryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: CoreLibraryModule, imports: [HttpClientModule, FormModule, PipesModule] }); }
@@ -7945,11 +8263,18 @@ class CoreLibraryModule {
                 provide: nextActionsToken,
                 useValue: nextActions,
             },
+            {
+                provide: initializeNextActionsToken,
+                useValue: initializeNextActions,
+            },
             ...nextActions,
+            ...initializeNextActions,
             ...flowUpdateNextActions,
             printInstructionRequestFactoryProvider,
             sendInstructionRequestFactoryProvider,
             sendInstructionStatusResponseFactoryProvider,
+            BraintreeHandler,
+            CheckoutHandler,
         ], imports: [HttpClientModule, FormModule, PipesModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CoreLibraryModule, decorators: [{
@@ -7982,11 +8307,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
                             provide: nextActionsToken,
                             useValue: nextActions,
                         },
+                        {
+                            provide: initializeNextActionsToken,
+                            useValue: initializeNextActions,
+                        },
                         ...nextActions,
+                        ...initializeNextActions,
                         ...flowUpdateNextActions,
                         printInstructionRequestFactoryProvider,
                         sendInstructionRequestFactoryProvider,
                         sendInstructionStatusResponseFactoryProvider,
+                        BraintreeHandler,
+                        CheckoutHandler,
                     ],
                 }]
         }] });
@@ -8069,6 +8401,195 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
                     args: [windowToken]
                 }] }] });
 
+class GooglePayCheckoutPaymentService {
+    constructor(paymentSystemProcessingService) {
+        this.paymentSystemProcessingService = paymentSystemProcessingService;
+        this.checkout = null;
+    }
+    preparePayment({ initParams, checkDeviceData, }) {
+        if (!initParams || !checkDeviceData.base64checkoutData)
+            return null;
+        this.initParams = initParams;
+        this.checkout =
+            this.paymentSystemProcessingService.getDecodedCheckout(checkDeviceData.base64checkoutData);
+        if (!this.checkout)
+            return null;
+        const checkoutData = this.checkout.request.form.fields;
+        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
+        const isReadyToPayRequest = JSON.parse(checkoutData.isReadyToPayRequest);
+        const result = { paymentDataRequest, isReadyToPayRequest };
+        if (checkoutData.amexCardNotification) {
+            result.amexCardNotification = JSON.parse(checkoutData.amexCardNotification);
+        }
+        return result;
+    }
+    getPaymentRequest() {
+        if (!this.checkout)
+            return null;
+        const checkoutData = this.checkout.request.form.fields;
+        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
+        paymentDataRequest.transactionInfo = {
+            currencyCode: checkoutData.currency,
+            totalPriceStatus: 'FINAL',
+            totalPrice: checkoutData.sum?.toString(),
+            countryCode: this.initParams.country.toUpperCase(),
+        };
+        return paymentDataRequest;
+    }
+    getAllowedPaymentMethods() {
+        if (!this.checkout)
+            return [];
+        const paymentDataRequest = JSON.parse(this.checkout.request.form.fields.paymentDataRequest);
+        return paymentDataRequest.allowedPaymentMethods;
+    }
+    handleSuccessfulPayment(response) {
+        if (!this.checkout)
+            return;
+        let returnUrl = this.checkout.request.form.fields.returnSuccessUrl;
+        const data = this.checkout.request.form.fields;
+        returnUrl += `&cpf_number=${data.cpf_number}&descriptor=${data.descriptor}&paymentData=${JSON.stringify(response)}`;
+        this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+    }
+    handleFailedPayment(error) {
+        if (!this.checkout)
+            return;
+        const statusCode = error?.statusCode;
+        const isStatusCanceled = statusCode && this.isCancelledStatus(statusCode);
+        if (isStatusCanceled)
+            return;
+        const returnUrl = this.checkout.request.form.fields.returnFailUrl;
+        this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+    }
+    isCancelledStatus(statusCode) {
+        return statusCode.toLowerCase() === 'canceled';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayCheckoutPaymentService, deps: [{ token: PaymentSystemProcessingService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayCheckoutPaymentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayCheckoutPaymentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: PaymentSystemProcessingService }] });
+
+class GooglePayInstantPaymentService {
+    constructor(summaryFinanceDetailsAdapterService) {
+        this.summaryFinanceDetailsAdapterService = summaryFinanceDetailsAdapterService;
+        this.googleInitData = null;
+    }
+    preparePayment({ initParams, checkDeviceData, }) {
+        if (!initParams)
+            return null;
+        this.initParams = initParams;
+        this.googleInitData = this.extractGoogleInitData(initParams.fields);
+        if (!this.googleInitData)
+            return null;
+        const displayItems = checkDeviceData.summary
+            ? this.getItemsTaxes(checkDeviceData.summary)
+            : [];
+        this.googleInitData.paymentDataRequest = {
+            ...this.googleInitData.paymentDataRequest,
+            transactionInfo: {
+                ...this.googleInitData.paymentDataRequest.transactionInfo,
+                totalPriceStatus: 'ESTIMATED',
+                totalPrice: this.googleInitData.paymentDataRequest.transactionInfo.totalPrice?.toString(),
+                countryCode: initParams.country.toUpperCase() ??
+                    this.googleInitData.paymentDataRequest.transactionInfo.countryCode?.toUpperCase(),
+                totalPriceLabel: this.googleInitData.paymentDataRequest.transactionInfo
+                    .totalPriceLabel ?? 'Total',
+                displayItems,
+            },
+            shippingAddressRequired: true,
+            callbackIntents: ['SHIPPING_ADDRESS', 'PAYMENT_AUTHORIZATION'],
+        };
+        return this.googleInitData;
+    }
+    getPaymentRequest() {
+        if (!this.googleInitData)
+            return null;
+        return {
+            ...this.googleInitData.paymentDataRequest,
+            transactionInfo: {
+                ...this.googleInitData.paymentDataRequest.transactionInfo,
+                totalPriceStatus: 'ESTIMATED',
+                totalPrice: this.googleInitData.paymentDataRequest.transactionInfo.totalPrice?.toString(),
+                countryCode: this.initParams.country.toUpperCase() ??
+                    this.googleInitData.paymentDataRequest.transactionInfo.countryCode?.toUpperCase(),
+            },
+            shippingAddressRequired: true,
+            callbackIntents: ['SHIPPING_ADDRESS', 'PAYMENT_AUTHORIZATION'],
+        };
+    }
+    getAllowedPaymentMethods() {
+        if (!this.googleInitData)
+            return [];
+        return this.googleInitData.paymentDataRequest.allowedPaymentMethods;
+    }
+    extractGoogleInitData(fields) {
+        try {
+            const googlePayInitData = fields.filter((field) => field.name === FieldNames.googlePayInitData)[0]?.value;
+            const data = JSON.parse(googlePayInitData ?? null);
+            return data;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    getItemsTaxes(summary) {
+        const financeResponse = this.summaryFinanceDetailsAdapterService.getFinanceDetails(summary);
+        const newCartPricing = financeResponse.cartSummary;
+        if (!newCartPricing.total?.money?.amount || !financeResponse.finance) {
+            return [];
+        }
+        const newPrice = {
+            total: this.getTotalAmount(financeResponse.finance),
+            subtotalDetails: newCartPricing.subtotalDetails,
+            subtotalPayment: newCartPricing.subtotalPayment,
+            totalDetails: newCartPricing.totalDetails,
+        };
+        const displayItems = [];
+        if (newPrice.subtotalPayment?.money?.amount) {
+            displayItems.push({
+                label: newPrice.subtotalPayment.title || 'Subtotal',
+                amount: newPrice.subtotalPayment.money?.amount.toString(),
+            });
+        }
+        let paymentsDetails = [];
+        if (newPrice.subtotalDetails?.length) {
+            paymentsDetails = newPrice.subtotalDetails;
+        }
+        if (newPrice.totalDetails?.length) {
+            paymentsDetails = paymentsDetails.concat(newPrice.totalDetails);
+        }
+        paymentsDetails.forEach((cartItem) => {
+            if (!cartItem.title || !cartItem.money?.amount) {
+                return;
+            }
+            displayItems.push({
+                label: cartItem.title,
+                amount: cartItem.money.amount.toString(),
+            });
+        });
+        return displayItems.map((item) => ({
+            label: item.label ?? '',
+            type: 'TAX',
+            price: item.amount,
+        }));
+    }
+    getTotalAmount(finance) {
+        return finance?.grand_total?.amount ?? finance?.total?.amount;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayInstantPaymentService, deps: [{ token: SummaryFinanceDetailsAdapterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayInstantPaymentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayInstantPaymentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: SummaryFinanceDetailsAdapterService }] });
+
 class GooglePayService {
     get libraryWasInitialized() {
         return !!this.window.google;
@@ -8076,14 +8597,17 @@ class GooglePayService {
     get googlePaymentClientWasInitialized() {
         return !!this.googlePaymentClient;
     }
-    constructor(window, paymentSystemProcessingService, injector) {
+    constructor(window, elkLoggerService, paymentSystemProcessingService, googlePayCheckoutPaymentService, googlePayInstantPaymentService, injector) {
         this.window = window;
+        this.elkLoggerService = elkLoggerService;
         this.paymentSystemProcessingService = paymentSystemProcessingService;
+        this.googlePayCheckoutPaymentService = googlePayCheckoutPaymentService;
+        this.googlePayInstantPaymentService = googlePayInstantPaymentService;
         this.injector = injector;
         this.googlePayScriptUrl = 'https://pay.google.com/gp/p/js/pay.js';
         this.readyToPay = new BehaviorSubject(null);
-        this.checkout = null;
         this.googlePaymentClient = null;
+        this.paymentService = null;
     }
     get readyToPay$() {
         return this.readyToPay.asObservable();
@@ -8092,8 +8616,9 @@ class GooglePayService {
         return this.readyToPay.getValue();
     }
     initGooglePayLibrary(data) {
-        this.isSandbox = data.isSandbox;
-        this.country = data.country;
+        this.initParams = data;
+        this.onPaymentDataChanged = data.onPaymentDataChanged;
+        this.onPaymentAuthorized = data.onPaymentAuthorized;
         if (this.libraryWasInitialized && this.googlePaymentClientWasInitialized) {
             return;
         }
@@ -8103,28 +8628,36 @@ class GooglePayService {
         }
         this.paymentSystemProcessingService.loadScript(this.googlePayScriptUrl, this.onLoadScript.bind(this));
     }
-    checkPaymentDevice(base64checkoutData) {
+    checkPaymentDevice(data) {
         this.paymentSystemProcessingService.initialize$
             .pipe(filter$1(Boolean), take(1))
             .subscribe(() => {
-            this.checkout =
-                this.paymentSystemProcessingService.getDecodedCheckout(base64checkoutData);
-            if (!this.checkout || !this.googlePaymentClient) {
-                throw new AppError(`Google Pay: no checkout or google payment client, checkout - ${Boolean(this.checkout).toString()}, client - ${Boolean(this.googlePaymentClient).toString()}`);
+            if (!this.googlePaymentClient) {
+                this.elkLoggerService.log('Google payment client is not initialized', [ErrorTags.GOOGLEPAY]);
+                throw new AppError(`Google Pay: Google payment client is not initialized`);
+            }
+            this.paymentService = this.getPaymentService();
+            const initData = this.paymentService.preparePayment({
+                initParams: this.initParams,
+                checkDeviceData: data,
+            });
+            if (!initData) {
+                this.elkLoggerService.log('No initialization data', [
+                    ErrorTags.GOOGLEPAY,
+                ]);
+                throw new AppError('Google Pay: no initialization data');
             }
-            const checkoutData = this.checkout.request.form.fields;
-            const isReadyToPayRequest = JSON.parse(checkoutData.isReadyToPayRequest);
             this.googlePaymentClient
-                .isReadyToPay(isReadyToPayRequest)
+                .isReadyToPay(initData.isReadyToPayRequest)
                 .then((response) => {
                 if (response.result && this.googlePaymentClient) {
-                    this.googlePaymentClient.prefetchPaymentData(JSON.parse(checkoutData.paymentDataRequest));
+                    this.googlePaymentClient.prefetchPaymentData(initData.paymentDataRequest);
                     return this.readyToPay.next(true);
                 }
                 this.readyToPay.next(false);
                 const result = response.result?.toString() ?? '';
                 const isHavePaymentClient = Boolean(this.googlePaymentClient).toString();
-                throw new Error(`Google Pay: possibly no response.result or googlePaymentClient is missing, result - ${result}, isHavePaymentClient - ${isHavePaymentClient}`);
+                throw new AppError(`Google Pay: possibly no response.result or googlePaymentClient is missing, result - ${result}, isHavePaymentClient - ${isHavePaymentClient}`);
             })
                 .catch((error) => {
                 this.readyToPay.next(false);
@@ -8137,60 +8670,46 @@ class GooglePayService {
         });
     }
     async proceedCheckout() {
-        if (!this.checkout || !this.googlePaymentClient) {
-            const isHaveCheckout = !!this.checkout;
-            const isHaveClient = !!this.googlePaymentClient;
-            throw new AppError(`Google Pay: no checkout or google payment client, checkout - ${isHaveCheckout.toString()}, client - ${isHaveClient.toString()}`);
+        if (!this.googlePaymentClient) {
+            this.elkLoggerService.log('Google payment client is not initialized to proceed checkout', [ErrorTags.GOOGLEPAY]);
+            throw new AppError(`Google Pay. proceedCheckout: no google payment client`);
+        }
+        if (!this.paymentService) {
+            this.elkLoggerService.log('Google payment service is not initialized to proceed checkout', [ErrorTags.GOOGLEPAY]);
+            throw new AppError(`Google Pay. proceedCheckout: no google payment service`);
+        }
+        const paymentDataRequest = this.paymentService.getPaymentRequest();
+        if (!paymentDataRequest) {
+            this.elkLoggerService.log('No data for payment data request', [
+                ErrorTags.GOOGLEPAY,
+            ]);
+            throw new AppError(`Google Pay: No data for payment data request`);
         }
-        const checkoutData = this.checkout.request.form.fields;
-        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
-        paymentDataRequest.transactionInfo = {
-            currencyCode: checkoutData.currency,
-            totalPriceStatus: 'FINAL',
-            totalPrice: checkoutData.sum,
-            countryCode: this.country,
-        };
         const checkStatusAction = this.injector
             .get(CheckStatusActionCreator)
             .getActionData();
         try {
             const paymentData = await this.googlePaymentClient.loadPaymentData(paymentDataRequest);
             if (!paymentData?.paymentMethodData?.tokenizationData?.token) {
+                this.elkLoggerService.log('Token is missing', [ErrorTags.GOOGLEPAY]);
                 throw new AppError('Google Pay: token is missing');
             }
-            if (!this.checkout) {
-                throw new AppError('Google Pay: no checkout data in then');
-            }
-            let returnUrl = this.checkout.request.form.fields.returnSuccessUrl;
-            const data = this.checkout.request.form.fields;
-            returnUrl += `&cpf_number=${data.cpf_number}&descriptor=${data.descriptor}&paymentData=${JSON.stringify(paymentData)}`;
-            this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+            this.paymentService.handleSuccessfulPayment?.(paymentData);
             return checkStatusAction;
         }
         catch (error) {
-            if (!this.checkout) {
-                throw new AppError(`Google Pay: no checkout data`);
-            }
-            const statusCode = error
-                ?.statusCode;
-            const isStatusCanceled = statusCode && this.isCancelledStatus(statusCode);
-            if (isStatusCanceled) {
-                return null;
-            }
-            const returnUrl = this.checkout.request.form.fields.returnFailUrl;
-            this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+            this.paymentService.handleFailedPayment?.(error);
             return checkStatusAction;
         }
     }
     createButton(onClickHandler, buttonColor = 'default') {
-        if (!this.checkout || !this.googlePaymentClient) {
+        if (!this.googlePaymentClient) {
             return null;
         }
-        const checkoutData = this.checkout.request.form.fields;
-        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
+        const allowedPaymentMethods = this.paymentService?.getAllowedPaymentMethods() || [];
         return this.googlePaymentClient.createButton({
             onClick: onClickHandler,
-            allowedPaymentMethods: paymentDataRequest.allowedPaymentMethods,
+            allowedPaymentMethods: allowedPaymentMethods,
             buttonSizeMode: 'fill',
             buttonType: 'buy',
             buttonColor,
@@ -8200,11 +8719,18 @@ class GooglePayService {
         if (!this.window.google) {
             return;
         }
-        const environment = this.isSandbox ? 'TEST' : 'PRODUCTION';
+        const environment = this.initParams.isSandbox ? 'TEST' : 'PRODUCTION';
+        const googlePaymentClientData = {
+            environment,
+        };
+        if (this.initParams.isInstantPayFlow) {
+            googlePaymentClientData.paymentDataCallbacks = {
+                onPaymentDataChanged: this.onPaymentDataChanged,
+                onPaymentAuthorized: this.onPaymentAuthorized,
+            };
+        }
         this.googlePaymentClient =
-            new this.window.google.payments.api.PaymentsClient({
-                environment,
-            });
+            new this.window.google.payments.api.PaymentsClient(googlePaymentClientData);
     }
     onLoadScript() {
         if (!this.window.google) {
@@ -8223,10 +8749,12 @@ class GooglePayService {
             this.paymentSystemProcessingService.emitInitialize(true);
         }
     }
-    isCancelledStatus(statusCode) {
-        return statusCode.toLowerCase() === 'canceled';
+    getPaymentService() {
+        if (this.initParams.isInstantPayFlow)
+            return this.googlePayInstantPaymentService;
+        return this.googlePayCheckoutPaymentService;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayService, deps: [{ token: windowToken }, { token: PaymentSystemProcessingService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayService, deps: [{ token: windowToken }, { token: ElkLoggerService }, { token: PaymentSystemProcessingService }, { token: GooglePayCheckoutPaymentService }, { token: GooglePayInstantPaymentService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayService, decorators: [{
@@ -8237,9 +8765,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [windowToken]
-                }] }, { type: PaymentSystemProcessingService }, { type: i0.Injector }] });
+                }] }, { type: ElkLoggerService }, { type: PaymentSystemProcessingService }, { type: GooglePayCheckoutPaymentService }, { type: GooglePayInstantPaymentService }, { type: i0.Injector }] });
 
-const applePayVersion = 3;
+var ApplePayIntegrationType;
+(function (ApplePayIntegrationType) {
+    ApplePayIntegrationType["redirect"] = "redirect";
+    ApplePayIntegrationType["native"] = "native";
+})(ApplePayIntegrationType || (ApplePayIntegrationType = {}));
 
 const agreementsGroup = [
     FieldNames.licenseDisclaimer,
@@ -8257,11 +8789,91 @@ const agreementsGroup = [
     FieldNames.koreaLimitsInstruction,
 ];
 
-var ApplePayErrors;
-(function (ApplePayErrors) {
-    ApplePayErrors["paymentError"] = "paymentError";
-    ApplePayErrors["deviceIsNotCapableError"] = "deviceIsNotCapableError";
-})(ApplePayErrors || (ApplePayErrors = {}));
+class ApplePayParamsBuilderService {
+    constructor() {
+        this.agreementFieldsNames = agreementsGroup;
+    }
+    buildParams(paymentForm) {
+        const { fields, summary } = paymentForm;
+        if (!fields || !summary)
+            return null;
+        const formFields = fields.reduce((acc, field) => {
+            if (this.agreementFieldsNames.includes(field.name) &&
+                field.isVisible === "1" /* XpsBoolean.true */) {
+                acc[field.name] = field.title;
+            }
+            else {
+                acc[field.name] = field.value;
+            }
+            return acc;
+        }, {});
+        const agreements = this.agreementFieldsNames
+            .map((fieldName) => [fieldName, formFields[fieldName]])
+            .filter((fieldEntry) => {
+            const [, value] = fieldEntry;
+            return !!value;
+        });
+        return {
+            tokenKey: this.getAppleToken(fields),
+            totalLabel: formFields[FieldNames.labelApplePay] ?? '',
+            totalAmount: this.getTotalAmount(summary),
+            currencyCode: this.getTotalCurrency(summary),
+            countryCode: formFields[FieldNames.countryCode] ?? '',
+            merchantCapabilities: this.getJsonValueFromField(formFields, FieldNames.merchantCapabilities),
+            requiredBillingContactFields: this.getJsonValueFromField(formFields, FieldNames.requiredBillingContactFields),
+            requiredShippingContactFields: this.getJsonValueFromField(formFields, FieldNames.requiredShippingContactFields),
+            supportedNetworks: this.getJsonValueFromField(formFields, FieldNames.supportedNetworks),
+            agreements,
+            acquirer: formFields[FieldNames.acquirer] ?? '',
+            isSandbox: formFields[FieldNames.isSandbox] ?? '',
+            payInstanceAccountId: formFields[FieldNames.payInstanceAccountId] ?? '',
+            getApplePaySessionUrl: formFields[FieldNames.getApplePaySessionUrl] ?? '',
+            payViaCheckoutUrl: formFields[FieldNames.payViaCheckoutUrl] ?? '',
+        };
+    }
+    updateParams(params, summary) {
+        return {
+            ...params,
+            totalAmount: this.getTotalAmount(summary),
+            currencyCode: this.getTotalCurrency(summary),
+        };
+    }
+    getJsonValueFromField(fields, fieldName) {
+        const field = fields[fieldName];
+        try {
+            return field ? JSON.parse(field) : undefined;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    getAppleToken(fields) {
+        const appleTokenField = fields.find((field) => {
+            return field.name === 'token_key';
+        });
+        if (!appleTokenField) {
+            return '';
+        }
+        return appleTokenField.value;
+    }
+    getTotalAmount(summary) {
+        const finance = summary?.finance;
+        const total = finance?.grand_total?.amount ?? finance?.total.amount;
+        return total?.toString() ?? '';
+    }
+    getTotalCurrency(summary) {
+        const finance = summary?.finance;
+        return finance?.grand_total?.currency ?? finance?.total?.currency ?? '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ApplePayParamsBuilderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ApplePayParamsBuilderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ApplePayParamsBuilderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
 class ApplePayService {
     get paymentParameters() {
@@ -8276,11 +8888,14 @@ class ApplePayService {
     get integrationType$() {
         return this.integrationType.asObservable();
     }
-    constructor(window, userAgentService, summaryFinanceDetailsAdapterService) {
+    constructor(window, userAgentService, summaryFinanceDetailsAdapterService, braintreeHandler, checkoutHandler, appleParamsBuilder, elkLoggerService) {
         this.window = window;
         this.userAgentService = userAgentService;
         this.summaryFinanceDetailsAdapterService = summaryFinanceDetailsAdapterService;
-        this.agreementFieldsNames = agreementsGroup;
+        this.braintreeHandler = braintreeHandler;
+        this.checkoutHandler = checkoutHandler;
+        this.appleParamsBuilder = appleParamsBuilder;
+        this.elkLoggerService = elkLoggerService;
         this.payment = new Subject();
         this.error = new Subject();
         this.integrationType = new Subject();
@@ -8288,48 +8903,18 @@ class ApplePayService {
         this.applePayParams = null;
         this.order = null;
         this.api = this.loadBraintree();
+        this.subscribeToHandlers();
     }
     setApplePayParams(data) {
-        const formFields = data?.paymentForm?.fields;
-        const summary = data?.paymentForm?.summary;
+        const paymentForm = data?.paymentForm;
+        const formFields = paymentForm?.fields;
+        const summary = paymentForm?.summary;
         if (!formFields || !summary) {
             return;
         }
-        const fields = formFields.reduce((acc, field) => {
-            if (this.agreementFieldsNames.includes(field.name) &&
-                field.isVisible === '1') {
-                acc[field.name] = field.title;
-            }
-            else {
-                acc[field.name] = field.value;
-            }
-            return acc;
-        }, {});
-        const agreements = this.agreementFieldsNames
-            .map((fieldName) => [fieldName, fields[fieldName]])
-            .filter((fieldEntry) => {
-            const [, value] = fieldEntry;
-            return !!value;
-        });
-        this.applePayParams = {
-            tokenKey: this.getAppleToken(formFields),
-            totalLabel: fields[FieldNames.labelApplePay] ?? '',
-            totalAmount: this.getTotalAmount(summary),
-            currencyCode: this.getTotalCurrency(summary),
-            countryCode: fields[FieldNames.countryCode] ?? '',
-            merchantCapabilities: this.getJsonValueFromField(fields, FieldNames.merchantCapabilities),
-            requiredBillingContactFields: this.getJsonValueFromField(fields, FieldNames.requiredBillingContactFields),
-            requiredShippingContactFields: this.getJsonValueFromField(fields, FieldNames.requiredShippingContactFields),
-            supportedNetworks: this.getJsonValueFromField(fields, FieldNames.supportedNetworks),
-            agreements: agreements,
-            acquirer: fields[FieldNames.acquirer] ?? '',
-            isSandbox: fields[FieldNames.isSandbox] ?? '',
-            payInstanceAccountId: fields[FieldNames.payInstanceAccountId] ?? '',
-            getApplePaySessionUrl: fields[FieldNames.getApplePaySessionUrl] ?? '',
-            payViaCheckoutUrl: fields[FieldNames.payViaCheckoutUrl] ?? '',
-        };
+        this.applePayParams = this.appleParamsBuilder.buildParams(paymentForm);
     }
-    async initLibrary(tokenKey) {
+    async initBraintreeLibrary(tokenKey) {
         try {
             const api = await this.api;
             const clientInstance = await api.client.create({
@@ -8338,12 +8923,16 @@ class ApplePayService {
             this.paymentClient = await api.applePay.create({
                 client: clientInstance,
             });
+            this.braintreeHandler.setClient(this.paymentClient);
         }
         catch (error) {
-            console.error('apple pay: initialize failed', error);
+            console.error(ApplePayErrors.braintreeInitializeError, error);
+            this.elkLoggerService.log(ApplePayErrors.braintreeInitializeError, [
+                ErrorTags.APPLEPAY,
+            ]);
         }
         this.emitIntegrationType();
-        if (!this.paymentClient || !this.isDeviceCapable()) {
+        if (!this.paymentClient || !this.isDeviceCapable) {
             this.emitError(ApplePayErrors.deviceIsNotCapableError);
         }
     }
@@ -8383,7 +8972,7 @@ class ApplePayService {
             }, '');
         }
     }
-    isDeviceCapable() {
+    get isDeviceCapable() {
         // Apple SDK is used on non-Safari devices.
         // Support of ApplePay payments will be defined on the external PS4 page
         if (!this.userAgentService.isSafari)
@@ -8406,54 +8995,49 @@ class ApplePayService {
         if (!this.applePayParams || !summary) {
             return;
         }
-        this.applePayParams.totalAmount = this.getTotalAmount(summary);
-        this.applePayParams.currencyCode = this.getTotalCurrency(summary);
-    }
-    async loadBraintree() {
-        const api = await import('braintree-web');
-        return api;
+        this.applePayParams = this.appleParamsBuilder.updateParams(this.applePayParams, summary);
     }
-    getAppleToken(formFields) {
-        const appleTokenField = formFields.find((field) => {
-            return field.name === 'token_key';
-        });
-        if (!appleTokenField) {
-            return '';
+    proceedCheckout(parameters, iframeIntegrationEnabled = false) {
+        const sessionHandler = this.getSessionHandler(parameters.acquirer);
+        if (!sessionHandler) {
+            console.error('Apple Pay: Unsupported acquirer:', parameters.acquirer);
+            return;
         }
-        return appleTokenField.value;
-    }
-    getTotalAmount(summary) {
-        const finance = summary?.finance;
-        const total = finance?.grand_total?.amount ?? finance?.total.amount;
-        return total?.toString() ?? '';
-    }
-    getTotalCurrency(summary) {
-        const finance = summary?.finance;
-        return finance?.grand_total?.currency ?? finance?.total?.currency ?? '';
+        sessionHandler.startSession(parameters, iframeIntegrationEnabled);
     }
-    getJsonValueFromField(fields, fieldName) {
-        const field = fields[fieldName];
-        try {
-            return field ? JSON.parse(field) : undefined;
-        }
-        catch (error) {
-            return undefined;
+    getSessionHandler(acquirer) {
+        switch (acquirer) {
+            case 'braintree':
+                return this.braintreeHandler;
+            case 'checkout':
+                return this.checkoutHandler;
+            default:
+                return undefined;
         }
     }
+    async loadBraintree() {
+        const api = await import('braintree-web');
+        return api;
+    }
     emitError(error) {
         this.error.next(error);
     }
     emitIntegrationType() {
-        let integrationType;
-        if (this.paymentClient && this.isDeviceCapable()) {
-            integrationType = 'redirect';
+        if (this.userAgentService.isSafari && this.isDeviceCapable) {
+            this.integrationType.next(ApplePayIntegrationType.native);
         }
-        else {
-            integrationType = 'none';
+        else if (this.paymentClient && this.isDeviceCapable) {
+            this.integrationType.next(ApplePayIntegrationType.redirect);
         }
-        this.integrationType.next(integrationType);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ApplePayService, deps: [{ token: windowToken }, { token: UserAgentService }, { token: SummaryFinanceDetailsAdapterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    subscribeToHandlers() {
+        const handlers = [this.braintreeHandler, this.checkoutHandler];
+        handlers.forEach((handler) => {
+            handler.error$.subscribe((error) => this.emitError(error));
+            handler.payment$.subscribe((token) => this.payment.next(token));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ApplePayService, deps: [{ token: windowToken }, { token: UserAgentService }, { token: SummaryFinanceDetailsAdapterService }, { token: BraintreeHandler }, { token: CheckoutHandler }, { token: ApplePayParamsBuilderService }, { token: ElkLoggerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ApplePayService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ApplePayService, decorators: [{
@@ -8464,7 +9048,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [windowToken]
-                }] }, { type: UserAgentService }, { type: SummaryFinanceDetailsAdapterService }] });
+                }] }, { type: UserAgentService }, { type: SummaryFinanceDetailsAdapterService }, { type: BraintreeHandler }, { type: CheckoutHandler }, { type: ApplePayParamsBuilderService }, { type: ElkLoggerService }] });
 
 /*
  * Public API Surface of core-library