@xsolla/payment-client-core 0.1.22 → 0.2.0

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

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, Injectable, Inject, Pipe, isDevMode, NgModule } from '@angular/core';
-import { firstValueFrom, lastValueFrom, map, Subject, BehaviorSubject, filter as filter$1, takeUntil, skip, throwError } from 'rxjs';
+import { firstValueFrom, lastValueFrom, map, Subject, BehaviorSubject, filter as filter$1, takeUntil, skip, take, throwError } from 'rxjs';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpHeaders, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
 import JSEncrypt from 'jsencrypt';
@@ -648,15 +648,6 @@ var InputEventName;
     InputEventName["focus"] = "focus";
 })(InputEventName || (InputEventName = {}));
 
-class ShowErrorsAction {
-    constructor(errors) {
-        this.type = 'show_errors';
-        this.data = {
-            errors,
-        };
-    }
-}
-
 const initializeResponseFactoryToken = new InjectionToken('InitializeResponse');
 const initializeResponseFactoryProvider = {
     provide: initializeResponseFactoryToken,
@@ -748,59 +739,148 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                     args: [windowToken]
                 }] }, { type: SecureApiClient }, { type: SettingsService }, { type: CountryService }]; } });
 
-class ShowFieldsAction {
-    constructor(submitResponse) {
+const vkPay = 3496;
+const googlePay = 3431;
+const applePay = 3175;
+const barzahlenPay = 1679;
+const naverPay = 3563;
+const venmoPay = 3636;
+
+const pagesRoutes = new Map([
+    [vkPay, '/payment/external-pages/vk-pay'],
+    [applePay, '/payment/external-pages/apple-pay'],
+    [barzahlenPay, '/payment/external-pages/barzahlen-pay'],
+    [naverPay, '/payment/external-pages/naver-pay'],
+    [venmoPay, '/payment/external-pages/venmo-pay'],
+]);
+
+const payStation4Url = 'https://secure.xsolla.com/paystation4';
+const sandboxPayStationUrl = 'https://sandbox-secure.xsolla.com/paystation4';
+
+class RedirectActionCreator {
+    constructor(settingsService) {
+        this.settingsService = settingsService;
+        this.type = 'redirect';
+    }
+    getActionData(submitResponse) {
+        return {
+            type: this.type,
+            data: {
+                fields: submitResponse.fields,
+                errors: submitResponse.errors,
+                messages: submitResponse.messages,
+                order: submitResponse.summary,
+                invoiceId: submitResponse.fixInvoice,
+                redirect: this.getRedirect(submitResponse),
+            },
+        };
+    }
+    isSuitable(response) {
+        return (response.currentCommand === XpsCommand.account ||
+            (response.currentCommand === XpsCommand.checkout &&
+                Boolean(response.parameters.checkout)));
+    }
+    getRedirect(submitResponse) {
+        return {
+            redirectUrl: this.getRedirectUrl(submitResponse),
+            data: submitResponse.parameters.checkout.data,
+        };
+    }
+    getRedirectUrl(submitResponse) {
+        const responseRedirectUrl = submitResponse.parameters.checkout.action;
+        const pid = submitResponse?.fields?.find(({ name }) => name === 'fix_pid')?.value;
+        if (!pid) {
+            return responseRedirectUrl;
+        }
+        const pagesPath = pagesRoutes.get(Number(pid));
+        if (!pagesPath) {
+            return responseRedirectUrl;
+        }
+        return this.preparePagesUrl(pagesPath);
+    }
+    preparePagesUrl(pagesPath) {
+        const isSandbox = this.settingsService.isSandboxMode();
+        const token = this.settingsService.token;
+        const payStationUrl = isSandbox ? sandboxPayStationUrl : payStation4Url;
+        return `${payStationUrl}/en${pagesPath}?token=${token}`;
+    }
+}
+RedirectActionCreator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RedirectActionCreator, deps: [{ token: SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+RedirectActionCreator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RedirectActionCreator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RedirectActionCreator, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: SettingsService }]; } });
+
+class ShowFieldsActionCreator {
+    constructor() {
         this.type = 'show_fields';
-        this.data = {
+    }
+    getActionData(submitResponse) {
+        const data = {
             fields: [],
             errors: [],
             messages: [],
             order: {},
         };
-        this.data.fields = submitResponse.fields.filter((field) => field?.isVisible === "1" /* XpsBoolean.true */);
-        this.data.errors = submitResponse.errors;
-        this.data.messages = submitResponse.messages;
-        this.data.order = submitResponse.summary;
+        data.fields = submitResponse.fields.filter((field) => field?.isVisible === "1" /* XpsBoolean.true */);
+        data.errors = submitResponse.errors;
+        data.messages = submitResponse.messages;
+        data.order = submitResponse.summary;
+        return {
+            type: this.type,
+            data,
+        };
+    }
+    isSuitable(response) {
+        return (response.currentCommand === XpsCommand.check ||
+            response.currentCommand === XpsCommand.form);
     }
 }
+ShowFieldsActionCreator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ShowFieldsActionCreator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ShowFieldsActionCreator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ShowFieldsActionCreator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ShowFieldsActionCreator, decorators: [{
+            type: Injectable
+        }] });
 
