@xsolla/payment-client-core 0.1.22 → 0.2.1

package/lib/core/extended-window.interface.d.ts

@@ -1 +1,4 @@
-export type ExtendedWindow = Window;
+import { GooglePayLibrary } from './sdk-payment-systems/google-pay/google-pay-library.interface';
+export interface ExtendedWindow extends Window {
+    google?: GooglePayLibrary;
+}

package/lib/core/payment/actions/action.interface.d.ts

@@ -1,4 +1,11 @@
+import { SubmitResponse } from '../submit/response/submit-response.class';
+import { NextAction } from './next-action.interface';
 export interface Action<T = string, D = object> {
     type: T;
     data: D;
 }
+export interface ActionCreator<T = string, D = unknown> {
+    type: T;
+    isSuitable(response?: SubmitResponse): boolean;
+    getActionData(actionData?: D): NextAction;
+}

package/lib/core/payment/actions/check-status/check-status.action.class.d.ts

@@ -1,8 +1,11 @@
 import { SubmitResponse } from '../../submit/response/submit-response.class';
-import { Action } from '../action.interface';
-import { CheckStatusActionData, CheckStatusActionType } from './check-status.action.type';
-export declare class CheckStatusAction implements Action {
+import { ActionCreator } from '../action.interface';
+import { CheckStatusAction, CheckStatusActionType } from './check-status.action.type';
+import * as i0 from "@angular/core";
+export declare class CheckStatusActionCreator implements ActionCreator {
     type: CheckStatusActionType;
-    data: CheckStatusActionData;
-    constructor(submitResponse: SubmitResponse);
+    getActionData(): CheckStatusAction;
+    isSuitable(response: SubmitResponse): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckStatusActionCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckStatusActionCreator>;
 }

package/lib/core/payment/actions/check-status/check-status.action.type.d.ts

@@ -1,12 +1,3 @@
 import { Action } from '../action.interface';
 export type CheckStatusActionType = 'check_status';
-export interface CheckStatusActionData {
-    invoice: number;
-    signature: string;
-    locale: string;
-    testProject?: string;
-    testPs?: string;
-    testXsolla?: string;
-    userReturnStatus?: string;
-}
-export type CheckStatusAction = Action<CheckStatusActionType, CheckStatusActionData>;
+export type CheckStatusAction = Action<CheckStatusActionType, null>;

package/lib/core/payment/actions/next-action.interface.d.ts

@@ -4,4 +4,5 @@ import { StatusUpdatedAction } from './status-updated/status-updated.action.type
 import { RedirectAction } from './redirect/redirect.action.type';
 import { ShowErrorsAction } from './show-errors/show-errors.action.type';
 import { ThreeDsAction } from './three-ds/three-ds.action.type';
-export type NextAction = CheckStatusAction | ShowFieldsAction | StatusUpdatedAction | ShowErrorsAction | RedirectAction | ThreeDsAction;
+import { SpecialButtonAction } from './special-button/special-button.action.type';
+export type NextAction = CheckStatusAction | ShowFieldsAction | StatusUpdatedAction | ShowErrorsAction | RedirectAction | ThreeDsAction | SpecialButtonAction;

package/lib/core/payment/actions/next-action.service.d.ts

@@ -3,16 +3,16 @@ import { Observable } from 'rxjs';
 import { NextAction } from './next-action.interface';
 import { SubmitResponse } from '../submit/response/submit-response.class';
 import { NextActionTokens } from './next-actions';
-import { SettingsService } from '../../settings/settings.service';
+import { ShowErrorsActionCreator } from './show-errors/show-errors.action.class';
 import * as i0 from "@angular/core";
 export declare class NextActionService {
     private readonly nextActionTokens;
     private readonly injector;
-    private readonly settingsService;
+    private readonly showErrorsActionCreator;
     private readonly flowUpdatesSubject;
     private readonly nextActionsList;
     get flowUpdates$(): Observable<NextAction>;
-    constructor(nextActionTokens: NextActionTokens, injector: Injector, settingsService: SettingsService);
+    constructor(nextActionTokens: NextActionTokens, injector: Injector, showErrorsActionCreator: ShowErrorsActionCreator);
     getNextAction(submitResponse: SubmitResponse): NextAction | null;
     emitFlowUpdates(action: NextAction): void;
     private fillNextActionsList;

package/lib/core/payment/actions/next-actions.d.ts

@@ -1,6 +1,6 @@
-import { InjectionToken, ValueProvider } from '@angular/core';
-import { Action } from './action.interface';
-export type NextActionTokens = ValueProvider[];
-export declare const nextActionsToken: InjectionToken<Action<string, object>>;
+import { InjectionToken, ProviderToken } from '@angular/core';
+import { ActionCreator } from './action.interface';
+export type NextActionTokens = Array<ProviderToken<ActionCreator>>;
+export declare const nextActionsToken: InjectionToken<ActionCreator<string, unknown>>;
 export declare const nextActions: NextActionTokens;
 export declare const flowUpdateNextActions: NextActionTokens;

package/lib/core/payment/actions/redirect/redirect.action.class.d.ts

@@ -1,11 +1,17 @@
 import { SubmitResponse } from '../../submit/response/submit-response.class';
-import { Action } from '../action.interface';
-import { RedirectActionData, RedirectActionType } from './redirect.action.type';
-export declare class RedirectAction implements Action {
-    type: RedirectActionType;
-    data: RedirectActionData;
-    constructor(submitResponse: SubmitResponse, token: string, isSandbox: boolean);
+import { ActionCreator } from '../action.interface';
+import { RedirectAction, RedirectActionType } from './redirect.action.type';
+import { SettingsService } from '../../../settings/settings.service';
+import * as i0 from "@angular/core";
+export declare class RedirectActionCreator implements ActionCreator {
+    private readonly settingsService;
+    readonly type: RedirectActionType;
+    constructor(settingsService: SettingsService);
+    getActionData(submitResponse: SubmitResponse): RedirectAction;
+    isSuitable(response: SubmitResponse): boolean;
     private getRedirect;
     private getRedirectUrl;
     private preparePagesUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RedirectActionCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RedirectActionCreator>;
 }

package/lib/core/payment/actions/show-errors/show-errors.action.class.d.ts

@@ -1,8 +1,13 @@
+import { ActionCreator } from '../action.interface';
+import { ShowErrorsAction, ShowErrorsActionData, ShowErrorsActionType } from './show-errors.action.type';
+import { SubmitResponse } from '../../submit/response/submit-response.class';
 import { XpsError } from '../../xps-error.interface';
-import { Action } from '../action.interface';
-import { ShowErrorsActionData, ShowErrorsActionType } from './show-errors.action.type';
-export declare class ShowErrorsAction implements Action {
+import * as i0 from "@angular/core";
+export declare class ShowErrorsActionCreator implements ActionCreator {
     type: ShowErrorsActionType;
     data: ShowErrorsActionData;
-    constructor(errors: XpsError[]);
+    getActionData(errors: XpsError[]): ShowErrorsAction;
+    isSuitable(response: SubmitResponse): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowErrorsActionCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowErrorsActionCreator>;
 }

package/lib/core/payment/actions/show-fields/show-fields.action.class.d.ts

@@ -1,8 +1,11 @@
-import { Action } from '../action.interface';
-import { ShowFieldsActionData, ShowFieldsActionType } from './show-fields.action.type';
+import { ActionCreator } from '../action.interface';
+import { ShowFieldsAction, ShowFieldsActionType } from './show-fields.action.type';
 import { SubmitResponse } from '../../submit/response/submit-response.class';
-export declare class ShowFieldsAction implements Action {
+import * as i0 from "@angular/core";
+export declare class ShowFieldsActionCreator implements ActionCreator {
     type: ShowFieldsActionType;
-    data: ShowFieldsActionData;
-    constructor(submitResponse: SubmitResponse);
+    getActionData(submitResponse: SubmitResponse): ShowFieldsAction;
+    isSuitable(response: SubmitResponse): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowFieldsActionCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowFieldsActionCreator>;
 }

package/lib/core/payment/actions/special-button/special-button.action.class.d.ts

@@ -0,0 +1,14 @@
+import { SubmitResponse } from '../../submit/response/submit-response.class';
+import { ActionCreator } from '../action.interface';
+import { SpecialButtonAction, SpecialButtonActionType } from './special-button.action.type';
+import * as i0 from "@angular/core";
+export declare class SpecialButtonActionCreator implements ActionCreator {
+    type: SpecialButtonActionType;
+    private readonly pids;
+    private readonly sdkPaymentMethodsName;
+    getActionData(submitResponse: SubmitResponse): SpecialButtonAction;
+    isSuitable(response: SubmitResponse): boolean;
+    private getPaymentMethodName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialButtonActionCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpecialButtonActionCreator>;
+}

package/lib/core/payment/actions/special-button/special-button.action.type.d.ts

@@ -0,0 +1,10 @@
+import { Action } from '../action.interface';
+import { XpsError } from '../../xps-error.interface';
+import { XpsMessage } from '../../xps-message.interface';
+export type SpecialButtonActionType = 'special_button';
+export interface SpecialButtonActionData {
+    errors: XpsError[] | null;
+    messages: XpsMessage[] | undefined;
+    buttonName: string;
+}
+export type SpecialButtonAction = Action<SpecialButtonActionType, SpecialButtonActionData>;

package/lib/core/payment/actions/status-updated/status-updated.action.class.d.ts

@@ -1,10 +1,17 @@
-import { Action } from '../action.interface';
-import { StatusUpdatedActionData, StatusUpdatedActionType } from './status-updated.action.type';
+import { ActionCreator } from '../action.interface';
+import { StatusUpdatedAction, StatusUpdatedActionType } from './status-updated.action.type';
 import { StatusResponse } from '../../status/status-request/response/status-response.class';
 import { Status } from '../../status/status.interface';
 import { SavePaymentMethodStatus } from '../../status/save-payment-method-status/save-payment-method-status.enum';
-export declare class StatusUpdatedAction implements Action {
+import * as i0 from "@angular/core";
+export declare class StatusUpdatedActionCreator implements ActionCreator {
     type: StatusUpdatedActionType;
-    data: StatusUpdatedActionData;
-    constructor(statusResponse: StatusResponse | Status, isSavePaymentMethodMode?: boolean, savePaymentMethodStatus?: SavePaymentMethodStatus);
+    getActionData({ statusResponse, isSavePaymentMethodMode, savePaymentMethodStatus, }: {
+        statusResponse: StatusResponse | Status;
+        isSavePaymentMethodMode?: boolean;
+        savePaymentMethodStatus?: SavePaymentMethodStatus;
+    }): StatusUpdatedAction;
+    isSuitable(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusUpdatedActionCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StatusUpdatedActionCreator>;
 }

package/lib/core/payment/actions/three-ds/three-ds.action.class.d.ts

@@ -1,8 +1,11 @@
-import { Action } from '../action.interface';
-import { ThreeDsActionData, ThreeDsActionType } from './three-ds.action.type';
+import { ActionCreator } from '../action.interface';
+import { ThreeDsAction, ThreeDsActionType } from './three-ds.action.type';
 import { StatusChallenge } from '../../three-ds/three-ds-20/status-update.interface';
-export declare class ThreeDsAction implements Action {
+import * as i0 from "@angular/core";
+export declare class ThreeDsActionCreator implements ActionCreator {
     type: ThreeDsActionType;
-    data: ThreeDsActionData;
-    constructor(statusUpdate: StatusChallenge);
+    getActionData(actionData: StatusChallenge): ThreeDsAction;
+    isSuitable(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThreeDsActionCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThreeDsActionCreator>;
 }

package/lib/core/payment/initialize/initialize.service.d.ts

@@ -3,6 +3,7 @@ import { EncryptCreditCardService } from '../../encrypt-credit-card/encrypt-cred
 import { SettingsService } from '../../settings/settings.service';
 import { PaymentConfig } from '../payment-config.interface';
 import { NextActionService } from '../actions/next-action.service';
+import { ShowErrorsActionCreator } from '../actions/show-errors/show-errors.action.class';
 import { XpsApiService } from '../xps-api/xps-api.service';
 import { InitializeResponseFactory } from './response/initialize-response.token';
 import { InitializeResponse } from './response/initialize-response.class';
@@ -16,8 +17,9 @@ export declare class InitializeService {
     private readonly nextActionService;
     private readonly xpsResponseErrorsMappingService;
     private readonly encryptCreditCardService;
+    private readonly showErrorsActionCreator;
     private readonly ps4ReferId;
-    constructor(responseFactory: InitializeResponseFactory, xpsApiService: XpsApiService, settingsService: SettingsService, countryService: CountryService, nextActionService: NextActionService, xpsResponseErrorsMappingService: XpsResponseErrorsMappingService, encryptCreditCardService: EncryptCreditCardService);
+    constructor(responseFactory: InitializeResponseFactory, xpsApiService: XpsApiService, settingsService: SettingsService, countryService: CountryService, nextActionService: NextActionService, xpsResponseErrorsMappingService: XpsResponseErrorsMappingService, encryptCreditCardService: EncryptCreditCardService, showErrorsActionCreator: ShowErrorsActionCreator);
     request(config: PaymentConfig): Promise<InitializeResponse>;
     private setCreditCardEncryptKey;
     static ɵfac: i0.ɵɵFactoryDeclaration<InitializeService, never>;

package/lib/core/payment/payment.service.d.ts

@@ -21,6 +21,9 @@ import { ThreeDsService } from './three-ds/three-ds.service';
 import { CreditCardStateService } from './credit-card-state/credit-card-state.service';
 import { FormState } from './form/form-state.interface';
 import { FormMessagesService } from './form-messages/form-messages.service';
+import { SettingsService } from '../settings/settings.service';
+import { CountryService } from '../country/country.service';
+import { SdkPaymentSystemsInitialData } from '../sdk-payment-systems/sdk-payment-systems-initial-data.interface';
 import * as i0 from "@angular/core";
 export declare class PaymentService {
     private readonly initializeService;
@@ -34,6 +37,8 @@ export declare class PaymentService {
     private readonly controlConfigService;
     private readonly threeDsService;
     private readonly formMessagesService;
+    private readonly settingsService;
+    private readonly countryService;
     form: UntypedFormGroup | null;
     get formFieldsStatus$(): Observable<FormFieldsStatus>;
     private data;
@@ -45,10 +50,11 @@ export declare class PaymentService {
     private formDestroy$;
     private readonly formFieldsStatusSubject;
     private isSavingMethodMode;
-    constructor(initializeService: InitializeService, submitService: SubmitService, syncService: SyncService, formService: FormService, statusService: StatusService, financeDetailsService: FinanceDetailsService, creditCardStateService: CreditCardStateService, nextActionService: NextActionService, controlConfigService: ControlConfigService, threeDsService: ThreeDsService, formMessagesService: FormMessagesService);
+    constructor(initializeService: InitializeService, submitService: SubmitService, syncService: SyncService, formService: FormService, statusService: StatusService, financeDetailsService: FinanceDetailsService, creditCardStateService: CreditCardStateService, nextActionService: NextActionService, controlConfigService: ControlConfigService, threeDsService: ThreeDsService, formMessagesService: FormMessagesService, settingsService: SettingsService, countryService: CountryService);
     initialize(config: PaymentConfig): Promise<Field[]>;
     submit(): Promise<NextAction | null | void>;
     getFields(): Field[];
+    getInitialDataForSdkPaymentSystems(): SdkPaymentSystemsInitialData;
     getPid(): number | null;
     validate(field: Field): Promise<ValidationErrors | null>;
     runThreeDs(): void;

package/lib/core/payment/status/save-payment-method-status/save-payment-method-status.service.d.ts

@@ -1,6 +1,7 @@
 import { StatusRequestParams } from '../status-request/status-request-params.interface';
 import { Status } from '../status.interface';
 import { StatusRequestService } from '../status-request/status-request.service';
+import { StatusUpdatedActionCreator } from '../../actions/status-updated/status-updated.action.class';
 import { ListenStatusService } from '../listen-status/listen-status.service';
 import { SavedPaymentAccountChangesService } from './api/saved-payment-account-changes.service';
 import { NextActionService } from '../../actions/next-action.service';
@@ -12,12 +13,13 @@ export declare class SavePaymentMethodStatusService {
     private readonly savedPaymentAccountChangesService;
     private readonly nextActionService;
     private readonly checkStatusService;
+    private readonly statusUpdatedActionCreator;
     private savePaymentMethodStatus?;
     private listenStatusSubscription;
     private statusChecked;
     private accountData?;
     private status?;
-    constructor(statusRequestService: StatusRequestService, listenStatusService: ListenStatusService, savedPaymentAccountChangesService: SavedPaymentAccountChangesService, nextActionService: NextActionService, checkStatusService: CheckStatusService);
+    constructor(statusRequestService: StatusRequestService, listenStatusService: ListenStatusService, savedPaymentAccountChangesService: SavedPaymentAccountChangesService, nextActionService: NextActionService, checkStatusService: CheckStatusService, statusUpdatedActionCreator: StatusUpdatedActionCreator);
     getStatus(params: StatusRequestParams): Promise<Status>;
     private checkStatus;
     private savingFailedOrCancel;

package/lib/core/payment/status/status.service.d.ts

@@ -3,6 +3,7 @@ import { StatusRequestParams } from './status-request/status-request-params.inte
 import { ListenStatusService } from './listen-status/listen-status.service';
 import { Status } from './status.interface';
 import { NextActionService } from '../actions/next-action.service';
+import { StatusUpdatedActionCreator } from '../actions/status-updated/status-updated.action.class';
 import { UrlService } from '../../url/url.service';
 import { FinanceDetailsService } from '../finance-details/finance-details.service';
 import { SavePaymentMethodStatusService } from './save-payment-method-status/save-payment-method-status.service';
@@ -14,7 +15,8 @@ export declare class StatusService {
     private readonly listenStatusService;
     private readonly nextActionService;
     private readonly savePaymentMethodStatusService;
-    constructor(urlService: UrlService, statusRequestService: StatusRequestService, financeDetailsService: FinanceDetailsService, listenStatusService: ListenStatusService, nextActionService: NextActionService, savePaymentMethodStatusService: SavePaymentMethodStatusService);
+    private readonly statusUpdatedActionCreator;
+    constructor(urlService: UrlService, statusRequestService: StatusRequestService, financeDetailsService: FinanceDetailsService, listenStatusService: ListenStatusService, nextActionService: NextActionService, savePaymentMethodStatusService: SavePaymentMethodStatusService, statusUpdatedActionCreator: StatusUpdatedActionCreator);
     getStatus(params: StatusRequestParams): Promise<Status>;
     getStatusWithUrlSearchParams(url?: string): Promise<Status>;
     private getRequestParamsFromUrl;

package/lib/core/payment/sync/sync.service.d.ts

@@ -8,6 +8,7 @@ import { SyncRequestFactory } from './request/sync-request.token';
 import { SyncResponse } from './response/sync-response.class';
 import { SyncResponseFactory } from './response/sync-response.token';
 import { NextActionService } from '../actions/next-action.service';
+import { ShowErrorsActionCreator } from '../actions/show-errors/show-errors.action.class';
 import { XpsApiService } from '../xps-api/xps-api.service';
 import { FieldAsyncValidation } from './field-async-validation.interface';
 import { EncryptCreditCardService } from '../../encrypt-credit-card/encrypt-credit-card.service';
@@ -21,12 +22,13 @@ export declare class SyncService extends EmitDataService<XpsResponse> {
     private readonly settingsService;
     private readonly xpsResponseErrorsMappingService;
     private readonly encryptCreditCardService;
+    private readonly showErrorsActionCreator;
     private prevFieldSyncStates;
     private form;
     private fields;
     private fieldSyncTimers;
     private readonly fieldAsyncValidation;
-    constructor(requestFactory: SyncRequestFactory, responseFactory: SyncResponseFactory, xpsApiService: XpsApiService, nextActionService: NextActionService, settingsService: SettingsService, xpsResponseErrorsMappingService: XpsResponseErrorsMappingService, encryptCreditCardService: EncryptCreditCardService);
+    constructor(requestFactory: SyncRequestFactory, responseFactory: SyncResponseFactory, xpsApiService: XpsApiService, nextActionService: NextActionService, settingsService: SettingsService, xpsResponseErrorsMappingService: XpsResponseErrorsMappingService, encryptCreditCardService: EncryptCreditCardService, showErrorsActionCreator: ShowErrorsActionCreator);
     get fieldAsyncValidation$(): Observable<FieldAsyncValidation>;
     setup(form: UntypedFormGroup, fields: Field[]): void;
     reset(): void;

package/lib/core/payment/three-ds/three-ds.service.d.ts

@@ -1,12 +1,16 @@
 import { NextActionService } from '../actions/next-action.service';
 import { ThreeDs20Service } from './three-ds-20/three-ds20.service';
+import { ThreeDsActionCreator } from '../actions/three-ds/three-ds.action.class';
+import { CheckStatusActionCreator } from '../actions/check-status/check-status.action.class';
 import { SubmitResponse } from '../submit/response/submit-response.class';
 import * as i0 from "@angular/core";
 export declare class ThreeDsService {
     private readonly threeDs20Service;
     private readonly nextActionService;
+    private readonly checkStatusActionCreator;
+    private readonly threeDsActionCreator;
     private statusSubscription;
-    constructor(threeDs20Service: ThreeDs20Service, nextActionService: NextActionService);
+    constructor(threeDs20Service: ThreeDs20Service, nextActionService: NextActionService, checkStatusActionCreator: CheckStatusActionCreator, threeDsActionCreator: ThreeDsActionCreator);
     checkThreeDs(params: SubmitResponse): void;
     stopChecking(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ThreeDsService, never>;

package/lib/core/payment/xps-checkout.d.ts

@@ -0,0 +1,17 @@
+export interface XpsCheckout<Fields = {
+    [key: string]: unknown;
+}> {
+    request: {
+        form: {
+            attributes: {
+                action: string;
+                method: 'GET' | 'POST';
+                encoding: string;
+            };
+            fields: Fields;
+        };
+        include: unknown;
+        cookies: unknown;
+    };
+    signature: string;
+}

package/lib/core/sdk-payment-systems/google-pay/google-pay-checkout.interface.d.ts

@@ -0,0 +1,17 @@
+import { XpsCheckout } from '../../payment/xps-checkout';
+export type GooglePayCheckout = XpsCheckout<{
+    amexCardNotification: string;
+    currency: string;
+    descriptor: string;
+    environment: string;
+    invoice: number;
+    isReadyToPayRequest: string;
+    itemDescription: string;
+    locale: string;
+    paymentDataRequest: string;
+    returnFailUrl: string;
+    returnSuccessUrl: string;
+    sum: string;
+    cpf_number: number;
+    agreements: string[];
+}>;

package/lib/core/sdk-payment-systems/google-pay/google-pay-init-params.interface.d.ts

@@ -0,0 +1,4 @@
+export interface GooglePayInitParams {
+    isSandbox: boolean;
+    country: string;
+}

package/lib/core/sdk-payment-systems/google-pay/google-pay-library.interface.d.ts

@@ -0,0 +1,83 @@
+export declare class GooglePayClient {
+    constructor(options: {
+        environment: string;
+    });
+    isReadyToPay(isReadyToPayRequest: string): Promise<{
+        result: boolean;
+    }>;
+    createButton(options: ButtonOptions): HTMLButtonElement;
+    loadPaymentData(paymentDataRequest: GooglePayPaymentRequest): Promise<PaymentDataResponse>;
+    prefetchPaymentData(paymentDataRequest: GooglePayPaymentRequest): void;
+}
+export interface GooglePayClientInit {
+    new (options: {
+        environment: string;
+    }): GooglePayClient;
+}
+export interface PaymentDataRequest {
+    transactionInfo: {
+        currencyCode: string;
+        totalPriceStatus: string;
+        totalPrice: string;
+    };
+}
+export interface PaymentDataResponse {
+    paymentMethodData: {
+        tokenizationData: {
+            token: string;
+        };
+    };
+}
+export interface ButtonOptions {
+    onClick(): void;
+    allowedPaymentMethods: GooglePayPaymentMethod[];
+    buttonColor?: 'default' | 'black' | 'white';
+    buttonType?: 'plain' | 'buy';
+    buttonSizeMode?: 'static' | 'fill';
+}
+export interface GooglePayLibrary {
+    payments: {
+        api: {
+            PaymentsClient: GooglePayClientInit;
+        };
+    };
+}
+export interface GooglePayPaymentMethod {
+    type: string;
+    parameters: {
+        allowedAuthMethods: string[];
+        allowedCardNetworks: string[];
+        allowPrepaidCards: boolean;
+        billingAddressRequired: boolean;
+        billingAddressParameters: {
+            format: string;
+            phoneNumberRequired: boolean;
+        };
+    };
+    tokenizationSpecification: {
+        type: string;
+        parameters: {
+            gateway: 'vantiv';
+            'vantiv:merchantPayPageId': string;
+            'vantiv:merchantOrderId': string;
+            'vantiv:merchantTransactionId': string;
+            'vantiv:merchantReportGroup': string;
+        };
+    };
+}
+export interface GooglePayPaymentRequest {
+    apiVersion: number;
+    apiVersionMinor: number;
+    merchantInfo: {
+        merchantId: string;
+    };
+    allowedPaymentMethods: GooglePayPaymentMethod[];
+    transactionInfo: {
+        currencyCode: string;
+        totalPriceStatus: string;
+        totalPrice: string;
+        countryCode: string;
+    };
+    emailRequired: boolean;
+    shippingAddressRequired: boolean;
+}

package/lib/core/sdk-payment-systems/google-pay/google-pay.service.d.ts

@@ -0,0 +1,35 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { PaymentSystemProcessingService } from '../payment-systems/payment-system-processing.service';
+import { ExtendedWindow } from '../../extended-window.interface';
+import { GooglePayInitParams } from './google-pay-init-params.interface';
+import { HttpClient } from '@angular/common/http';
+import { CheckStatusAction } from '../../payment/actions/check-status/check-status.action.type';
+import * as i0 from "@angular/core";
+export declare class GooglePayService {
+    private readonly window;
+    readonly commonPayProcessingService: PaymentSystemProcessingService;
+    readonly httpClient: HttpClient;
+    readonly injector: Injector;
+    private readonly googlePayScriptUrl;
+    private readonly readyToPay;
+    private checkout;
+    private googlePaymentClient;
+    private isSandbox;
+    private country;
+    private get libraryWasInitialized();
+    private get googlePaymentClientWasInitialized();
+    constructor(window: ExtendedWindow, commonPayProcessingService: PaymentSystemProcessingService, httpClient: HttpClient, injector: Injector);
+    get readyToPay$(): Observable<boolean | null>;
+    isReadyToPay(): boolean | null;
+    sendUserBack(path: string): void;
+    initGooglePayLibrary(data: GooglePayInitParams): void;
+    checkPaymentDevice(base64checkoutData: string): void;
+    proceedCheckout(): Promise<CheckStatusAction | null>;
+    createButton(onClickHandler: () => void): HTMLButtonElement | null;
+    private setupGooglePayClient;
+    private onLoadScript;
+    private isCancelledStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GooglePayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GooglePayService>;
+}

package/lib/core/sdk-payment-systems/payment-systems/payment-system-processing.service.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { GooglePayCheckout } from '../google-pay/google-pay-checkout.interface';
+import { ExtendedWindow } from '../../extended-window.interface';
+import * as i0 from "@angular/core";
+export type CommonCheckout = GooglePayCheckout;
+export declare class PaymentSystemProcessingService {
+    private readonly window;
+    private readonly statusUrl;
+    private readonly initialize;
+    constructor(window: ExtendedWindow);
+    get initialize$(): Observable<boolean>;
+    get status$(): Observable<string>;
+    emitPayment(payment: string): void;
+    emitInitialize(isInitialized: boolean): void;
+    getDecodedCheckout<T extends CommonCheckout>(base64checkoutData: string): T;
+    loadScript(url: string, onLoad: () => void, addScriptCustomAttributes?: (script: HTMLScriptElement) => HTMLScriptElement): void;
+    isInitialized(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentSystemProcessingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaymentSystemProcessingService>;
+}

package/lib/core/sdk-payment-systems/sdk-payment-methods.const.d.ts

@@ -0,0 +1 @@
+export declare const googlePayPid = 3431;

package/lib/core/sdk-payment-systems/sdk-payment-systems-initial-data.interface.d.ts

@@ -0,0 +1,6 @@
+import { XpsBoolean } from '../xps-boolean.enum';
+export interface SdkPaymentSystemsInitialData {
+    data: string;
+    sandbox: XpsBoolean;
+    country: string;
+}

package/lib/core/sdk-payment-systems/sdk-payment-systems.interface.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { GooglePayInitParams } from './google-pay/google-pay-init-params.interface';
+import { SdkPaymentSystemsInitialData } from './sdk-payment-systems-initial-data.interface';
+import { CheckStatusAction } from '../payment/actions/check-status/check-status.action.type';
+export interface SdkPaymentSystems {
+    googlePay: {
+        readyToPay$: Observable<boolean | null>;
+        isReadyToPay(): boolean | null;
+        initGooglePayLibrary(params: GooglePayInitParams): void;
+        checkPaymentDevice(base64checkoutData: string): void;
+        proceedCheckout(): Promise<CheckStatusAction | null>;
+        createButton(onClickHandler: () => void): HTMLButtonElement | null;
+        sendUserBack(path: string): void;
+    };
+    commonPayProcessingService: {
+        initialize$: Observable<boolean>;
+        isInitialized(): boolean;
+        status$: Observable<string>;
+    };
+    getInitialData(): SdkPaymentSystemsInitialData;
+}

package/lib/core-library.service.d.ts

@@ -29,6 +29,9 @@ import { NextAction } from './core/payment/actions/next-action.interface';
 import { Balance } from './core/settings/balance.interface';
 import { FormMessagesService } from './core/payment/form-messages/form-messages.service';
 import { EditSavedMethodsService } from './core/edit-saved-methods/edit-saved-methods.service';
+import { GooglePayService } from './core/sdk-payment-systems/google-pay/google-pay.service';
+import { PaymentSystemProcessingService } from './core/sdk-payment-systems/payment-systems/payment-system-processing.service';
+import { SdkPaymentSystems } from './core/sdk-payment-systems/sdk-payment-systems.interface';
 import * as i0 from "@angular/core";
 export declare class CoreLibraryService {
     private readonly settingsService;
@@ -47,6 +50,8 @@ export declare class CoreLibraryService {
     private readonly creditCardStateService;
     private readonly formMessagesService;
     private readonly editSavedMethodsService;
+    private readonly googlePayService;
+    private readonly commonPayProcessingService;
     paymentMethods: {
         getList: (isSaveMethodMode?: boolean) => Promise<PaymentMethod[]>;
         getQuickMethods: () => Promise<PaymentMethod[]>;
@@ -54,7 +59,8 @@ export declare class CoreLibraryService {
         getUserBalance: () => Promise<UserBalanceResponse>;
         deleteSavedMethod: (id: number, type: string) => Promise<boolean>;
     };
-    constructor(settingsService: SettingsService, countryService: CountryService, paymentMethodsService: PaymentMethodsService, savedMethodsService: SavedMethodsService, userBalanceService: UserBalanceService, paymentConfigService: PaymentConfigService, paymentService: PaymentService, deviceFingerPrintService: DeviceFingerPrintService, financeDetailsService: FinanceDetailsService, legalService: LegalService, statusService: StatusService, nextActionService: NextActionService, creditCardService: CreditCardService, creditCardStateService: CreditCardStateService, formMessagesService: FormMessagesService, editSavedMethodsService: EditSavedMethodsService);
+    sdkPaymentSystems: SdkPaymentSystems;
+    constructor(settingsService: SettingsService, countryService: CountryService, paymentMethodsService: PaymentMethodsService, savedMethodsService: SavedMethodsService, userBalanceService: UserBalanceService, paymentConfigService: PaymentConfigService, paymentService: PaymentService, deviceFingerPrintService: DeviceFingerPrintService, financeDetailsService: FinanceDetailsService, legalService: LegalService, statusService: StatusService, nextActionService: NextActionService, creditCardService: CreditCardService, creditCardStateService: CreditCardStateService, formMessagesService: FormMessagesService, editSavedMethodsService: EditSavedMethodsService, googlePayService: GooglePayService, commonPayProcessingService: PaymentSystemProcessingService);
     init(configuration: InitConfiguration): Promise<void>;
     getStatus(url?: string): Promise<Status>;
     setCountry(country: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xsolla/payment-client-core",
-  "version": "0.1.22",
+  "version": "0.2.1",
   "peerDependencies": {
     "@angular/common": "^15.2.0",
     "@angular/core": "^15.2.0",