@xsolla/payment-client-core 0.2.11 → 0.2.13

package/lib/core/combined-payment-methods/combined-payment-methods.interface.d.ts

@@ -0,0 +1,9 @@
+import { PaymentMethod } from '../payment-methods/payment-method.interface';
+import { SavedMethod } from '../saved-methods/saved-method.interface';
+export interface CombinedPaymentMethods {
+    paymentMethods: {
+        quick: PaymentMethod[];
+        remained: PaymentMethod[];
+    };
+    savedMethods: SavedMethod[];
+}

package/lib/core/combined-payment-methods/combined-payment-methods.service.d.ts

@@ -0,0 +1,12 @@
+import { SavedMethodsService } from '../saved-methods/saved-methods.service';
+import { PaymentMethodsService } from '../payment-methods/payment-methods.service';
+import { CombinedPaymentMethods } from './combined-payment-methods.interface';
+import * as i0 from "@angular/core";
+export declare class CombinedPaymentMethodsService {
+    private readonly paymentMethodsService;
+    private readonly savedMethodsService;
+    constructor(paymentMethodsService: PaymentMethodsService, savedMethodsService: SavedMethodsService);
+    getCombinedPaymentMethods(): Promise<CombinedPaymentMethods>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CombinedPaymentMethodsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CombinedPaymentMethodsService>;
+}

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