-const showFieldsActionFactoryToken = new InjectionToken('ShowFieldsAction');
-const showFieldsActionFactoryProvider = {
-    provide: showFieldsActionFactoryToken,
-    useValue: {
-        factory: (...args) => new ShowFieldsAction(...args),
-        isSuitable: (response) => {
-            return (response.currentCommand === XpsCommand.check ||
-                response.currentCommand === XpsCommand.form);
-        },
-    },
-};
-
-class CheckStatusAction {
-    constructor(submitResponse) {
+class CheckStatusActionCreator {
+    constructor() {
         this.type = 'check_status';
-        this.data = {
-            invoice: parseInt(submitResponse.parameters.form.fix_invoice?.value),
-            signature: submitResponse.parameters.form.signature?.value,
-            locale: submitResponse.parameters.form.locale?.value,
-            testPs: submitResponse.parameters.form.testPs?.value,
-            testXsolla: submitResponse.parameters.form.testXsolla?.value,
-            testProject: submitResponse.parameters.form.testProject?.value,
-            userReturnStatus: submitResponse.parameters.form.userReturnStatus?.value,
+    }
+    getActionData() {
+        return {
+            type: this.type,
+            data: null,
         };
     }
+    isSuitable(response) {
+        return response.currentCommand === XpsCommand.status;
+    }
 }
+CheckStatusActionCreator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CheckStatusActionCreator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CheckStatusActionCreator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CheckStatusActionCreator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CheckStatusActionCreator, decorators: [{
+            type: Injectable
+        }] });
 
-const checkStatusActionFactoryToken = new InjectionToken('CheckStatusAction');
-const checkStatusActionFactoryProvider = {
-    provide: checkStatusActionFactoryToken,
-    useValue: {
-        factory: (...args) => new CheckStatusAction(...args),
-        isSuitable: (response) => {
-            return response.currentCommand === XpsCommand.status;
-        },
-    },
-};
+class ShowErrorsActionCreator {
+    constructor() {
+        this.type = 'show_errors';
+    }
+    getActionData(errors) {
+        return {
+            type: this.type,
+            data: { errors },
+        };
+    }
+    isSuitable(response) {
+        return Boolean(response.errors?.length);
+    }
+}
+ShowErrorsActionCreator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ShowErrorsActionCreator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ShowErrorsActionCreator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ShowErrorsActionCreator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ShowErrorsActionCreator, decorators: [{
+            type: Injectable
+        }] });
 
 class TerminalError extends AppError {
     constructor(message, code) {
@@ -921,9 +1001,11 @@ class StatusResponse {
     }
 }
 
-class StatusUpdatedAction {
-    constructor(statusResponse, isSavePaymentMethodMode = false, savePaymentMethodStatus) {
+class StatusUpdatedActionCreator {
+    constructor() {
         this.type = 'status_updated';
+    }
+    getActionData({ statusResponse, isSavePaymentMethodMode, savePaymentMethodStatus, }) {
         let status;
         if (statusResponse instanceof StatusResponse) {
             status = statusResponse.status;
@@ -931,155 +1013,123 @@ class StatusUpdatedAction {
         else {
             status = statusResponse;
         }
-        this.data = {
-            statusState: status.statusState,
-            invoice: status.invoice,
-            isSuccess: status.isSuccess,
-            isCanceled: status.isCanceled,
-            group: status.group,
-            isSavePaymentMethodMode,
-            savePaymentMethodStatus,
+        return {
+            type: this.type,
+            data: {
+                statusState: status.statusState,
+                invoice: status.invoice,
+                isSuccess: status.isSuccess,
+                isCanceled: status.isCanceled,
+                group: status.group,
+                isSavePaymentMethodMode: Boolean(isSavePaymentMethodMode),
+                savePaymentMethodStatus,
+            },
         };
     }
+    isSuitable() {
+        return false;
+    }
 }
+StatusUpdatedActionCreator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusUpdatedActionCreator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+StatusUpdatedActionCreator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusUpdatedActionCreator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusUpdatedActionCreator, decorators: [{
+            type: Injectable
+        }] });
 
-const statusUpdatedActionFactoryToken = new InjectionToken('StatusUpdatedAction');
-const statusUpdatedActionFactoryProvider = {
-    provide: statusUpdatedActionFactoryToken,
-    useValue: {
-        factory: (...args) => new StatusUpdatedAction(...args),
-        isSuitable: () => false,
-    },
-};
-
-const vkPay = 3496;
-const googlePay = 3431;
-const applePay = 3175;
-const barzahlenPay = 1679;
-const naverPay = 3563;
-const venmoPay = 3636;
-
-const pagesRoutes = new Map([
-    [vkPay, '/payment/external-pages/vk-pay'],
-    [applePay, '/payment/external-pages/apple-pay'],
-    [barzahlenPay, '/payment/external-pages/barzahlen-pay'],
-    [naverPay, '/payment/external-pages/naver-pay'],
-    [venmoPay, '/payment/external-pages/venmo-pay'],
-]);
-
-const payStation4Url = 'https://secure.xsolla.com/paystation4';
-const sandboxPayStationUrl = 'https://sandbox-secure.xsolla.com/paystation4';
-
-class RedirectAction {
-    constructor(submitResponse, token, isSandbox) {
-        this.type = 'redirect';
-        this.data = {
-            fields: submitResponse.fields,
-            errors: submitResponse.errors,
-            messages: submitResponse.messages,
-            order: submitResponse.summary,
-            invoiceId: submitResponse.fixInvoice,
-            redirect: this.getRedirect(submitResponse, token, isSandbox),
-        };
+class ThreeDsActionCreator {
+    constructor() {
+        this.type = '3DS';
     }
-    getRedirect(submitResponse, token, isSandbox) {
+    getActionData(actionData) {
         return {
-            redirectUrl: this.getRedirectUrl(submitResponse, token, isSandbox),
-            data: submitResponse.parameters.checkout.data,
+            type: this.type,
+            data: actionData,
         };
     }
-    getRedirectUrl(submitResponse, token, isSandbox) {
-        const responseRedirectUrl = submitResponse.parameters.checkout.action;
-        const pid = submitResponse?.fields?.find(({ name }) => name === 'fix_pid')?.value;
-        if (!pid) {
-            return responseRedirectUrl;
-        }
-        const pagesPath = pagesRoutes.get(Number(pid));
-        if (!pagesPath) {
-            return responseRedirectUrl;
-        }
-        return this.preparePagesUrl(pagesPath, token, isSandbox);
-    }
-    preparePagesUrl(pagesPath, token, isSandbox) {
-        const payStationUrl = isSandbox ? sandboxPayStationUrl : payStation4Url;
-        return `${payStationUrl}/en${pagesPath}?token=${token}`;
+    isSuitable() {
+        return false;
     }
 }
+ThreeDsActionCreator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ThreeDsActionCreator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ThreeDsActionCreator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ThreeDsActionCreator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ThreeDsActionCreator, decorators: [{
+            type: Injectable
+        }] });
 
-const redirectActionFactoryToken = new InjectionToken('RedirectAction');
-const redirectActionFactoryProvider = {
-    provide: redirectActionFactoryToken,
-    useValue: {
-        factory: (...args) => new RedirectAction(...args),
-        isSuitable: (response) => {
-            return (response.currentCommand === XpsCommand.account ||
-                (response.currentCommand === XpsCommand.checkout &&
-                    Boolean(response.parameters.checkout)));
-        },
-    },
-};
-
-const showErrorsActionFactoryToken = new InjectionToken('ShowErrorsAction');
-const showErrorsActionFactoryProvider = {
-    provide: showErrorsActionFactoryToken,
-    useValue: {
-        factory: (...args) => new ShowErrorsAction(...args),
-        isSuitable: (response) => {
-            return Boolean(response.errors?.length);
-        },
-    },
-};
+const googlePayPid = 3431;
 
-class ThreeDsAction {
-    constructor(statusUpdate) {
-        this.type = '3DS';
-        this.data = statusUpdate;
+class SpecialButtonActionCreator {
+    constructor() {
+        this.type = 'special_button';
+        this.pids = [googlePayPid];
+        this.sdkPaymentMethodsName = new Map([
+            [googlePayPid, 'google-pay'],
+        ]);
+    }
+    getActionData(submitResponse) {
+        return {
+            type: this.type,
+            data: {
+                errors: submitResponse.errors,
+                messages: submitResponse.messages,
+                buttonName: this.getPaymentMethodName(submitResponse.pid),
+            },
+        };
+    }
+    isSuitable(response) {
+        return (response.currentCommand === XpsCommand.checkout &&
+            Boolean(response.parameters.checkout) &&
+            this.pids.includes(response.pid));
+    }
+    getPaymentMethodName(pid) {
+        const buttonName = this.sdkPaymentMethodsName.get(pid);
+        if (!buttonName) {
+            throw new Error('Special button not found');
+        }
+        return buttonName;
     }
 }
-
-const threeDsActionFactoryToken = new InjectionToken('ThreeDsAction');
-const threeDsActionFactoryProvider = {
-    provide: threeDsActionFactoryToken,
-    useValue: {
-        factory: (...args) => new ThreeDsAction(...args),
-        isSuitable: () => false,
-    },
-};
+SpecialButtonActionCreator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SpecialButtonActionCreator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SpecialButtonActionCreator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SpecialButtonActionCreator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SpecialButtonActionCreator, decorators: [{
+            type: Injectable
+        }] });
 
 const nextActionsToken = new InjectionToken('Action');
 const nextActions = [
-    showFieldsActionFactoryProvider,
-    checkStatusActionFactoryProvider,
-    redirectActionFactoryProvider,
+    ShowFieldsActionCreator,
+    CheckStatusActionCreator,
+    SpecialButtonActionCreator,
+    RedirectActionCreator,
 ];
 const flowUpdateNextActions = [
-    statusUpdatedActionFactoryProvider,
-    showErrorsActionFactoryProvider,
-    threeDsActionFactoryProvider,
+    ShowErrorsActionCreator,
+    StatusUpdatedActionCreator,
+    ThreeDsActionCreator,
 ];
 
 class NextActionService {
     get flowUpdates$() {
         return this.flowUpdatesSubject.asObservable();
     }
-    constructor(nextActionTokens, injector, settingsService) {
+    constructor(nextActionTokens, injector, showErrorsActionCreator) {
         this.nextActionTokens = nextActionTokens;
         this.injector = injector;
-        this.settingsService = settingsService;
+        this.showErrorsActionCreator = showErrorsActionCreator;
         this.flowUpdatesSubject = new Subject();
         this.nextActionsList = [];
         this.fillNextActionsList();
     }
     getNextAction(submitResponse) {
         if (submitResponse.errors?.length) {
-            this.emitFlowUpdates(new ShowErrorsAction(submitResponse.errors));
+            this.emitFlowUpdates(this.showErrorsActionCreator.getActionData(submitResponse.errors));
         }
         if (!submitResponse.currentCommand) {
             return null;
         }
-        const nextActionFactory = this.findNextAction(submitResponse);
-        if (nextActionFactory) {
-            return nextActionFactory(submitResponse, this.settingsService.token, this.settingsService.isSandboxMode());
+        const nextAction = this.findNextAction(submitResponse);
+        if (nextAction) {
+            return nextAction.getActionData(submitResponse);
         }
         throw new Error('Next action is undefined.');
     }
@@ -1088,7 +1138,7 @@ class NextActionService {
     }
     fillNextActionsList() {
         this.nextActionTokens.forEach((nextAction) => {
-            const item = this.injector.get(nextAction.provide);
+            const item = this.injector.get(nextAction);
             this.nextActionsList.push(item);
         });
     }
@@ -1099,10 +1149,10 @@ class NextActionService {
         if (!actionType) {
             return;
         }
-        return actionType.factory;
+        return actionType;
     }
 }
-NextActionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, deps: [{ token: nextActionsToken }, { token: i0.Injector }, { token: SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+NextActionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, deps: [{ token: nextActionsToken }, { token: i0.Injector }, { token: ShowErrorsActionCreator }], target: i0.ɵɵFactoryTarget.Injectable });
 NextActionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, decorators: [{
             type: Injectable,
@@ -1112,7 +1162,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [nextActionsToken]
-                }] }, { type: i0.Injector }, { type: SettingsService }]; } });
+                }] }, { type: i0.Injector }, { type: ShowErrorsActionCreator }]; } });
 
 /* eslint-disable @typescript-eslint/no-magic-numbers */
 const cardNumberSanctionErrorCodes = [
@@ -1597,7 +1647,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         }], ctorParameters: function () { return [{ type: CreditCardService }]; } });
 
 class InitializeService {
-    constructor(responseFactory, xpsApiService, settingsService, countryService, nextActionService, xpsResponseErrorsMappingService, encryptCreditCardService) {
+    constructor(responseFactory, xpsApiService, settingsService, countryService, nextActionService, xpsResponseErrorsMappingService, encryptCreditCardService, showErrorsActionCreator) {
         this.responseFactory = responseFactory;
         this.xpsApiService = xpsApiService;
         this.settingsService = settingsService;
@@ -1605,6 +1655,7 @@ class InitializeService {
         this.nextActionService = nextActionService;
         this.xpsResponseErrorsMappingService = xpsResponseErrorsMappingService;
         this.encryptCreditCardService = encryptCreditCardService;
+        this.showErrorsActionCreator = showErrorsActionCreator;
         // TODO PAYMENTS-15743: replace with new refer id for headless core
         this.ps4ReferId = '22';
     }
@@ -1631,7 +1682,7 @@ class InitializeService {
             const response = this.xpsResponseErrorsMappingService.mapErrors(xpsResponse);
             const initializeResponse = this.responseFactory(response);
             if (initializeResponse.paymentForm?.errors?.length) {
-                this.nextActionService.emitFlowUpdates(new ShowErrorsAction(initializeResponse.paymentForm.errors));
+                this.nextActionService.emitFlowUpdates(this.showErrorsActionCreator.getActionData(initializeResponse.paymentForm.errors));
             }
             if (initializeResponse.paymentForm) {
                 this.setCreditCardEncryptKey(initializeResponse.paymentForm);
@@ -1650,7 +1701,7 @@ class InitializeService {
         this.encryptCreditCardService.setPublicKey(atob(publicKeyField.value));
     }
 }
-InitializeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, deps: [{ token: initializeResponseFactoryToken }, { token: XpsApiService }, { token: SettingsService }, { token: CountryService }, { token: NextActionService }, { token: XpsResponseErrorsMappingService }, { token: EncryptCreditCardService }], target: i0.ɵɵFactoryTarget.Injectable });
+InitializeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, deps: [{ token: initializeResponseFactoryToken }, { token: XpsApiService }, { token: SettingsService }, { token: CountryService }, { token: NextActionService }, { token: XpsResponseErrorsMappingService }, { token: EncryptCreditCardService }, { token: ShowErrorsActionCreator }], target: i0.ɵɵFactoryTarget.Injectable });
 InitializeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, decorators: [{
             type: Injectable,
@@ -1660,7 +1711,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [initializeResponseFactoryToken]
-                }] }, { type: XpsApiService }, { type: SettingsService }, { type: CountryService }, { type: NextActionService }, { type: XpsResponseErrorsMappingService }, { type: EncryptCreditCardService }]; } });
+                }] }, { type: XpsApiService }, { type: SettingsService }, { type: CountryService }, { type: NextActionService }, { type: XpsResponseErrorsMappingService }, { type: EncryptCreditCardService }, { type: ShowErrorsActionCreator }]; } });
 
 class XpsApiPartRequest {
     addXpsParameters(parameters) {
@@ -1895,7 +1946,7 @@ const syncResponseFactoryProvider = {
 };
 
 class SyncService extends EmitDataService {
-    constructor(requestFactory, responseFactory, xpsApiService, nextActionService, settingsService, xpsResponseErrorsMappingService, encryptCreditCardService) {
+    constructor(requestFactory, responseFactory, xpsApiService, nextActionService, settingsService, xpsResponseErrorsMappingService, encryptCreditCardService, showErrorsActionCreator) {
         super();
         this.requestFactory = requestFactory;
         this.responseFactory = responseFactory;
@@ -1904,6 +1955,7 @@ class SyncService extends EmitDataService {
         this.settingsService = settingsService;
         this.xpsResponseErrorsMappingService = xpsResponseErrorsMappingService;
         this.encryptCreditCardService = encryptCreditCardService;
+        this.showErrorsActionCreator = showErrorsActionCreator;
         this.prevFieldSyncStates = {};
         this.form = new UntypedFormGroup({});
         this.fields = [];
@@ -2001,7 +2053,7 @@ class SyncService extends EmitDataService {
     emitFormErrors(response) {
         const formErrors = response.errors?.filter((error) => !error.element_name);
         if (formErrors?.length) {
-            this.nextActionService.emitFlowUpdates(new ShowErrorsAction(formErrors));
+            this.nextActionService.emitFlowUpdates(this.showErrorsActionCreator.getActionData(formErrors));
         }
     }
     resetFieldSyncTimer(field, timerId) {
@@ -2012,7 +2064,7 @@ class SyncService extends EmitDataService {
         this.fieldSyncTimers[field.name] = timerId;
     }
 }
-SyncService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, deps: [{ token: syncRequestFactoryToken }, { token: syncResponseFactoryToken }, { token: XpsApiService }, { token: NextActionService }, { token: SettingsService }, { token: XpsResponseErrorsMappingService }, { token: EncryptCreditCardService }], target: i0.ɵɵFactoryTarget.Injectable });
+SyncService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, deps: [{ token: syncRequestFactoryToken }, { token: syncResponseFactoryToken }, { token: XpsApiService }, { token: NextActionService }, { token: SettingsService }, { token: XpsResponseErrorsMappingService }, { token: EncryptCreditCardService }, { token: ShowErrorsActionCreator }], target: i0.ɵɵFactoryTarget.Injectable });
 SyncService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, decorators: [{
             type: Injectable,
@@ -2025,7 +2077,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [syncResponseFactoryToken]
-                }] }, { type: XpsApiService }, { type: NextActionService }, { type: SettingsService }, { type: XpsResponseErrorsMappingService }, { type: EncryptCreditCardService }]; } });
+                }] }, { type: XpsApiService }, { type: NextActionService }, { type: SettingsService }, { type: XpsResponseErrorsMappingService }, { type: EncryptCreditCardService }, { type: ShowErrorsActionCreator }]; } });
 
 class ControlConfig {
     constructor() {
@@ -4701,12 +4753,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         }], ctorParameters: function () { return [{ type: SettingsService }, { type: SecureApiClient }]; } });
 
 class SavePaymentMethodStatusService {
-    constructor(statusRequestService, listenStatusService, savedPaymentAccountChangesService, nextActionService, checkStatusService) {
+    constructor(statusRequestService, listenStatusService, savedPaymentAccountChangesService, nextActionService, checkStatusService, statusUpdatedActionCreator) {
         this.statusRequestService = statusRequestService;
         this.listenStatusService = listenStatusService;
         this.savedPaymentAccountChangesService = savedPaymentAccountChangesService;
         this.nextActionService = nextActionService;
         this.checkStatusService = checkStatusService;
+        this.statusUpdatedActionCreator = statusUpdatedActionCreator;
         this.statusChecked = false;
     }
     async getStatus(params) {
@@ -4792,26 +4845,31 @@ class SavePaymentMethodStatusService {
         this.listenStatusService.stopListening();
         this.listenStatusSubscription.unsubscribe();
         const isSavePaymentMethod = true;
-        this.nextActionService.emitFlowUpdates(new StatusUpdatedAction(status, isSavePaymentMethod, this.savePaymentMethodStatus));
+        this.nextActionService.emitFlowUpdates(this.statusUpdatedActionCreator.getActionData({
+            statusResponse: status,
+            isSavePaymentMethodMode: isSavePaymentMethod,
+            savePaymentMethodStatus: this.savePaymentMethodStatus,
+        }));
     }
 }
-SavePaymentMethodStatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavePaymentMethodStatusService, deps: [{ token: StatusRequestService }, { token: ListenStatusService }, { token: SavedPaymentAccountChangesService }, { token: NextActionService }, { token: CheckStatusService }], target: i0.ɵɵFactoryTarget.Injectable });
+SavePaymentMethodStatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavePaymentMethodStatusService, deps: [{ token: StatusRequestService }, { token: ListenStatusService }, { token: SavedPaymentAccountChangesService }, { token: NextActionService }, { token: CheckStatusService }, { token: StatusUpdatedActionCreator }], target: i0.ɵɵFactoryTarget.Injectable });
 SavePaymentMethodStatusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavePaymentMethodStatusService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavePaymentMethodStatusService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: StatusRequestService }, { type: ListenStatusService }, { type: SavedPaymentAccountChangesService }, { type: NextActionService }, { type: CheckStatusService }]; } });
