@xsolla/payment-client-core 0.2.43 → 0.2.45

package/lib/core/environment.interface.d.ts

@@ -0,0 +1 @@
+export type Environment = 'production' | 'staging' | 'development';

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

@@ -4,8 +4,8 @@ export interface Action<T = string, D = object> {
     type: T;
     data: D;
 }
-export interface ActionCreator<T = string, D = unknown> {
+export interface ActionCreator<R = SubmitResponse, T = string, D = unknown> {
     type: T;
-    isSuitable(response?: SubmitResponse): boolean;
+    isSuitable(response?: R): boolean;
     getActionData(actionData?: D): NextAction;
 }

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

@@ -1,7 +1,7 @@
 import { Injector } from '@angular/core';
 import { Observable } from 'rxjs';
-import { NextAction } from './next-action.interface';
 import { SubmitResponse } from '../submit/response/submit-response.class';
+import { NextAction } from './next-action.interface';
 import { NextActionTokens } from './next-actions';
 import { ShowErrorsActionCreator } from './show-errors/show-errors.action.class';
 import * as i0 from "@angular/core";

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

@@ -1,6 +1,6 @@
 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 nextActionsToken: InjectionToken<ActionCreator<import("../submit/response/submit-response.class").SubmitResponse, string, unknown>>;
 export declare const nextActions: NextActionTokens;
 export declare const flowUpdateNextActions: NextActionTokens;

package/lib/core/payment/field-names.enum.d.ts

@@ -21,6 +21,7 @@ export declare enum FieldNames {
     description = "description",
     email = "email",
     psEmail = "psEmail",
+    psAccountCountry = "psAccountCountry",
     bazitemail = "bazitemail",
     euCheck = "eu_check",
     extraCvv = "extra_cvv",
@@ -75,5 +76,7 @@ export declare enum FieldNames {
     isSandbox = "isSandbox",
     payInstanceAccountId = "payInstanceAccountId",
     getApplePaySessionUrl = "getApplePaySessionUrl",
-    payViaCheckoutUrl = "payViaCheckoutUrl"
+    payViaCheckoutUrl = "payViaCheckoutUrl",
+    googlePayInitData = "googlePayInitData",
+    googlePayPaymentData = "googlePayPaymentData"
 }

package/lib/core/payment/field.interface.d.ts

@@ -14,7 +14,7 @@ export interface Field {
     regex?: string;
     validation_error_msg?: string;
     label_hint?: string;
-    javascript: {
+    javascript?: {
         change: {
             mutableFields: string[];
             staticParams: {

package/lib/core/payment/finance-details/finance-details.service.d.ts

@@ -14,6 +14,7 @@ export declare class FinanceDetailsService extends EmitDataService<FinanceDetail
     constructor(sessionService: SessionService, summaryFinanceDetailsAdapterService: SummaryFinanceDetailsAdapterService, statusFinanceDetailsAdapterService: StatusFinanceDetailsAdapterService);
     emitWithSummary(summary?: XpsSummary): void;
     emitWithStatus(status?: Status): void;
+    getDetailsFromSummary(summary: XpsSummary): FinanceDetails;
     static ɵfac: i0.ɵɵFactoryDeclaration<FinanceDetailsService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FinanceDetailsService>;
 }

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

@@ -0,0 +1,11 @@
+import { InitializeNextAction } from '../initialize-actions/next-action.interface';
+import { InitializeResponse } from '../initialize/response/initialize-response.class';
+export interface InitializeAction<T = string, D = object> {
+    type: T;
+    data: D;
+}
+export interface InitializeActionCreator<R = InitializeResponse, T = string, D = unknown> {
+    type: T;
+    isSuitable(response?: R): boolean;
+    getActionData(actionData?: D): InitializeNextAction;
+}

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

@@ -0,0 +1,16 @@
+import { Injector } from '@angular/core';
+import { InitializeResponse } from '../initialize/response/initialize-response.class';
+import { InitializeNextActionTokens } from './initialize-next-actions';
+import { InitializeNextAction } from './next-action.interface';
+import * as i0 from "@angular/core";
+export declare class InitializeNextActionService {
+    private readonly initializeNextActionTokens;
+    private readonly injector;
+    private readonly initializeNextActionsList;
+    constructor(initializeNextActionTokens: InitializeNextActionTokens, injector: Injector);
+    getNextAction(response: InitializeResponse): InitializeNextAction | null;
+    private fillNextActionsList;
+    private findNextAction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitializeNextActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InitializeNextActionService>;
+}

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

@@ -0,0 +1,5 @@
+import { InjectionToken, ProviderToken } from '@angular/core';
+import { InitializeActionCreator } from './action.interface';
+export type InitializeNextActionTokens = Array<ProviderToken<InitializeActionCreator>>;
+export declare const initializeNextActionsToken: InjectionToken<InitializeActionCreator<import("../initialize/response/initialize-response.class").InitializeResponse, string, unknown>>;
+export declare const initializeNextActions: InitializeNextActionTokens;

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

@@ -0,0 +1,2 @@
+import { InitializeSpecialButtonAction } from './special-button/special-button.action.type';
+export type InitializeNextAction = InitializeSpecialButtonAction;

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

@@ -0,0 +1,17 @@
+import { ElkLoggerService } from '../../../exceptions-handling/elk/elk-logger.service';
+import { InitializeResponse } from '../../initialize/response/initialize-response.class';
+import { InitializeActionCreator } from '../action.interface';
+import { InitializeSpecialButtonAction, SpecialButtonActionType } from './special-button.action.type';
+import * as i0 from "@angular/core";
+export declare class InitializeSpecialButtonActionCreator implements InitializeActionCreator {
+    private readonly elkLoggerService;
+    type: SpecialButtonActionType;
+    private readonly pids;
+    private readonly sdkPaymentMethodsName;
+    constructor(elkLoggerService: ElkLoggerService);
+    getActionData(response: InitializeResponse): InitializeSpecialButtonAction;
+    isSuitable(response: InitializeResponse): boolean;
+    private getPaymentMethodName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitializeSpecialButtonActionCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InitializeSpecialButtonActionCreator>;
+}

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

@@ -0,0 +1,6 @@
+import { InitializeAction } from '../action.interface';
+export type SpecialButtonActionType = 'special_button';
+export interface SpecialButtonActionData {
+    buttonName: string;
+}
+export type InitializeSpecialButtonAction = InitializeAction<SpecialButtonActionType, SpecialButtonActionData>;

package/lib/core/payment/initialized-form.inteface.d.ts

@@ -1,5 +1,7 @@
 import { Field } from './field.interface';
+import { InitializeNextAction } from './initialize-actions/next-action.interface';
 export interface InitializedForm {
     fields: Field[];
     isFormAutoSubmitted: boolean;
+    nextAction: InitializeNextAction | null;
 }

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

@@ -1,5 +1,6 @@
 import { Observable } from 'rxjs';
 import { FormControlStatus, UntypedFormGroup } from '@angular/forms';
+import { SubmitResponse } from './submit/response/submit-response.class';
 import { FormService } from './form/form.service';
 import { InitializeService } from './initialize/initialize.service';
 import { Status } from './status/status.interface';
@@ -7,6 +8,7 @@ import { SubmitService } from './submit/submit.service';
 import { SyncService } from './sync/sync.service';
 import { StatusService } from './status/status.service';
 import { NextActionService } from './actions/next-action.service';
+import { InitializeNextActionService } from './initialize-actions/initialize-next-action.service';
 import { ControlConfig } from './form/controls/control-config';
 import { ControlConfigService } from './form/controls/control-config.service';
 import { FinanceDetails } from './finance-details/finance-details.interface';
@@ -31,8 +33,11 @@ import { ControlStatus } from './form/control-status.interface';
 import { InitializedForm } from './initialized-form.inteface';
 import { CashPaymentData } from './cash-payment-data.interface';
 import { PrintInstructionService } from '../xsolla-number/api/print-instruction/print-instruction.service';
+import { SyncResponse } from './sync/response/sync-response.class';
+import { ElkLoggerService } from '../exceptions-handling/elk/elk-logger.service';
 import * as i0 from "@angular/core";
 export declare class PaymentService {
+    private readonly elkLoggerService;
     private readonly initializeService;
     private readonly submitService;
     private readonly syncService;
@@ -41,6 +46,7 @@ export declare class PaymentService {
     private readonly financeDetailsService;
     private readonly creditCardStateService;
     private readonly nextActionService;
+    private readonly initializeNextActionService;
     private readonly controlConfigService;
     private readonly threeDsService;
     private readonly formMessagesService;
@@ -64,17 +70,19 @@ export declare class PaymentService {
     private readonly formFieldsStatusSubject;
     private readonly _formResponse$;
     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, settingsService: SettingsService, countryService: CountryService, checkStatusActionCreator: CheckStatusActionCreator, printInstructionService: PrintInstructionService);
+    constructor(elkLoggerService: ElkLoggerService, initializeService: InitializeService, submitService: SubmitService, syncService: SyncService, formService: FormService, statusService: StatusService, financeDetailsService: FinanceDetailsService, creditCardStateService: CreditCardStateService, nextActionService: NextActionService, initializeNextActionService: InitializeNextActionService, controlConfigService: ControlConfigService, threeDsService: ThreeDsService, formMessagesService: FormMessagesService, settingsService: SettingsService, countryService: CountryService, checkStatusActionCreator: CheckStatusActionCreator, printInstructionService: PrintInstructionService);
     initialize(config: PaymentConfiguration): Promise<InitializedForm>;
     submit(): Promise<NextAction | null | void>;
+    submitWithFields(fields?: Field[]): Promise<SubmitResponse>;
     getFields(): Field[];
     getControlStatus(name: FieldNames): ControlStatus | null;
-    getInitialDataForSdkPaymentSystems(): SdkPaymentSystemsInitialData;
+    getInitialDataForSdkPaymentSystems(): Promise<SdkPaymentSystemsInitialData>;
     getQrCode(): string;
     getCashPaymentData(): CashPaymentData;
     getPid(): number | null;
     getSubmitButtonText(): string | null;
     validate(field: Field): Promise<ValidationErrors | null>;
+    calculateField(changedField: Field, fields: Field[]): Promise<SyncResponse>;
     runThreeDs(): void;
     getFinanceDetails(): FinanceDetails | null;
     updateFieldFormState(fieldName: string, formState: FormState): void;
@@ -97,6 +105,7 @@ export declare class PaymentService {
     private emitFormResponse;
     private getInitializeMessages;
     private canAutoSubmit;
+    private getSdkPaymentDataFromResponse;
     static ɵfac: i0.ɵɵFactoryDeclaration<PaymentService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PaymentService>;
 }

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

@@ -40,7 +40,7 @@ export declare class SyncService extends EmitDataService<XpsResponse> {
     reset(): void;
     validate(field: Field, delay?: number): Promise<ValidationErrors | null>;
     getSyncValidationErrors(field: Field): ValidationErrors | null;
-    protected request(field: Field): Promise<SyncResponse>;
+    request(field: Field, fields?: Field[], form?: UntypedFormGroup): Promise<SyncResponse>;
     private isReadyField;
     private getPrevFieldSyncState;
     private setPrevFieldSyncState;

package/lib/core/payment/xps-error.interface.d.ts

@@ -3,5 +3,6 @@ export interface XpsError {
     code: number;
     message: string;
     element_name?: string;
+    title?: string;
     alternative_instances?: PaymentMethodApi[];
 }

package/lib/core/script-tracker/script-tracker.service.d.ts

@@ -0,0 +1,19 @@
+import { UserBehaviourAnalyticsService } from '../user-behaviour-analytics/user-behaviour-analytics.service';
+import { Environment } from '../environment.interface';
+import * as i0 from "@angular/core";
+export declare class ScriptTrackerService {
+    private readonly userBehaviourAnalyticsService;
+    private readonly currentScripts;
+    private readonly scriptHostBlacklist;
+    private readonly SCRIPT_DEBOUNCE_TIME_MS;
+    private readonly scriptTracked$;
+    constructor(userBehaviourAnalyticsService: UserBehaviourAnalyticsService);
+    initScriptTracking(environment: Environment): void;
+    private handleScriptData;
+    private getTrackedScripts;
+    private checkCurrentScripts;
+    private setupScriptObserver;
+    private trackScript;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScriptTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScriptTrackerService>;
+}

package/lib/core/sdk-payment-systems/google-pay/check-payment-device-data.interface.d.ts

@@ -0,0 +1,9 @@
+import { Field } from '../../payment/field.interface';
+import { SubmitResponse } from '../../payment/submit/response/submit-response.class';
+import { XpsSummary } from '../../payment/xps-summary.interface';
+export interface CheckPaymentDeviceData {
+    base64checkoutData: string | null;
+    submitResponse: SubmitResponse | null;
+    fields: Field[];
+    summary: XpsSummary | null;
+}

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

@@ -1,4 +1,10 @@
+import { Field } from '../../payment/field.interface';
+import { PaymentAuthorizedHandler, PaymentDataChangedHandler } from './google-pay-library.interface';
 export interface GooglePayInitParams {
     isSandbox: boolean;
+    isInstantPayFlow: boolean;
     country: string;
+    fields: Field[];
+    onPaymentDataChanged: PaymentDataChangedHandler;
+    onPaymentAuthorized: PaymentAuthorizedHandler;
 }

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

@@ -1,18 +1,163 @@
-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;
+type ApiVersion = number;
+type ApiVersionMinor = number;
+interface Address {
+    name: string;
+    address1: string;
+    address2: string;
+    address3: string;
+    locality: string;
+    administrativeArea: string;
+    countryCode: string;
+    postalCode: string;
+    sortingCode: string;
+}
+export type DisplayItems = Array<{
+    label: string;
+    type: string;
+    price: string;
+}>;
+export interface TransactionInfo {
+    currencyCode?: string;
+    totalPriceStatus: string;
+    totalPrice?: number | string;
+    countryCode?: string;
+    totalPriceLabel?: string;
+    displayItems?: DisplayItems;
+}
+export interface AllowedPaymentMethod {
+    type: string;
+    parameters: {
+        allowedAuthMethods: string[];
+        allowedCardNetworks: string[];
+        allowPrepaidCards: boolean;
+        billingAddressRequired: boolean;
+        billingAddressParameters: {
+            format: string;
+            phoneNumberRequired: boolean;
+        };
+    };
+    tokenizationSpecification: {
+        type: string;
+        parameters: {
+            gateway: string;
+            'vantiv:merchantPayPageId'?: string;
+            'vantiv:merchantOrderId'?: string;
+            'vantiv:merchantTransactionId'?: string;
+            'vantiv:merchantReportGroup'?: string;
+        };
+    };
+}
+export interface IsReadyToPayRequest {
+    apiVersion: ApiVersion;
+    apiVersionMinor: ApiVersionMinor;
+    allowedPaymentMethods: AllowedPaymentMethod[];
+}
+export interface GooglePayPaymentRequest {
+    apiVersion: ApiVersion;
+    apiVersionMinor: ApiVersionMinor;
+    merchantInfo: {
+        merchantId: string;
+    };
+    allowedPaymentMethods: AllowedPaymentMethod[];
+    transactionInfo: TransactionInfo;
+    emailRequired: boolean;
+    shippingAddressRequired: boolean;
+    callbackIntents: string[];
+}
+export interface PaymentAuthorizationResult {
+    transactionState: 'SUCCESS' | 'ERROR';
+    error?: {
+        reason: string;
+        message: string;
+        intent: string;
+    };
+}
+export interface PaymentData {
+    apiVersion: number;
+    apiVersionMinor: number;
+    paymentMethodData: {
+        type: string;
+        description: string;
+        info: {
+            cardDetails: string;
+            assuranceDetails: {
+                accountVerified: boolean;
+                cardHolderAuthenticated: boolean;
+            };
+            cardNetwork: string;
+            billingAddress?: Address;
+        };
+        tokenizationData: {
+            type: string;
+            token?: string;
+        };
+    };
+    email?: string;
+    shippingAddress?: Address;
+}
+export interface PaymentDataRequestUpdate {
+    newTransactionInfo?: {
+        displayItems?: Array<{
+            label: string;
+            type: string;
+            price: string;
+        }>;
+        currencyCode: string;
+        countryCode?: string;
+        transactionId?: string;
+        totalPriceStatus: string;
+        totalPrice: string;
+        totalPriceLabel?: string;
+        checkoutOption?: string;
+    };
+    newShippingOptionParameters?: {
+        defaultSelectedOptionId: string;
+        shippingOptions?: Array<{
+            id: string;
+            label: string;
+            description?: string;
+        }>;
+    };
+    newOfferInfo?: {
+        offers: Array<{
+            redemptionCode: string;
+            description: string;
+        }>;
+    };
+    error?: {
+        reason: string;
+        message: string;
+        intent: string;
+    };
+}
+export interface GoogleInitData {
+    isReadyToPayRequest: IsReadyToPayRequest;
+    paymentDataRequest: GooglePayPaymentRequest;
+    amexCardNotification?: string;
+}
+export interface IntermediatePaymentData {
+    callbackTrigger?: 'INITIALIZE' | 'SHIPPING_ADDRESS' | 'SHIPPING_OPTION';
+    shippingAddress?: {
+        administrativeArea: string;
+        countryCode: string;
+        locality: string;
+        postalCode: string;
+    };
+    shippingOptionData?: {
+        id: string;
+    };
+}
+export type PaymentDataChangedHandler = (intermediatePaymentData: IntermediatePaymentData) => Promise<PaymentDataRequestUpdate>;
+export type PaymentAuthorizedHandler = (paymentData: PaymentData) => Promise<PaymentAuthorizationResult>;
+export interface GooglePayClientInitData {
+    environment: string;
+    paymentDataCallbacks?: {
+        onPaymentDataChanged: PaymentDataChangedHandler;
+        onPaymentAuthorized: PaymentAuthorizedHandler;
+    };
 }
 export interface GooglePayClientInit {
-    new (options: {
-        environment: string;
-    }): GooglePayClient;
+    new (options: GooglePayClientInitData): GooglePayClient;
 }
 export interface PaymentDataRequest {
     transactionInfo: {
@@ -30,7 +175,7 @@ export interface PaymentDataResponse {
 }
 export interface ButtonOptions {
     onClick(): void;
-    allowedPaymentMethods: GooglePayPaymentMethod[];
+    allowedPaymentMethods: AllowedPaymentMethod[];
     buttonColor?: 'default' | 'black' | 'white';
     buttonType?: 'plain' | 'buy';
     buttonSizeMode?: 'static' | 'fill';
@@ -42,42 +187,15 @@ export interface GooglePayLibrary {
         };
     };
 }
-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;
+export declare class GooglePayClient {
+    constructor(options: {
+        environment: string;
+    });
+    isReadyToPay(isReadyToPayRequest: IsReadyToPayRequest): Promise<{
+        result: boolean;
+    }>;
+    createButton(options: ButtonOptions): HTMLButtonElement;
+    loadPaymentData(paymentDataRequest: GooglePayPaymentRequest): Promise<PaymentDataResponse>;
+    prefetchPaymentData(paymentDataRequest: GooglePayPaymentRequest): void;
 }
+export {};

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

@@ -1,33 +1,41 @@
 import { Injector } from '@angular/core';
 import { Observable } from 'rxjs';
-import { PaymentSystemProcessingService } from '../payment-systems/payment-system-processing.service';
+import { ElkLoggerService } from '../../exceptions-handling/elk/elk-logger.service';
 import { ExtendedWindow } from '../../extended-window.interface';
-import { GooglePayInitParams } from './google-pay-init-params.interface';
 import { CheckStatusAction } from '../../payment/actions/check-status/check-status.action.type';
+import { PaymentSystemProcessingService } from '../payment-systems/payment-system-processing.service';
+import { CheckPaymentDeviceData } from './check-payment-device-data.interface';
 import { GooglePayButtonColorType } from './google-pay-button-color.type';
+import { GooglePayInitParams } from './google-pay-init-params.interface';
+import { GooglePayCheckoutPaymentService } from './payment/google-pay-checkout-payment.service';
+import { GooglePayInstantPaymentService } from './payment/google-pay-instant-payment.service';
 import * as i0 from "@angular/core";
 export declare class GooglePayService {
     private readonly window;
-    readonly paymentSystemProcessingService: PaymentSystemProcessingService;
-    readonly injector: Injector;
+    private readonly elkLoggerService;
+    private readonly paymentSystemProcessingService;
+    private readonly googlePayCheckoutPaymentService;
+    private readonly googlePayInstantPaymentService;
+    private readonly injector;
     private readonly googlePayScriptUrl;
     private readonly readyToPay;
-    private checkout;
     private googlePaymentClient;
-    private isSandbox;
-    private country;
+    private initParams;
+    private paymentService;
+    private onPaymentDataChanged;
+    private onPaymentAuthorized;
     private get libraryWasInitialized();
     private get googlePaymentClientWasInitialized();
-    constructor(window: ExtendedWindow, paymentSystemProcessingService: PaymentSystemProcessingService, injector: Injector);
+    constructor(window: ExtendedWindow, elkLoggerService: ElkLoggerService, paymentSystemProcessingService: PaymentSystemProcessingService, googlePayCheckoutPaymentService: GooglePayCheckoutPaymentService, googlePayInstantPaymentService: GooglePayInstantPaymentService, injector: Injector);
     get readyToPay$(): Observable<boolean | null>;
     isReadyToPay(): boolean | null;
     initGooglePayLibrary(data: GooglePayInitParams): void;
-    checkPaymentDevice(base64checkoutData: string): void;
+    checkPaymentDevice(data: CheckPaymentDeviceData): void;
     proceedCheckout(): Promise<CheckStatusAction | null>;
     createButton(onClickHandler: () => void, buttonColor?: GooglePayButtonColorType): HTMLButtonElement | null;
     private setupGooglePayClient;
     private onLoadScript;
-    private isCancelledStatus;
+    private getPaymentService;
     static ɵfac: i0.ɵɵFactoryDeclaration<GooglePayService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GooglePayService>;
 }

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

@@ -0,0 +1,18 @@
+import { PaymentSystemProcessingService } from '../../payment-systems/payment-system-processing.service';
+import { AllowedPaymentMethod, GoogleInitData, GooglePayPaymentRequest, PaymentDataResponse } from '../google-pay-library.interface';
+import { GooglePayPaymentService, PreparePaymentParams } from './google-pay-payment-service.interface';
+import * as i0 from "@angular/core";
+export declare class GooglePayCheckoutPaymentService implements GooglePayPaymentService {
+    readonly paymentSystemProcessingService: PaymentSystemProcessingService;
+    private initParams;
+    private checkout;
+    constructor(paymentSystemProcessingService: PaymentSystemProcessingService);
+    preparePayment({ initParams, checkDeviceData, }: PreparePaymentParams): GoogleInitData | null;
+    getPaymentRequest(): GooglePayPaymentRequest | null;
+    getAllowedPaymentMethods(): AllowedPaymentMethod[];
+    handleSuccessfulPayment(response: PaymentDataResponse): void;
+    handleFailedPayment(error: unknown): void;
+    private isCancelledStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GooglePayCheckoutPaymentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GooglePayCheckoutPaymentService>;
+}

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

@@ -0,0 +1,18 @@
+import { SummaryFinanceDetailsAdapterService } from '../../../payment/finance-details/summary/summary-finance-details-adapter.service';
+import { AllowedPaymentMethod, GoogleInitData, GooglePayPaymentRequest } from '../google-pay-library.interface';
+import { GooglePayPaymentService, PreparePaymentParams } from './google-pay-payment-service.interface';
+import * as i0 from "@angular/core";
+export declare class GooglePayInstantPaymentService implements GooglePayPaymentService {
+    private readonly summaryFinanceDetailsAdapterService;
+    private initParams;
+    private googleInitData;
+    constructor(summaryFinanceDetailsAdapterService: SummaryFinanceDetailsAdapterService);
+    preparePayment({ initParams, checkDeviceData, }: PreparePaymentParams): GoogleInitData | null;
+    getPaymentRequest(): GooglePayPaymentRequest | null;
+    getAllowedPaymentMethods(): AllowedPaymentMethod[];
+    private extractGoogleInitData;
+    private getItemsTaxes;
+    private getTotalAmount;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GooglePayInstantPaymentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GooglePayInstantPaymentService>;
+}

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

@@ -0,0 +1,14 @@
+import { CheckPaymentDeviceData } from '../check-payment-device-data.interface';
+import { GooglePayInitParams } from '../google-pay-init-params.interface';
+import { AllowedPaymentMethod, GoogleInitData, GooglePayPaymentRequest, PaymentDataResponse } from '../google-pay-library.interface';
+export interface PreparePaymentParams {
+    initParams: GooglePayInitParams;
+    checkDeviceData: CheckPaymentDeviceData;
+}
+export interface GooglePayPaymentService {
+    preparePayment(params: PreparePaymentParams): GoogleInitData | null;
+    getPaymentRequest(): GooglePayPaymentRequest | null;
+    getAllowedPaymentMethods(): AllowedPaymentMethod[];
+    handleSuccessfulPayment?(response: PaymentDataResponse): void;
+    handleFailedPayment?(error: unknown): void;
+}

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

@@ -0,0 +1,7 @@
+import { CartLine } from '../../payment/finance-details/cart-line.interface';
+export interface UpdatedPrice {
+    total: number;
+    subtotalPayment?: CartLine | null;
+    subtotalDetails?: CartLine[];
+    totalDetails?: CartLine[];
+}

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

@@ -1,6 +1,12 @@
+import { Field } from '../payment/field.interface';
+import { SubmitResponse } from '../payment/submit/response/submit-response.class';
+import { XpsSummary } from '../payment/xps-summary.interface';
 import { XpsBoolean } from '../xps-boolean.enum';
 export interface SdkPaymentSystemsInitialData {
-    data: string;
     sandbox: XpsBoolean;
     country: string;
+    fields: Field[];
+    summary: XpsSummary | null;
+    submitResponse: SubmitResponse | null;
+    data: string | null;
 }