@@ -1,6 +1,7 @@
 import { ApplePaySession } from 'braintree-web';
 import { GooglePayLibrary } from './sdk-payment-systems/google-pay/google-pay-library.interface';
 export interface ExtendedWindow extends Window {
+    PerformanceObserver?: typeof PerformanceObserver;
     ApplePaySession: typeof ApplePaySession;
     BraintreeData?: {
         _getDeviceData(): unknown;

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

@@ -20,6 +20,7 @@ export declare enum FieldNames {
     description = "description",
     email = "email",
     psEmail = "psEmail",
+    bazitemail = "bazitemail",
     euCheck = "eu_check",
     extraCvv = "extra_cvv",
     extraCardNumber = "extra_card_number",
@@ -59,5 +60,7 @@ export declare enum FieldNames {
     sum = "sum",
     out = "out",
     tinkoffDisclaimer = "ps.tinkoff.disclaimer",
+    ppEmail = "pp_email",
+    redeemPoints = "redeemPoints",
     omnibusDirective = "omnibus_directive"
 }

package/lib/core/payment/form/control-status.interface.d.ts

@@ -0,0 +1,7 @@
+import { FieldNames } from '../field-names.enum';
+import { FormControlStatus, ValidationErrors } from '@angular/forms';
+export interface ControlStatus {
+    name: FieldNames;
+    status: FormControlStatus;
+    errors: ValidationErrors | null;
+}

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

@@ -8,6 +8,7 @@ import { XpsApiService } from '../xps-api/xps-api.service';
 import { InitializeResponseFactory } from './response/initialize-response.token';
 import { InitializeResponse } from './response/initialize-response.class';
 import { XpsResponseErrorsMappingService } from '../../errors-mapping/xps-response-errors-mapping.service';
+import { UserBehaviourAnalyticsService } from '../../user-behaviour-analytics/user-behaviour-analytics.service';
 import * as i0 from "@angular/core";
 export declare class InitializeService {
     protected readonly responseFactory: InitializeResponseFactory;
@@ -18,8 +19,9 @@ export declare class InitializeService {
     private readonly xpsResponseErrorsMappingService;
     private readonly encryptCreditCardService;
     private readonly showErrorsActionCreator;
+    private readonly userBehaviourAnalyticsService;
     private readonly ps4ReferId;
-    constructor(responseFactory: InitializeResponseFactory, xpsApiService: XpsApiService, settingsService: SettingsService, countryService: CountryService, nextActionService: NextActionService, xpsResponseErrorsMappingService: XpsResponseErrorsMappingService, encryptCreditCardService: EncryptCreditCardService, showErrorsActionCreator: ShowErrorsActionCreator);
+    constructor(responseFactory: InitializeResponseFactory, xpsApiService: XpsApiService, settingsService: SettingsService, countryService: CountryService, nextActionService: NextActionService, xpsResponseErrorsMappingService: XpsResponseErrorsMappingService, encryptCreditCardService: EncryptCreditCardService, showErrorsActionCreator: ShowErrorsActionCreator, userBehaviourAnalyticsService: UserBehaviourAnalyticsService);
     request(config: PaymentConfig): Promise<InitializeResponse>;
     private setCreditCardEncryptKey;
     static ɵfac: i0.ɵɵFactoryDeclaration<InitializeService, never>;

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

@@ -8,6 +8,8 @@ import { FinanceDetails } from './finance-details/finance-details.interface';
 import { InputEventName } from './form/input-event.enum';
 import { FormFieldsStatus } from './form/form-fields-status.interface';
 import { FormState } from './form/form-state.interface';
+import { FieldNames } from './field-names.enum';
+import { ControlStatus } from './form/control-status.interface';
 export interface Payment {
     initialize(): Promise<Field[]>;
     submit(): Promise<NextAction | null | void>;
@@ -26,6 +28,7 @@ export interface Payment {
         updateFieldFormState(fieldName: string, formState: FormState): void;
         formMessages$: Observable<string[]>;
         getFormStatus(): FormControlStatus | undefined;
+        getControlStatus(name: FieldNames): ControlStatus | null;
     };
     financeDetailsUpdates$: Observable<FinanceDetails>;
     addExtraField(name: string, value: string): void;

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

@@ -19,6 +19,7 @@ import { InputEventName } from './form/input-event.enum';
 import { FormFieldsStatus } from './form/form-fields-status.interface';
 import { ThreeDsService } from './three-ds/three-ds.service';
 import { CreditCardStateService } from './credit-card-state/credit-card-state.service';
+import { FieldNames } from './field-names.enum';
 import { FormState } from './form/form-state.interface';
 import { FormMessagesService } from './form-messages/form-messages.service';
 import { SettingsService } from '../settings/settings.service';
@@ -26,6 +27,7 @@ import { CountryService } from '../country/country.service';
 import { SdkPaymentSystemsInitialData } from '../sdk-payment-systems/sdk-payment-systems-initial-data.interface';
 import { FormResponse } from './form-response.interface';
 import { CheckStatusActionCreator } from './actions/check-status/check-status.action.class';
+import { ControlStatus } from './form/control-status.interface';
 import * as i0 from "@angular/core";
 export declare class PaymentService {
     private readonly initializeService;
@@ -62,6 +64,7 @@ export declare class PaymentService {
     initialize(config: PaymentConfig): Promise<Field[]>;
     submit(): Promise<NextAction | null | void>;
     getFields(): Field[];
+    getControlStatus(name: FieldNames): ControlStatus | null;
     getInitialDataForSdkPaymentSystems(): SdkPaymentSystemsInitialData;
     getQrCode(): string;
     getPid(): number | null;

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

@@ -4,11 +4,13 @@ import { CheckStatusService } from '../check-status/check-status.service';
 import { WebsocketStatusService } from '../websocket-status/websocket-status.service';
 import { StatusSettings } from '../status-settings.interface';
 import { StatusUpdated } from '../status-updated.interface';
+import { UserBehaviourAnalyticsService } from '../../../user-behaviour-analytics/user-behaviour-analytics.service';
 import * as i0 from "@angular/core";
 export declare class ListenStatusService {
     private readonly statusService;
     private readonly checkStatusService;
     private readonly websocketStatusService;
+    private readonly userBehaviourAnalyticsService;
     isListening: boolean;
     private readonly websocketOpenedSubject;
     private readonly statusUpdatedSubject;
@@ -16,7 +18,7 @@ export declare class ListenStatusService {
     private destroy$;
     get websocketOpened$(): Observable<StatusSettings>;
     get statusUpdated$(): Observable<StatusUpdated>;
-    constructor(statusService: StatusRequestService, checkStatusService: CheckStatusService, websocketStatusService: WebsocketStatusService);
+    constructor(statusService: StatusRequestService, checkStatusService: CheckStatusService, websocketStatusService: WebsocketStatusService, userBehaviourAnalyticsService: UserBehaviourAnalyticsService);
     listen(invoice: number): Observable<StatusSettings>;
     stopListening(): void;
     private subscribeStatusUpdate;

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

@@ -8,6 +8,7 @@ import { DeviceFingerPrintService } from '../../device-finger-print/device-finge
 import { XpsApiService } from '../xps-api/xps-api.service';
 import { EncryptCreditCardService } from '../../encrypt-credit-card/encrypt-credit-card.service';
 import { XpsResponseErrorsMappingService } from '../../errors-mapping/xps-response-errors-mapping.service';
+import { UserBehaviourAnalyticsService } from '../../user-behaviour-analytics/user-behaviour-analytics.service';
 import * as i0 from "@angular/core";
 export declare class SubmitService {
     private readonly requestFactory;
@@ -17,8 +18,10 @@ export declare class SubmitService {
     private readonly xpsApiService;
     private readonly xpsResponseErrorsMappingService;
     private readonly encryptCreditCardService;
-    constructor(requestFactory: SubmitRequestFactory, responseFactory: SubmitResponseFactory, settingsService: SettingsService, deviceFingerPrintService: DeviceFingerPrintService, xpsApiService: XpsApiService, xpsResponseErrorsMappingService: XpsResponseErrorsMappingService, encryptCreditCardService: EncryptCreditCardService);
+    private readonly userBehaviourAnalyticsService;
+    constructor(requestFactory: SubmitRequestFactory, responseFactory: SubmitResponseFactory, settingsService: SettingsService, deviceFingerPrintService: DeviceFingerPrintService, xpsApiService: XpsApiService, xpsResponseErrorsMappingService: XpsResponseErrorsMappingService, encryptCreditCardService: EncryptCreditCardService, userBehaviourAnalyticsService: UserBehaviourAnalyticsService);
     request(fields: Field[], form: UntypedFormGroup): Promise<SubmitResponse>;
+    private fillUserSession;
     static ɵfac: i0.ɵɵFactoryDeclaration<SubmitService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SubmitService>;
 }

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

@@ -13,6 +13,7 @@ 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';
 import { XpsResponseErrorsMappingService } from '../../errors-mapping/xps-response-errors-mapping.service';
+import { UserBehaviourAnalyticsService } from '../../user-behaviour-analytics/user-behaviour-analytics.service';
 import * as i0 from "@angular/core";
 export declare class SyncService extends EmitDataService<XpsResponse> {
     private readonly requestFactory;
@@ -23,12 +24,13 @@ export declare class SyncService extends EmitDataService<XpsResponse> {
     private readonly xpsResponseErrorsMappingService;
     private readonly encryptCreditCardService;
     private readonly showErrorsActionCreator;
+    private readonly userBehaviourAnalyticsService;
     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, showErrorsActionCreator: ShowErrorsActionCreator);
+    constructor(requestFactory: SyncRequestFactory, responseFactory: SyncResponseFactory, xpsApiService: XpsApiService, nextActionService: NextActionService, settingsService: SettingsService, xpsResponseErrorsMappingService: XpsResponseErrorsMappingService, encryptCreditCardService: EncryptCreditCardService, showErrorsActionCreator: ShowErrorsActionCreator, userBehaviourAnalyticsService: UserBehaviourAnalyticsService);
     get fieldAsyncValidation$(): Observable<FieldAsyncValidation>;
     setup(form: UntypedFormGroup, fields: Field[]): void;
     reset(): void;

package/lib/core/payment/xps-api/xps-api.service.d.ts

@@ -4,14 +4,16 @@ import { SettingsService } from '../../settings/settings.service';
 import { XpsRequest } from '../xps-request.interface';
 import { XpsResponse } from '../xps-response.interface';
 import { CountryService } from '../../country/country.service';
+import { UserAgentService } from '../../user-agent/user-agent.service';
 import * as i0 from "@angular/core";
 export declare class XpsApiService {
     private readonly window;
     private readonly secureApiClient;
     private readonly settingsService;
     private readonly countryService;
+    private readonly userAgentService;
     private readonly directPaymentApiRoute;
-    constructor(window: ExtendedWindow, secureApiClient: SecureApiClient, settingsService: SettingsService, countryService: CountryService);
+    constructor(window: ExtendedWindow, secureApiClient: SecureApiClient, settingsService: SettingsService, countryService: CountryService, userAgentService: UserAgentService);
     directPaymentRequest(parameters: XpsRequest): Promise<XpsResponse>;
     private collectAnalyticsParameters;
     private collectUserSessionId;

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

@@ -2,6 +2,7 @@ import { CountryService } from '../country/country.service';
 import { SecureApiClient } from '../http/secure-api/secure-api.service';
 import { SettingsService } from '../settings/settings.service';
 import { PaymentMethod } from './payment-method.interface';
+import { PaymentMethodsResponse } from './payment-methods-response.class';
 import { PaymentMethodsResponseFactory } from './payment-methods-response.token';
 import * as i0 from "@angular/core";
 export declare class PaymentMethodsService {
@@ -12,6 +13,7 @@ export declare class PaymentMethodsService {
     private readonly apiRoute;
     private readonly cache;
     constructor(responseFactory: PaymentMethodsResponseFactory, settingsService: SettingsService, countryService: CountryService, secureApi: SecureApiClient);
+    getAllMethods(): Promise<PaymentMethodsResponse>;
     getList(isSaveMethodMode?: boolean): Promise<PaymentMethod[]>;
     getQuickMethods(): Promise<PaymentMethod[]>;
     private request;

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

@@ -0,0 +1,24 @@
+import { NgZone } from '@angular/core';
+import { UserBehaviourAnalyticsService } from '../user-behaviour-analytics/user-behaviour-analytics.service';
+import { XhrActionService } from './xhr-action.service';
+import { ExtendedWindow } from '../extended-window.interface';
+import * as i0 from "@angular/core";
+export declare class PerformanceService {
+    private readonly userBehaviourAnalyticsService;
+    private readonly xhrActionService;
+    private readonly window;
+    private readonly zone;
+    private readonly navigationPerformance;
+    private readonly resourcesPerformance;
+    private get network();
+    private get runApp();
+    constructor(userBehaviourAnalyticsService: UserBehaviourAnalyticsService, xhrActionService: XhrActionService, window: ExtendedWindow, zone: NgZone);
+    init(): undefined | void;
+    private getInitRequest;
+    private sendMeasurement;
+    private measureRunApp;
+    private measureInitialValues;
+    private listenXhrActions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PerformanceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PerformanceService>;
+}

package/lib/core/performance/xhr-action.interface.d.ts

@@ -0,0 +1,8 @@
+export interface XhrAction {
+    name: string;
+    duration: number;
+    apiRequestCount: number;
+    apiRequestDuration: number;
+    cdnRequestCount: number;
+    cdnRequestDuration: number;
+}

package/lib/core/performance/xhr-action.service.d.ts

@@ -0,0 +1,25 @@
+import { Observable } from 'rxjs';
+import { XhrAction } from './xhr-action.interface';
+import { ExtendedWindow } from '../extended-window.interface';
+import * as i0 from "@angular/core";
+export declare class XhrActionService {
+    private readonly window;
+    private readonly pauseTime;
+    private readonly userInputEventNames;
+    private isXhrActionStarted;
+    private apiRequestEntries;
+    private cdnRequestEntries;
+    private readonly entriesSubject;
+    constructor(window: ExtendedWindow);
+    getXhrAction(): Observable<XhrAction>;
+    private processEntry;
+    private startXhrAction;
+    private stopXhrAction;
+    private getUserInput;
+    private getPerformance;
+    private getApiRequestName;
+    private getDuration;
+    private getPauseEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<XhrActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<XhrActionService>;
+}

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

@@ -7,7 +7,7 @@ import { CheckStatusAction } from '../../payment/actions/check-status/check-stat
 import * as i0 from "@angular/core";
 export declare class GooglePayService {
     private readonly window;
-    readonly commonPayProcessingService: PaymentSystemProcessingService;
+    readonly paymentSystemProcessingService: PaymentSystemProcessingService;
     readonly injector: Injector;
     private readonly googlePayScriptUrl;
     private readonly readyToPay;
@@ -17,7 +17,7 @@ export declare class GooglePayService {
     private country;
     private get libraryWasInitialized();
     private get googlePaymentClientWasInitialized();
-    constructor(window: ExtendedWindow, commonPayProcessingService: PaymentSystemProcessingService, injector: Injector);
+    constructor(window: ExtendedWindow, paymentSystemProcessingService: PaymentSystemProcessingService, injector: Injector);
     get readyToPay$(): Observable<boolean | null>;
     isReadyToPay(): boolean | null;
     initGooglePayLibrary(data: GooglePayInitParams): void;

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

@@ -10,7 +10,7 @@ export declare class PaymentSystemProcessingService {
     constructor(window: ExtendedWindow);
     get initialize$(): Observable<boolean>;
     get status$(): Observable<string>;
-    emitPayment(payment: string): void;
+    emitStatusUrl(statusUrl: string): void;
     emitInitialize(isInitialized: boolean): void;
     getDecodedCheckout<T extends CommonCheckout>(base64checkoutData: string): T;
     loadScript(url: string, onLoad: () => void, addScriptCustomAttributes?: (script: HTMLScriptElement) => HTMLScriptElement): void;

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

@@ -1,20 +1,4 @@
-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;
-    };
-    commonPayProcessingService: {
-        initialize$: Observable<boolean>;
-        isInitialized(): boolean;
-        status$: Observable<string>;
-    };
     getInitialData(): SdkPaymentSystemsInitialData;
 }

package/lib/core/settings/configuration.interface.d.ts

@@ -1,6 +1,5 @@
 export interface InitConfiguration {
     token: string;
-    isMobile: boolean;
     isWebview?: boolean;
     sandbox?: boolean;
 }

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

@@ -14,15 +14,14 @@ export declare class SettingsService {
     get settings(): DeepReadonly<Settings>;
     get user(): DeepReadonly<User>;
     get utilsResponse(): DeepReadonly<UtilsResponse>;
+    get unsafeUtilsResponse(): DeepReadonly<UtilsResponse | null>;
     get isEmpty(): boolean;
     get token(): string;
-    get isMobile(): boolean;
     get hasResponse(): boolean;
     isInitialized: boolean;
     private response;
     private _token;
     private sandboxMode;
-    private _isMobile;
     constructor(secureApi: SecureApiClient);
     init(configuration: InitConfiguration): Promise<void>;
     isSandboxMode(): boolean;

package/lib/core/user-behaviour-analytics/event-builder/event-builder.service.d.ts

@@ -0,0 +1,22 @@
+import { UserBehaviourEvent } from './user-behaviour-event.interface';
+import { CreateEventMethodOptionsInterface } from '../user-behaviour-analytics.interface';
+import { SettingsService } from '../../settings/settings.service';
+import { UserAgentService } from '../../user-agent/user-agent.service';
+import { ExtendedWindow } from '../../extended-window.interface';
+import { UserSessionOptions } from '../user-session-options';
+import * as i0 from "@angular/core";
+export declare class EventBuilderService {
+    private readonly settingsService;
+    private readonly userAgentService;
+    private readonly window;
+    constructor(settingsService: SettingsService, userAgentService: UserAgentService, window: ExtendedWindow);
+    createEvent(options: CreateEventMethodOptionsInterface, userSessionOptions: UserSessionOptions): UserBehaviourEvent;
+    private getDate;
+    private getTimezone;
+    private convertToEventParameterType;
+    private convertValueForPostMessage;
+    private isSubscription;
+    private getPaymentMethodId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EventBuilderService>;
+}

package/lib/core/user-behaviour-analytics/event-builder/event-parameter-types.d.ts

@@ -0,0 +1,7 @@
+export declare enum EventParameterType {
+    string = "0",
+    int = "1",
+    float = "2",
+    bool = "3",
+    intArray = "4"
+}

package/lib/core/user-behaviour-analytics/event-builder/invoice.interface.d.ts

@@ -0,0 +1,14 @@
+export interface Invoice {
+    purchase_invoice_id: number | null;
+    geotype_id: number | null;
+    payment_country: string | null;
+    payment_method_contr_id: number | null;
+    ps_type: number | null;
+    purchase_sum: number | null;
+    purchase_currency: string | null;
+    purchase_sku: string | null;
+    purchase_digital_content_sku: string | null;
+    purchase_description: string | null;
+    digital_content_cart_id: number | null;
+    digital_good_cart_id: number | null;
+}

package/lib/core/user-behaviour-analytics/event-builder/purchase.type.d.ts

@@ -0,0 +1 @@
+export type Purchase = 'virtual_item' | 'virtual_currency' | 'subscription' | 'pay2play';

package/lib/core/user-behaviour-analytics/event-builder/user-behaviour-event.interface.d.ts

@@ -0,0 +1,52 @@
+import { Purchase } from './purchase.type';
+import { Invoice } from './invoice.interface';
+import { userBehaviourEventTypes } from '../user-behaviour-event/user-behaviour-event-types';
+export interface UserBehaviourEvent extends Invoice {
+    action: string;
+    type: keyof typeof userBehaviourEventTypes;
+    value: string | number[] | null;
+    state: string | null;
+    date: string;
+    milliseconds: number | null;
+    timezone: string;
+    session_id: string | null;
+    referrer_url: string | null;
+    project_id: number | null;
+    payment_country: string | null;
+    instance_id: number | null;
+    is_pay_with_saved_method: number | null;
+    purchase_external_id: string | null;
+    purchase_type: Purchase;
+    virtual_currency_amount: number | null;
+    coupon_code: string | null;
+    theme_version: string | null;
+    subscription_package_id: number | null;
+    subscription_product_id: number | null;
+    subscription_recurrent_id: number | null;
+    user_id: string | null;
+    user_access_token: string | null;
+    user_name: string | null;
+    user_email: string | null;
+    user_country: string | null;
+    user_ip: string | null;
+    user_mobile_operator_name: string | null;
+    user_operation_system: string | null;
+    user_browser: string | null;
+    user_browser_version: string | null;
+    user_locale: string | null;
+    user_utm: string | null;
+    xsolla_product_tag: string | null;
+    experiment_id: string | null;
+    is_test_session: number | null;
+    extra_value: string | null;
+    babka_value: string | null;
+    is_subscription: number | null;
+    is_iframe: number | null;
+    web3wallet: string | null;
+    dimension_1: string | null;
+    dimension_2: string | null;
+    dimension_3: string | null;
+    dimension_4: string | null;
+    dimension_5: string | null;
+    client_version: 'Headless Checkout';
+}

package/lib/core/user-behaviour-analytics/one-time-analytics-events.const.d.ts

@@ -0,0 +1 @@
+export declare const oneTimeAnalyticsEvents: Set<string>;

package/lib/core/user-behaviour-analytics/user-behaviour-analytics.interface.d.ts

@@ -0,0 +1,36 @@
+import { eventCategories } from './user-behaviour-event/user-behaviour-event-categories';
+import { userBehaviourEventTypes } from './user-behaviour-event/user-behaviour-event-types';
+import { Invoice } from './event-builder/invoice.interface';
+import { EventParameterType } from './event-builder/event-parameter-types';
+export interface SendEventMethodOptionsInterface {
+    value?: string | null | boolean | number | number[];
+    valueType?: EventParameterType;
+    eventCategory?: keyof typeof eventCategories;
+    extraValue?: string | null;
+    purchaseType?: string | null;
+    instanceId?: number | null;
+    dimension1?: string | null;
+    dimension2?: string | null;
+    dimension3?: string | null;
+    dimension4?: string | null;
+    dimension5?: string | null;
+    skipForExternalPage?: boolean;
+    syncRequest?: boolean;
+}
+export interface CreateEventMethodOptionsInterface {
+    action: string;
+    type: keyof typeof userBehaviourEventTypes;
+    value: string | null | boolean | number | number[];
+    valueType: EventParameterType | null;
+    date: Date;
+    invoice: Invoice | null;
+    state: string;
+    extraValue: string | null;
+    purchase_type: string | null;
+    instanceId?: number | null;
+    dimension1: string | null;
+    dimension2: string | null;
+    dimension3: string | null;
+    dimension4: string | null;
+    dimension5: string | null;
+}

package/lib/core/user-behaviour-analytics/user-behaviour-analytics.service.d.ts

@@ -0,0 +1,43 @@
+import { HttpClient } from '@angular/common/http';
+import { userBehaviourEventTypes } from './user-behaviour-event/user-behaviour-event-types';
+import { SendEventMethodOptionsInterface } from './user-behaviour-analytics.interface';
+import { EventBuilderService } from './event-builder/event-builder.service';
+import { Invoice } from './event-builder/invoice.interface';
+import { SettingsService } from '../settings/settings.service';
+import { Field } from '../payment/field.interface';
+import { XpsResponse } from '../payment/xps-response.interface';
+import { UserSessionOptions } from './user-session-options';
+import * as i0 from "@angular/core";
+export declare class UserBehaviourAnalyticsService {
+    private readonly http;
+    private readonly eventBuilderService;
+    private readonly settingsService;
+    set isPayWithSavedMethod(value: boolean);
+    set subscriptionPackageId(value: number);
+    set couponCode(value: string);
+    set paymentStatus(value: string);
+    get sessionOptions(): UserSessionOptions;
+    private get purchaseType();
+    private readonly apiUrl;
+    private readonly _events$;
+    private readonly userSessionOptions;
+    private readonly sentEvents;
+    constructor(http: HttpClient, eventBuilderService: EventBuilderService, settingsService: SettingsService);
+    init(): undefined | void;
+    setPid(pid?: number | null): void;
+    fillUserSession(paymentForm: {
+        fields: Field[];
+        subscriptionRecurrentId?: number;
+        userSession?: Invoice;
+        pid: XpsResponse['pid'];
+        errors: XpsResponse['errors'];
+        summary: XpsResponse['summary'];
+        title: string;
+    }): void;
+    send(action: string, type: keyof typeof userBehaviourEventTypes, options?: SendEventMethodOptionsInterface): void;
+    private onOpenPayStation;
+    private resetInvoice;
+    private resetPid;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserBehaviourAnalyticsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserBehaviourAnalyticsService>;
+}

package/lib/core/user-behaviour-analytics/user-behaviour-event/user-behaviour-event-categories.d.ts

@@ -0,0 +1,4 @@
+export declare const eventCategories: {
+    readonly withoutInvoice: "withoutInvoice";
+    readonly withInvoice: "withInvoice";
+};

package/lib/core/user-behaviour-analytics/user-behaviour-event/user-behaviour-event-types.d.ts

@@ -0,0 +1,7 @@
+export declare const userBehaviourEventTypes: {
+    readonly open: "open";
+    readonly show: "show";
+    readonly click: "click";
+    readonly manual: "manual";
+    readonly store: "store";
+};

package/lib/core/user-behaviour-analytics/user-behaviour-event-name.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum UserBehaviourEventName {
+    openPaystation = "open-paystation",
+    showMethodHeader = "show-method-header",
+    showErrorMessage = "show-error-message",
+    openStatusError = "open-status-error"
+}

package/lib/core/user-behaviour-analytics/user-session-options.d.ts

@@ -0,0 +1,15 @@
+import { Invoice } from './event-builder/invoice.interface';
+export interface UserSessionOptions {
+    invoice: Invoice | null;
+    instanceId: number | null;
+    subscriptionRecurrentId: number | null;
+    userMobileOperatorName: string | null;
+    isPayWithSavedMethod: boolean;
+    subscriptionPackageId: number | null;
+    subscriptionProductId: number | null;
+    couponCode: string | null;
+    totalSum: number | null;
+    totalCurrency: string | null;
+    paymentInstanceName: string | null;
+    paymentStatus: string | null;
+}