+        }], ctorParameters: function () { return [{ type: StatusRequestService }, { type: ListenStatusService }, { type: SavedPaymentAccountChangesService }, { type: NextActionService }, { type: CheckStatusService }, { type: StatusUpdatedActionCreator }]; } });
 
 class StatusService {
-    constructor(urlService, statusRequestService, financeDetailsService, listenStatusService, nextActionService, savePaymentMethodStatusService) {
+    constructor(urlService, statusRequestService, financeDetailsService, listenStatusService, nextActionService, savePaymentMethodStatusService, statusUpdatedActionCreator) {
         this.urlService = urlService;
         this.statusRequestService = statusRequestService;
         this.financeDetailsService = financeDetailsService;
         this.listenStatusService = listenStatusService;
         this.nextActionService = nextActionService;
         this.savePaymentMethodStatusService = savePaymentMethodStatusService;
+        this.statusUpdatedActionCreator = statusUpdatedActionCreator;
     }
     async getStatus(params) {
         const isSavePaymentMethodMode = params?.isSavePaymentAccount === "1" /* XpsBoolean.true */;
@@ -4850,18 +4908,18 @@ class StatusService {
             .pipe(skip(1))
             .subscribe(({ statusResponse }) => {
             this.financeDetailsService.emitWithStatus(statusResponse.status);
-            this.nextActionService.emitFlowUpdates(new StatusUpdatedAction(statusResponse));
+            this.nextActionService.emitFlowUpdates(this.statusUpdatedActionCreator.getActionData({ statusResponse }));
         });
     }
 }
-StatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, deps: [{ token: UrlService }, { token: StatusRequestService }, { token: FinanceDetailsService }, { token: ListenStatusService }, { token: NextActionService }, { token: SavePaymentMethodStatusService }], target: i0.ɵɵFactoryTarget.Injectable });
+StatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, deps: [{ token: UrlService }, { token: StatusRequestService }, { token: FinanceDetailsService }, { token: ListenStatusService }, { token: NextActionService }, { token: SavePaymentMethodStatusService }, { token: StatusUpdatedActionCreator }], target: i0.ɵɵFactoryTarget.Injectable });
 StatusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: UrlService }, { type: StatusRequestService }, { type: FinanceDetailsService }, { type: ListenStatusService }, { type: NextActionService }, { type: SavePaymentMethodStatusService }]; } });
+        }], ctorParameters: function () { return [{ type: UrlService }, { type: StatusRequestService }, { type: FinanceDetailsService }, { type: ListenStatusService }, { type: NextActionService }, { type: SavePaymentMethodStatusService }, { type: StatusUpdatedActionCreator }]; } });
 
 class CreditCardStateService extends EmitDataService {
 }
@@ -5254,9 +5312,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         }], ctorParameters: function () { return [{ type: StatusThreeDsService }, { type: NotifyDfpStatusService }, { type: WebSocketFactory }, { type: DfpCollectService }, { type: ReinsuranceCheckService }]; } });
 
 class ThreeDsService {
-    constructor(threeDs20Service, nextActionService) {
+    constructor(threeDs20Service, nextActionService, checkStatusActionCreator, threeDsActionCreator) {
         this.threeDs20Service = threeDs20Service;
         this.nextActionService = nextActionService;
+        this.checkStatusActionCreator = checkStatusActionCreator;
+        this.threeDsActionCreator = threeDsActionCreator;
         this.statusSubscription = null;
     }
     checkThreeDs(params) {
@@ -5269,23 +5329,23 @@ class ThreeDsService {
         this.statusSubscription?.unsubscribe();
         this.statusSubscription = this.threeDs20Service.statusUpdates$.subscribe((statusUpdate) => {
             if (statusUpdate.type === 'complete') {
-                return this.nextActionService.emitFlowUpdates(new CheckStatusAction(params));
+                return this.nextActionService.emitFlowUpdates(this.checkStatusActionCreator.getActionData());
             }
-            this.nextActionService.emitFlowUpdates(new ThreeDsAction(statusUpdate));
+            this.nextActionService.emitFlowUpdates(this.threeDsActionCreator.getActionData(statusUpdate));
         });
     }
     stopChecking() {
         this.statusSubscription?.unsubscribe();
     }
 }
-ThreeDsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ThreeDsService, deps: [{ token: ThreeDs20Service }, { token: NextActionService }], target: i0.ɵɵFactoryTarget.Injectable });
+ThreeDsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ThreeDsService, deps: [{ token: ThreeDs20Service }, { token: NextActionService }, { token: CheckStatusActionCreator }, { token: ThreeDsActionCreator }], target: i0.ɵɵFactoryTarget.Injectable });
 ThreeDsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ThreeDsService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ThreeDsService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: ThreeDs20Service }, { type: NextActionService }]; } });
+        }], ctorParameters: function () { return [{ type: ThreeDs20Service }, { type: NextActionService }, { type: CheckStatusActionCreator }, { type: ThreeDsActionCreator }]; } });
 
 class FormMessagesService extends EmitDataService {
     constructor(unescapeHtmlPipe) {
@@ -5313,7 +5373,7 @@ class PaymentService {
     get formFieldsStatus$() {
         return this.formFieldsStatusSubject.asObservable().pipe(filter$1(Boolean));
     }
-    constructor(initializeService, submitService, syncService, formService, statusService, financeDetailsService, creditCardStateService, nextActionService, controlConfigService, threeDsService, formMessagesService) {
+    constructor(initializeService, submitService, syncService, formService, statusService, financeDetailsService, creditCardStateService, nextActionService, controlConfigService, threeDsService, formMessagesService, settingsService, countryService) {
         this.initializeService = initializeService;
         this.submitService = submitService;
         this.syncService = syncService;
@@ -5325,6 +5385,8 @@ class PaymentService {
         this.controlConfigService = controlConfigService;
         this.threeDsService = threeDsService;
         this.formMessagesService = formMessagesService;
+        this.settingsService = settingsService;
+        this.countryService = countryService;
         this.form = null;
         this.data = null;
         this.financeDetails = null;
@@ -5383,6 +5445,18 @@ class PaymentService {
         }
         return this.data?.paymentForm?.fields ?? [];
     }
+    getInitialDataForSdkPaymentSystems() {
+        if (!isSubmitResponse(this.data)) {
+            throw new Error('Should submit form first');
+        }
+        return {
+            data: this.data.parameters.checkout.data.data,
+            sandbox: this.settingsService.isSandboxMode()
+                ? "1" /* XpsBoolean.true */
+                : "0" /* XpsBoolean.false */,
+            country: this.countryService.getCountry(),
+        };
+    }
     getPid() {
         if (this.data instanceof SubmitResponse) {
             return (Number(this.data.fields.find((field) => field.name === 'fix_pid')?.value) || null);
@@ -5524,14 +5598,14 @@ class PaymentService {
         }
     }
 }
-PaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", 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 }], target: i0.ɵɵFactoryTarget.Injectable });
+PaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", 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 }], target: i0.ɵɵFactoryTarget.Injectable });
 PaymentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: InitializeService }, { type: SubmitService }, { type: SyncService }, { type: FormService }, { type: StatusService }, { type: FinanceDetailsService }, { type: CreditCardStateService }, { type: NextActionService }, { type: ControlConfigService }, { type: ThreeDsService }, { type: FormMessagesService }]; } });
+        }], ctorParameters: function () { return [{ 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 }]; } });
 
 class RefundPolicyService {
     constructor(settingsService) {
@@ -5671,8 +5745,281 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                 }]
         }], ctorParameters: function () { return [{ type: SavedMethodsService }, { type: SettingsService }, { type: SecureApiClient }]; } });
 
+class PaymentSystemProcessingService {
+    constructor(window) {
+        this.window = window;
+        this.statusUrl = new BehaviorSubject('');
+        this.initialize = new BehaviorSubject(false);
+    }
+    get initialize$() {
+        return this.initialize.asObservable();
+    }
+    get status$() {
+        return this.statusUrl.asObservable().pipe(filter((status) => !!status));
+    }
+    emitPayment(payment) {
+        this.statusUrl.next(payment);
+    }
+    emitInitialize(isInitialized) {
+        this.initialize.next(isInitialized);
+    }
+    getDecodedCheckout(base64checkoutData) {
+        try {
+            return JSON.parse(atob(base64checkoutData));
+        }
+        catch (error) {
+            throw new AppError('load script service: decode error');
+        }
+    }
+    loadScript(url, onLoad, addScriptCustomAttributes) {
+        this.initialize.next(false);
+        let script = this.window.document.createElement('script');
+        script.async = true;
+        script.src = url;
+        if (addScriptCustomAttributes) {
+            script = addScriptCustomAttributes(script);
+        }
+        this.window.document.body.append(script);
+        script.onload = () => {
+            try {
+                onLoad();
+            }
+            catch (error) {
+                let message = error;
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                throw new AppError(`Pages: error during script onload handler: ${message}, url - ${url}`);
+            }
+        };
+        script.onerror = (event, source, lineno, colno, error) => {
+            const errorMessage = error ? error.message : '';
+            let eventMessage = event;
+            if (typeof event === 'object') {
+                eventMessage = JSON.stringify(event);
+            }
+            throw new AppError(`Pages: error during script onerror handler:
+        url - ${url},
+        event - ${eventMessage},
+        source - ${source ?? ''},
+        lineno - ${lineno ?? ''},
+        colno - ${colno ?? ''},
+        error - ${errorMessage}`);
+        };
+    }
+    isInitialized() {
+        return this.initialize.getValue();
+    }
+}
+PaymentSystemProcessingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentSystemProcessingService, deps: [{ token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable });
+PaymentSystemProcessingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentSystemProcessingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentSystemProcessingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }]; } });
+
+class GooglePayService {
+    get libraryWasInitialized() {
+        return !!this.window.google;
+    }
+    get googlePaymentClientWasInitialized() {
+        return !!this.googlePaymentClient;
+    }
+    constructor(window, elkLoggerService, commonPayProcessingService, httpClient, injector) {
+        this.window = window;
+        this.elkLoggerService = elkLoggerService;
+        this.commonPayProcessingService = commonPayProcessingService;
+        this.httpClient = httpClient;
+        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.commonPayProcessingService.status$.subscribe((path) => {
+            this.sendUserBack(path);
+        });
+    }
+    get readyToPay$() {
+        return this.readyToPay.asObservable();
+    }
+    isReadyToPay() {
+        return this.readyToPay.getValue();
+    }
+    sendUserBack(path) {
+        void this.httpClient.get(path);
+    }
+    initGooglePayLibrary(data) {
+        this.isSandbox = data.isSandbox;
+        this.country = data.country;
+        if (this.libraryWasInitialized && this.googlePaymentClientWasInitialized) {
+            return;
+        }
+        if (this.libraryWasInitialized && !this.googlePaymentClientWasInitialized) {
+            this.setupGooglePayClient();
+            return;
+        }
+        this.commonPayProcessingService.loadScript(this.googlePayScriptUrl, this.onLoadScript.bind(this));
+        this.elkLoggerService.log('Google Pay: loading script is starting', [
+            ErrorTags.GOOGLEPAY,
+        ]);
+    }
+    checkPaymentDevice(base64checkoutData) {
+        this.commonPayProcessingService.initialize$
+            .pipe(filter$1(Boolean), take(1))
+            .subscribe(() => {
+            this.checkout =
+                this.commonPayProcessingService.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()}`);
+            }
+            const checkoutData = this.checkout.request.form.fields;
+            const isReadyToPayRequest = JSON.parse(checkoutData.isReadyToPayRequest);
+            this.googlePaymentClient
+                .isReadyToPay(isReadyToPayRequest)
+                .then((response) => {
+                if (response.result && this.googlePaymentClient) {
+                    this.googlePaymentClient.prefetchPaymentData(JSON.parse(checkoutData.paymentDataRequest));
+                    return this.readyToPay.next(true);
+                }
+                this.readyToPay.next(false);
+                const result = response.result?.toString() ?? '';
+                const isHavePaymentClient = Boolean(this.googlePaymentClient).toString();
+                this.elkLoggerService.log(`Google Pay: possibly no response.result or googlePaymentClient is missing, result - ${result}, isHavePaymentClient - ${isHavePaymentClient}`, [ErrorTags.GOOGLEPAY], {
+                    result: response.result,
+                    response: response,
+                    googlePaymentClient: !!this.googlePaymentClient,
+                });
+                throw new Error();
+            })
+                .catch((error) => {
+                this.readyToPay.next(false);
+                let message = error ?? '';
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                throw new AppError(`Google Pay: device is not ready to pay, ${message}`);
+            });
+        });
+    }
+    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()}`);
+        }
+        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) {
+                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.commonPayProcessingService.emitPayment(returnUrl);
+            return checkStatusAction;
+        }
+        catch (error) {
+            this.elkLoggerService.log(`Google Pay: google payment window error. ${JSON.stringify(error)}`, [ErrorTags.GOOGLEPAY], {
+                error: 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.commonPayProcessingService.emitPayment(returnUrl);
+            return checkStatusAction;
+        }
+    }
+    createButton(onClickHandler) {
+        if (!this.checkout || !this.googlePaymentClient) {
+            return null;
+        }
+        const checkoutData = this.checkout.request.form.fields;
+        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
+        return this.googlePaymentClient.createButton({
+            onClick: onClickHandler,
+            allowedPaymentMethods: paymentDataRequest.allowedPaymentMethods,
+            buttonSizeMode: 'fill',
+            buttonType: 'buy',
+            buttonColor: 'white',
+        });
+    }
+    setupGooglePayClient() {
+        if (!this.window.google) {
+            return;
+        }
+        const environment = this.isSandbox ? 'TEST' : 'PRODUCTION';
+        this.googlePaymentClient =
+            new this.window.google.payments.api.PaymentsClient({
+                environment,
+            });
+        this.elkLoggerService.log(`Google Pay: payments client is initialized, paymentsClient - ${Boolean(this.googlePaymentClient).toString()}`, [ErrorTags.GOOGLEPAY], { environment: environment, initialized: !!this.googlePaymentClient });
+    }
+    onLoadScript() {
+        if (!this.window.google) {
+            const retryTimeout = 1000;
+            setTimeout(() => {
+                const isAvailableGoogleClient = !!this.window.google;
+                if (!isAvailableGoogleClient) {
+                    this.elkLoggerService.log('Google Pay: google library is missing', [
+                        ErrorTags.GOOGLEPAY,
+                    ]);
+                }
+                else {
+                    this.setupGooglePayClient();
+                    this.commonPayProcessingService.emitInitialize(true);
+                }
+            }, retryTimeout);
+            throw new AppError('Google Pay: google library now is available');
+        }
+        else {
+            this.setupGooglePayClient();
+            this.commonPayProcessingService.emitInitialize(true);
+        }
+    }
+    isCancelledStatus(statusCode) {
+        return statusCode.toLowerCase() === 'canceled';
+    }
+}
+GooglePayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: GooglePayService, deps: [{ token: windowToken }, { token: ElkLoggerService }, { token: PaymentSystemProcessingService }, { token: i1.HttpClient }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+GooglePayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: GooglePayService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: GooglePayService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: ElkLoggerService }, { type: PaymentSystemProcessingService }, { type: i1.HttpClient }, { type: i0.Injector }]; } });
+
 class CoreLibraryService {
-    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, paymentConfigService, paymentService, deviceFingerPrintService, financeDetailsService, legalService, statusService, nextActionService, creditCardService, creditCardStateService, formMessagesService, editSavedMethodsService) {
+    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, paymentConfigService, paymentService, deviceFingerPrintService, financeDetailsService, legalService, statusService, nextActionService, creditCardService, creditCardStateService, formMessagesService, editSavedMethodsService, googlePayService, commonPayProcessingService) {
         this.settingsService = settingsService;
         this.countryService = countryService;
         this.paymentMethodsService = paymentMethodsService;
@@ -5689,6 +6036,8 @@ class CoreLibraryService {
         this.creditCardStateService = creditCardStateService;
         this.formMessagesService = formMessagesService;
         this.editSavedMethodsService = editSavedMethodsService;
+        this.googlePayService = googlePayService;
+        this.commonPayProcessingService = commonPayProcessingService;
         this.paymentMethods = {
             getList: async (isSaveMethodMode) => this.paymentMethodsService.getList(isSaveMethodMode),
             getQuickMethods: async () => this.paymentMethodsService.getQuickMethods(),
@@ -5696,6 +6045,23 @@ class CoreLibraryService {
             getUserBalance: async () => this.userBalanceService.getUserBalance(),
             deleteSavedMethod: async (id, type) => this.editSavedMethodsService.deleteSavedMethodRequest(id, type),
         };
+        this.sdkPaymentSystems = {
+            commonPayProcessingService: {
+                initialize$: this.commonPayProcessingService.initialize$,
+                isInitialized: () => this.commonPayProcessingService.isInitialized(),
+                status$: this.commonPayProcessingService.status$,
+            },
+            googlePay: {
+                readyToPay$: this.googlePayService.readyToPay$,
+                isReadyToPay: () => this.googlePayService.isReadyToPay(),
+                initGooglePayLibrary: (params) => this.googlePayService.initGooglePayLibrary(params),
+                checkPaymentDevice: (base64checkoutData) => this.googlePayService.checkPaymentDevice(base64checkoutData),
+                proceedCheckout: async () => this.googlePayService.proceedCheckout(),
+                createButton: (onClickHandler) => this.googlePayService.createButton(onClickHandler),
+                sendUserBack: (path) => this.googlePayService.sendUserBack(path),
+            },
+            getInitialData: () => this.paymentService.getInitialDataForSdkPaymentSystems(),
+        };
     }
     async init(configuration) {
         await this.settingsService.init(configuration);
@@ -5760,14 +6126,14 @@ class CoreLibraryService {
         return this.userBalanceService.getUserBalanceValue();
     }
 }
-CoreLibraryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", 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 }], target: i0.ɵɵFactoryTarget.Injectable });
+CoreLibraryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", 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: GooglePayService }, { token: PaymentSystemProcessingService }], target: i0.ɵɵFactoryTarget.Injectable });
 CoreLibraryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: SettingsService }, { type: CountryService }, { type: PaymentMethodsService }, { type: SavedMethodsService }, { type: UserBalanceService }, { type: PaymentConfigService }, { type: PaymentService }, { type: DeviceFingerPrintService }, { type: FinanceDetailsService }, { type: LegalService }, { type: StatusService }, { type: NextActionService }, { type: CreditCardService }, { type: CreditCardStateService }, { type: FormMessagesService }, { type: EditSavedMethodsService }]; } });
+        }], ctorParameters: function () { return [{ type: SettingsService }, { type: CountryService }, { type: PaymentMethodsService }, { type: SavedMethodsService }, { type: UserBalanceService }, { type: PaymentConfigService }, { type: PaymentService }, { type: DeviceFingerPrintService }, { type: FinanceDetailsService }, { type: LegalService }, { type: StatusService }, { type: NextActionService }, { type: CreditCardService }, { type: CreditCardStateService }, { type: FormMessagesService }, { type: EditSavedMethodsService }, { type: GooglePayService }, { type: PaymentSystemProcessingService }]; } });
 
 class HttpError extends AppError {
     constructor(error, req) {