@xsolla/payment-client-core 0.0.4 → 0.0.6

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

@@ -1,10 +1,11 @@
 import { __awaiter } from 'tslib';
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Inject, NgModule } from '@angular/core';
-import { firstValueFrom, lastValueFrom, map, throwError } from 'rxjs';
+import { InjectionToken, Injectable, Inject, isDevMode, NgModule } from '@angular/core';
+import { firstValueFrom, lastValueFrom, map, BehaviorSubject, Subject, filter as filter$1, takeUntil, skip, throwError } from 'rxjs';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpHeaders, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
-import { catchError } from 'rxjs/operators';
+import { UntypedFormGroup, Validators, UntypedFormControl, ReactiveFormsModule } from '@angular/forms';
+import { filter, map as map$1, catchError } from 'rxjs/operators';
 import * as i1$1 from '@angular/router';
 
 class AppError extends Error {
@@ -424,6 +425,2134 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                     }] }, { type: SettingsService }, { type: SecureApiClient }];
     } });
 
+class InitializeResponse {
+    constructor(response) {
+        this.paymentForm = null;
+        this.paymentForm = this.extractPaymentForm(response);
+    }
+    extractPaymentForm(response) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!response) {
+            return null;
+        }
+        return {
+            totalAmount: response.buyData.sum,
+            currency: response.buyData.currency,
+            fields: Object.keys(response.form).map((key) => response.form[key]),
+            taxDisclaimer: response.taxDisclaimer,
+            number: response.number,
+            barcode: response.barcode,
+            instruction: response.instruction,
+            offers: response.offers,
+            error: response.error,
+            errors: response.errors,
+            restrictions: response.restrictions,
+            info: response.info,
+            buyData: response.buyData,
+            pid: response.pid,
+            messages: (_a = response.messages) !== null && _a !== void 0 ? _a : [],
+            title: response.title,
+            summary: response.summary,
+            skipForm: response.skipForm,
+            isSavedMethodPayment: !!((_b = response.form) === null || _b === void 0 ? void 0 : _b.saved_method_id),
+            couponCode: ((_d = (_c = response.form) === null || _c === void 0 ? void 0 : _c.couponCode) === null || _d === void 0 ? void 0 : _d.value) || '',
+            publicId: response.public_id,
+            skipCheckout: response.skipCheckout,
+            koreaNotification: response.form.korea_limits_instruction,
+            isCheckout: response.isCheckout,
+            categories: response.categories,
+            hasFatalErrors: (_e = response.textAll) === null || _e === void 0 ? void 0 : _e.fatal,
+            userSession: response.userSession,
+            statusText: (_h = (_g = (_f = response.status) === null || _f === void 0 ? void 0 : _f.statusData) === null || _g === void 0 ? void 0 : _g.stateText) !== null && _h !== void 0 ? _h : null,
+            country: response.country ? response.country.iso : null,
+        };
+    }
+}
+
+const initializeResponseFactoryToken = new InjectionToken('InitializeResponse');
+const initializeResponseFactoryProvider = {
+    provide: initializeResponseFactoryToken,
+    useValue: (...args) => new InitializeResponse(...args),
+};
+
+class InitializeService {
+    constructor(responseFactory, secureApi, settingsService, countryService) {
+        this.responseFactory = responseFactory;
+        this.secureApi = secureApi;
+        this.settingsService = settingsService;
+        this.countryService = countryService;
+        this.apiRoute = 'directpayment';
+    }
+    request(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestParams = {
+                access_token: this.settingsService.token,
+                pid: String(config.paymentMethodId),
+                country: this.countryService.getCountry(),
+                returnUrl: config.returnUrl,
+            };
+            return lastValueFrom(this.secureApi
+                .post(this.apiRoute, new URLSearchParams(Object.assign({}, requestParams)), {
+                headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                responseType: 'json',
+            })
+                .pipe(map((response) => this.responseFactory(response)))).catch((error) => {
+                throw new ResponseError(error.message);
+            });
+        });
+    }
+}
+InitializeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, deps: [{ token: initializeResponseFactoryToken }, { token: SecureApiClient }, { token: SettingsService }, { token: CountryService }], target: i0.ɵɵFactoryTarget.Injectable });
+InitializeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [initializeResponseFactoryToken]
+                    }] }, { type: SecureApiClient }, { type: SettingsService }, { type: CountryService }];
+    } });
+
+class XpsApiPartRequest {
+    addXpsParameters(parameters) {
+        for (const key in parameters) {
+            this[`xps_${key}`] = parameters[key];
+        }
+    }
+}
+
+class TokenError extends AppError {
+    constructor() {
+        super('XPS API needs token.');
+    }
+}
+
+class SubmitRequest extends XpsApiPartRequest {
+    constructor(parameters) {
+        super();
+        const { token, dfpHash } = parameters;
+        if (token === null) {
+            throw new TokenError();
+        }
+        this.access_token = token;
+        if (dfpHash) {
+            this.xps_dfp_hash = dfpHash;
+        }
+    }
+}
+
+const submitRequestFactoryToken = new InjectionToken('SubmitRequest');
+const submitRequestFactoryProvider = {
+    provide: submitRequestFactoryToken,
+    useValue: (...args) => new SubmitRequest(...args),
+};
+
+var XpsCommand;
+(function (XpsCommand) {
+    XpsCommand["form"] = "form";
+    XpsCommand["check"] = "check";
+    XpsCommand["status"] = "status";
+    XpsCommand["checkout"] = "checkout";
+    XpsCommand["account"] = "account";
+    XpsCommand["create"] = "create";
+})(XpsCommand || (XpsCommand = {}));
+
+var FieldNames;
+(function (FieldNames) {
+    FieldNames["address1"] = "address1";
+    FieldNames["address2"] = "address2";
+    FieldNames["address"] = "address";
+    FieldNames["allowRecurrentSubscription"] = "allowRecurrentSubscription";
+    FieldNames["allowSubscription"] = "allowSubscription";
+    FieldNames["apt"] = "apt";
+    FieldNames["availableCardTypes"] = "available_card_types";
+    FieldNames["bank"] = "bank";
+    FieldNames["birthDate"] = "birth_date";
+    FieldNames["cardMonth"] = "card_month";
+    FieldNames["cardYear"] = "card_year";
+    FieldNames["cardNumber"] = "card_number";
+    FieldNames["cardholdername"] = "cardholdername";
+    FieldNames["city"] = "city";
+    FieldNames["couponCode"] = "couponCode";
+    FieldNames["cpfName"] = "cpf_name";
+    FieldNames["cpfNumber"] = "cpf_number";
+    FieldNames["cvv"] = "cvv";
+    FieldNames["description"] = "description";
+    FieldNames["email"] = "email";
+    FieldNames["psEmail"] = "psEmail";
+    FieldNames["euCheck"] = "eu_check";
+    FieldNames["extraCvv"] = "extra_cvv";
+    FieldNames["extraCardNumber"] = "extra_card_number";
+    FieldNames["extraCardType"] = "extra_card_type";
+    FieldNames["fName"] = "f_name";
+    FieldNames["installments"] = "installments";
+    FieldNames["lName"] = "l_name";
+    FieldNames["needInstallments"] = "needInstallments";
+    FieldNames["personId"] = "person_id";
+    FieldNames["personIdAr"] = "person_id_ar";
+    FieldNames["personIdCo"] = "person_id_co";
+    FieldNames["phone"] = "phone";
+    FieldNames["purchaseDescription"] = "purchaseDescription";
+    FieldNames["recurrentType"] = "recurrent_type";
+    FieldNames["rockstarTaxes"] = "rockstar_taxes";
+    FieldNames["state"] = "state";
+    FieldNames["street"] = "street";
+    FieldNames["streetNumber"] = "street_number";
+    FieldNames["take2Taxes"] = "take2_taxes";
+    FieldNames["termsAndConditions"] = "termsAndConditions";
+    FieldNames["termsAndConditionsAtariPp"] = "termsAndConditionsAtariPP";
+    FieldNames["termsAndConditionsAtariTc"] = "termsAndConditionsAtariTC";
+    FieldNames["termsAndConditionsHtcEula"] = "termsAndConditionsHtcEula";
+    FieldNames["termsAndConditionsRobloxEula"] = "termsAndConditionsRobloxEula";
+    FieldNames["termsAndConditionsRolandEula"] = "termsAndConditionsRolandEula";
+    FieldNames["termsAndConditionsDeusLoVultEula"] = "termsAndConditionsDeusLoVultEula";
+    FieldNames["termsAndConditionsOnzenga"] = "termsAndConditionsOnzenga";
+    FieldNames["xsollaTipsAmount"] = "xsollaTipsAmount";
+    FieldNames["zip"] = "zip";
+    FieldNames["allowSave"] = "allowSave";
+    FieldNames["koreaLimitsInstruction"] = "korea_limits_instruction";
+    FieldNames["tokenApplePay"] = "token_applepay";
+    FieldNames["fixInvoice"] = "fix_invoice";
+    FieldNames["fixPid"] = "fix_pid";
+    FieldNames["signature"] = "signature";
+    FieldNames["qr"] = "qr";
+    FieldNames["sum"] = "sum";
+    FieldNames["out"] = "out";
+    FieldNames["tinkoffDisclaimer"] = "ps.tinkoff.disclaimer";
+})(FieldNames || (FieldNames = {}));
+
+class SubmitResponse {
+    constructor(parameters, responseNumber = 0) {
+        var _a, _b, _c;
+        this.responseNumber = responseNumber;
+        /* Todo split into properties */
+        this.parameters = parameters;
+        this.fields = Object.keys(parameters.form).map((key) => parameters.form[key]);
+        if (parameters.onlineBanking) {
+            this.onlineBanking = {
+                url: parameters.onlineBanking.value,
+            };
+        }
+        this.isNeedRedirect =
+            parameters.currentCommand === XpsCommand.account ||
+                (parameters.currentCommand === XpsCommand.checkout &&
+                    Boolean(parameters.checkout));
+        this.buyData = parameters.buyData;
+        this.fixInvoice = (_a = this.fields.find((field) => field.name === FieldNames.fixInvoice)) === null || _a === void 0 ? void 0 : _a.value;
+        this.signature = (_b = this.fields.find((field) => field.name === FieldNames.signature)) === null || _b === void 0 ? void 0 : _b.value;
+        this.hasFatalErrors = (_c = parameters.textAll) === null || _c === void 0 ? void 0 : _c.fatal;
+        this.userSession = parameters.userSession;
+        this.pid = parameters.pid;
+        this.errors = parameters.errors;
+        this.summary = parameters.summary;
+        this.title = parameters.title;
+        this.currentCommand = parameters.currentCommand;
+        this.messages = parameters.messages;
+    }
+}
+
+const submitResponseFactoryToken = new InjectionToken('SubmitResponse');
+const submitResponseFactoryProvider = {
+    provide: submitResponseFactoryToken,
+    useValue: (...args) => new SubmitResponse(...args),
+};
+
+class TerminalError extends AppError {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+
+class DefaultTerminalError extends TerminalError {
+    constructor() {
+        const message = `It's not you, it's us, but we can help. Please contact our customer support.`;
+        super(message, '1000-0002');
+    }
+}
+
+class DeviceFingerPrintService {
+    constructor(secureApi, settingsService, window) {
+        this.secureApi = secureApi;
+        this.settingsService = settingsService;
+        this.window = window;
+        this.apiRoute = 'dfp';
+        this.fingerprintApiUrl = 'https://afs.xsolla.com/dfp/api/v1/';
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.settingsService.isInitialized) {
+                return;
+            }
+            this.fingerprintJs = yield this.loadFingerprintJs();
+            this.hash = yield this.buildHash();
+            this.antifraudFingerprintLibrary =
+                yield this.loadAntifraudFingerprintLibrary();
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    getHash() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.hash;
+        });
+    }
+    loadFingerprintJs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { default: library, murmurX64Hash128: getHash } = yield import('@fingerprintjs/fingerprintjs');
+            return { library, getHash };
+        });
+    }
+    loadAntifraudFingerprintLibrary() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const library = yield import('@xsolla/antifraud-fingerprint');
+            return library.default;
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    makeAntifraudFingerprint() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.settingsService.token) {
+                return null;
+            }
+            const antifraudFingerprint = this.antifraudFingerprintLibrary;
+            try {
+                return new antifraudFingerprint({
+                    api: {
+                        url: this.fingerprintApiUrl,
+                        token: this.settingsService.token,
+                        timeout: 3000,
+                    },
+                    retry: {
+                        num: 1,
+                        timeout: 500,
+                    },
+                });
+            }
+            catch (error) {
+                return null;
+            }
+        });
+    }
+    /**
+     *Загружаем библиотеку, генерируем данные,
+     *хешируем с помощью BASE64 и отправляем на бэкенд,
+     *в ответ получаем dfp_hash.
+     **/
+    buildHash() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fingerPrintData = yield this.generate();
+            const hash = yield this.send(fingerPrintData).catch(() => {
+                return null;
+            });
+            return JSON.stringify(hash);
+        });
+    }
+    /**
+     *Новая версия библиотеки содержит не все компоненты, некоторые приходится имплементировать самостоятельно
+     **/
+    getHasLiedResolution() {
+        const { screen } = this.window;
+        return (screen.width < screen.availWidth || screen.height < screen.availHeight);
+    }
+    /**
+     *Бэкенд заточен под конкретные поля, которые необходимо смапить.
+     **/
+    getComponents(components) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return {
+            user_agent: navigator.userAgent,
+            language: (_c = (_b = (_a = components.languages.value) === null || _a === void 0 ? void 0 : _a.shift()) === null || _b === void 0 ? void 0 : _b.shift()) !== null && _c !== void 0 ? _c : '',
+            color_depth: components.colorDepth.value,
+            device_memory: components.deviceMemory.value,
+            hardware_concurrency: components.hardwareConcurrency.value,
+            resolution: components.screenResolution.value,
+            available_resolution: components.screenResolution.value,
+            timezone_offset: new Date().getTimezoneOffset(),
+            session_storage: components.sessionStorage.value ? 1 : 0,
+            local_storage: components.localStorage.value ? 1 : 0,
+            indexed_db: components.indexedDB.value ? 1 : 0,
+            open_database: components.openDatabase.value ? 1 : 0,
+            navigator_platform: components.platform.value,
+            regular_plugins: (_e = (_d = components.plugins.value) === null || _d === void 0 ? void 0 : _d.map((plugin) => plugin.name)) !== null && _e !== void 0 ? _e : [],
+            canvas: (_f = components.canvas.value) === null || _f === void 0 ? void 0 : _f.text,
+            webgl: (_g = components.canvas.value) === null || _g === void 0 ? void 0 : _g.text,
+            webgl_vendor: components.vendor.value,
+            has_lied_resolution: this.getHasLiedResolution(),
+            touch_support: Object.values((_h = components.touchSupport.value) !== null && _h !== void 0 ? _h : {}),
+            js_fonts: components.fonts.value,
+        };
+    }
+    /**
+     * Получаем данные dfp с помощью FingerprintJS, мапим необходимые поля, добавляем хэш
+     **/
+    generate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { library, getHash } = this.fingerprintJs;
+            const fingerprint = yield library.load();
+            const commonFingerPrintData = yield fingerprint.get();
+            const fingerPrintData = this.getComponents(commonFingerPrintData.components);
+            fingerPrintData.hash = getHash(JSON.stringify(fingerPrintData));
+            return fingerPrintData;
+        });
+    }
+    /**
+     * Отправка dfp на сервер, в ответ получаем dfp_hash
+     **/
+    send(fingerPrintData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = this.settingsService.token;
+            if (token === null) {
+                throw new DefaultTerminalError();
+            }
+            const requestBody = {
+                access_token: token,
+                'dfp[200]': '',
+            };
+            requestBody['dfp[200]'] = btoa(encodeURIComponent(JSON.stringify(fingerPrintData)));
+            return lastValueFrom(this.secureApi.post(this.apiRoute, new URLSearchParams(requestBody), {
+                headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                responseType: 'json',
+            }))
+                .then((response) => {
+                return response.dfp_hash;
+            })
+                .then((hash) => __awaiter(this, void 0, void 0, function* () {
+                const fingerprint = yield this.makeAntifraudFingerprint();
+                if (!fingerprint) {
+                    return null;
+                }
+                yield (fingerprint === null || fingerprint === void 0 ? void 0 : fingerprint.dispatch(hash['200']).catch((err) => console.log(err)));
+                const afsHash = yield fingerprint.hash();
+                return Object.assign({ '301': afsHash }, hash);
+            }))
+                .catch((error) => {
+                var _a, _b, _c, _d, _e, _f;
+                const response = error.getHttpErrorData().response;
+                throw new TerminalError((_c = (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.errors[0]) === null || _b === void 0 ? void 0 : _b.message) !== null && _c !== void 0 ? _c : '', (_f = (_e = (_d = response.data) === null || _d === void 0 ? void 0 : _d.errors[0]) === null || _e === void 0 ? void 0 : _e.support_code) !== null && _f !== void 0 ? _f : '');
+            });
+        });
+    }
+}
+DeviceFingerPrintService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DeviceFingerPrintService, deps: [{ token: SecureApiClient }, { token: SettingsService }, { token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable });
+DeviceFingerPrintService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DeviceFingerPrintService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DeviceFingerPrintService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: SecureApiClient }, { type: SettingsService }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [windowToken]
+                    }] }];
+    } });
+
+class SubmitService {
+    constructor(requestFactory, responseFactory, settingsService, deviceFingerPrintService, secureApi) {
+        this.requestFactory = requestFactory;
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.deviceFingerPrintService = deviceFingerPrintService;
+        this.secureApi = secureApi;
+        this.directPaymentApiRoute = 'directpayment';
+    }
+    // NB: Never add 'async' statement for this method!
+    // 'Async' statement wraps current promise into another.
+    // In this way two promises become unequal, that can broke XPS API requests logic.
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    request(fields, form) {
+        const responsePromise = this.deviceFingerPrintService
+            .getHash()
+            // eslint-disable-next-line @typescript-eslint/promise-function-async
+            .then((dfpHash) => {
+            const request = this.requestFactory({
+                token: this.settingsService.token,
+                fields,
+                form,
+                dfpHash,
+            });
+            return lastValueFrom(this.secureApi.post(this.directPaymentApiRoute, request, {
+                headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                responseType: 'json',
+            }))
+                .then((response) => this.responseFactory(response))
+                .catch((error) => {
+                throw new ResponseError(error.message);
+            });
+        });
+        return responsePromise;
+    }
+}
+SubmitService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SubmitService, deps: [{ token: submitRequestFactoryToken }, { token: submitResponseFactoryToken }, { token: SettingsService }, { token: DeviceFingerPrintService }, { token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
+SubmitService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SubmitService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SubmitService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [submitRequestFactoryToken]
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [submitResponseFactoryToken]
+                    }] }, { type: SettingsService }, { type: DeviceFingerPrintService }, { type: SecureApiClient }];
+    } });
+
+class XpsRequest {
+    addXpsParameters(parameters) {
+        for (const key in parameters) {
+            this[`xps_${key}`] = parameters[key];
+        }
+    }
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+class SyncRequest extends XpsRequest {
+    constructor(parameters) {
+        super();
+        this.xps_fix_command = 'calculate';
+        this.access_token = parameters.token;
+        const fieldsValues = this.getFieldsValues(parameters.changedField, parameters.fields, parameters.form);
+        this.addXpsParameters(Object.assign(Object.assign({}, fieldsValues), { change_element: parameters.changedField.name }));
+    }
+    getFieldsValues(changedField, fields, form) {
+        var _a;
+        const fieldsMap = this.getFieldsMap(fields);
+        return (_a = changedField === null || changedField === void 0 ? void 0 : changedField.javascript) === null || _a === void 0 ? void 0 : _a.change.params.reduce((xpsParams, fieldName) => {
+            var _a;
+            const formControl = form.get(fieldName);
+            const field = fieldsMap.get(fieldName);
+            if (formControl || field) {
+                xpsParams[fieldName] = (_a = formControl === null || formControl === void 0 ? void 0 : formControl.value) !== null && _a !== void 0 ? _a : field === null || field === void 0 ? void 0 : field.value;
+            }
+            return xpsParams;
+        }, {});
+    }
+    getFieldsMap(fields) {
+        const map = new Map();
+        fields.forEach((field) => map.set(field.name, field));
+        return map;
+    }
+}
+
+const syncRequestFactoryToken = new InjectionToken('SyncRequest');
+const syncRequestFactoryProvider = {
+    provide: syncRequestFactoryToken,
+    useValue: (...args) => new SyncRequest(...args),
+};
+
+class SyncResponse {
+    constructor(changedField, response) {
+        var _a;
+        const fieldError = (_a = response === null || response === void 0 ? void 0 : response.errors) === null || _a === void 0 ? void 0 : _a.find((error) => error.element_name === changedField.name);
+        if (fieldError) {
+            this.rewritableError = {
+                code: fieldError.code,
+                message: fieldError.message,
+            };
+        }
+        this.fields = Object.keys(response.form).map((key) => response.form[key]);
+        this.parameters = response;
+    }
+}
+
+const syncResponseFactoryToken = new InjectionToken('SyncResponse');
+const syncResponseFactoryProvider = {
+    provide: syncResponseFactoryToken,
+    useValue: (...args) => new SyncResponse(...args),
+};
+
+class SyncService {
+    constructor(requestFactory, responseFactory, secureApi, settingsService) {
+        this.requestFactory = requestFactory;
+        this.responseFactory = responseFactory;
+        this.secureApi = secureApi;
+        this.settingsService = settingsService;
+        this.apiRoute = 'directpayment';
+        this.prevFieldSyncStates = {};
+        this.form = new UntypedFormGroup({});
+        this.fields = [];
+    }
+    setup(form, fields) {
+        this.reset();
+        this.form = form;
+        this.fields = fields;
+    }
+    reset() {
+        this.prevFieldSyncStates = {};
+        this.form = new UntypedFormGroup({});
+        this.fields = [];
+    }
+    validate(field) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isReadyField(field)) {
+                return Promise.resolve(null);
+            }
+            const control = this.form.get(field.name);
+            const value = control === null || control === void 0 ? void 0 : control.value;
+            const prevFieldState = this.getPrevFieldSyncState(field);
+            const isInitialValue = value === field.value && !prevFieldState;
+            if (isInitialValue) {
+                return Promise.resolve(null);
+            }
+            if (prevFieldState && value === prevFieldState.value) {
+                return Promise.resolve(prevFieldState.result);
+            }
+            const requestPromise = this.request(field);
+            this.setPrevFieldSyncState(field, value, requestPromise);
+            return requestPromise.then((response) => {
+                var _a;
+                return (_a = response.rewritableError) !== null && _a !== void 0 ? _a : null;
+            });
+        });
+    }
+    request(field) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestParams = this.requestFactory({
+                token: this.settingsService.token,
+                changedField: field,
+                fields: this.fields,
+                form: this.form,
+            });
+            return lastValueFrom(this.secureApi.post(this.apiRoute, new URLSearchParams(requestParams), {
+                headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                responseType: 'json',
+            })).then((response) => {
+                return this.responseFactory(field, response);
+            });
+        });
+    }
+    isReadyField(field) {
+        var _a, _b;
+        const isSyncEnabled = !!((_a = field.javascript) === null || _a === void 0 ? void 0 : _a.change);
+        const isExistsInForm = !!((_b = this.form) === null || _b === void 0 ? void 0 : _b.get(field.name));
+        return isSyncEnabled && isExistsInForm;
+    }
+    getPrevFieldSyncState(field) {
+        return this.prevFieldSyncStates[field.name];
+    }
+    setPrevFieldSyncState(field, value, result) {
+        this.prevFieldSyncStates[field.name] = { value, result };
+    }
+}
+SyncService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, deps: [{ token: syncRequestFactoryToken }, { token: syncResponseFactoryToken }, { token: SecureApiClient }, { token: SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+SyncService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SyncService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [syncRequestFactoryToken]
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [syncResponseFactoryToken]
+                    }] }, { type: SecureApiClient }, { type: SettingsService }];
+    } });
+
+class ControlConfig {
+    constructor() {
+        this.shouldHideUserInput = false;
+    }
+}
+
+class TextControlConfig extends ControlConfig {
+    constructor() {
+        super(...arguments);
+        this.controlType = 'text';
+    }
+}
+
+function convert(validator, message) {
+    return (control) => {
+        const errors = validator(control);
+        if (!errors) {
+            return errors;
+        }
+        const firstErrorKey = Object.keys(errors)[0];
+        let error = errors[firstErrorKey];
+        error = typeof error === 'object' && error !== null ? error : {};
+        const rewritableError = Object.assign({}, error);
+        rewritableError.message = message;
+        if (error[firstErrorKey] != null) {
+            rewritableError.value = error[firstErrorKey];
+        }
+        if (rewritableError.requiredLength) {
+            rewritableError.number = rewritableError.requiredLength;
+        }
+        errors.rewritableError = rewritableError;
+        return errors;
+    };
+}
+
+const emailRegexp = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i; // eslint-disable-line
+function emailValidator() {
+    return convert(Validators.pattern(emailRegexp), 'Enter a valid email');
+}
+
+function requiredValidator() {
+    return convert(Validators.required, 'Required');
+}
+
+class Converter {
+    constructor(syncService) {
+        this.syncService = syncService;
+    }
+    convertToConfig(field, formState) {
+        const config = this.createControlConfig(field, formState);
+        if (formState === null || formState === void 0 ? void 0 : formState.disabled) {
+            config.disabled = true;
+        }
+        return config;
+    }
+    convertToFormControl(field) {
+        return new UntypedFormControl(this.getValue(field), this.getValidators(field), this.getAsyncValidators(field));
+    }
+    getValidators(field) {
+        const validators = [];
+        if (field.isMandatory === "1" /* XpsBoolean.true */) {
+            validators.push(requiredValidator());
+        }
+        if (field.regex) {
+            const match = /^\/(.*)\/([gim]*)$/.exec(field.regex);
+            if (match) {
+                const pattern = new RegExp(match[1], match[2]);
+                const errorMessage = field.validation_error_msg
+                    ? field.validation_error_msg
+                    : 'Enter valid data';
+                validators.push(convert(Validators.pattern(pattern), errorMessage));
+            }
+        }
+        return validators;
+    }
+    getAsyncValidators(field) {
+        return () => __awaiter(this, void 0, void 0, function* () { return this.syncService.validate(field); });
+    }
+    createDefaultControlConfig(controlConfigClass, field) {
+        const config = new controlConfigClass();
+        this.copyCommonOptions(config, field);
+        return config;
+    }
+    getValue(field) {
+        return field.value;
+    }
+    getDataType() {
+        return 'text';
+    }
+    getAutocomplete() {
+        return 'off';
+    }
+    shouldHideUserInput() {
+        return false;
+    }
+    getCommonControlConfig(field) {
+        return {
+            name: field.name,
+            title: field.title,
+            labelHint: field.label_hint,
+            dataType: this.getDataType(),
+            readonly: field.isReadonly === "1" /* XpsBoolean.true */,
+            placeholder: field.example,
+            autocomplete: this.getAutocomplete(),
+        };
+    }
+    copyCommonOptions(target, field) {
+        const commonControlConfig = this.getCommonControlConfig(field);
+        Object.keys(commonControlConfig).forEach((sourceKey) => {
+            if (!(sourceKey in target)) {
+                target[sourceKey] = commonControlConfig[sourceKey];
+            }
+        });
+    }
+}
+
+class EmailConverter extends Converter {
+    constructor(syncService) {
+        super(syncService);
+    }
+    getValidators(field) {
+        return super.getValidators(field).concat([emailValidator()]);
+    }
+    createControlConfig(field) {
+        const config = this.createDefaultControlConfig(TextControlConfig, field);
+        config.autocomplete = 'email';
+        config.icon = 'mail';
+        return config;
+    }
+    getDataType() {
+        return 'email';
+    }
+}
+EmailConverter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EmailConverter, deps: [{ token: SyncService }], target: i0.ɵɵFactoryTarget.Injectable });
+EmailConverter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EmailConverter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EmailConverter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: SyncService }]; } });
+
+const restrictedValueValidator = (restrictedValue) => {
+    return ({ value }) => {
+        return value !== restrictedValue ? null : { valueAllowed: false };
+    };
+};
+
+class ZipConverter extends Converter {
+    constructor(syncService, countryService) {
+        super(syncService);
+        this.countryService = countryService;
+        this.minLength = 3;
+        this.maxLength = 10;
+        this.usCountryLength = 5;
+    }
+    get isUsCountry() {
+        return this.countryService.getCountry() === 'US';
+    }
+    getValidators(field) {
+        const minLength = this.isUsCountry ? this.usCountryLength : this.minLength;
+        const maxLength = this.isUsCountry ? this.usCountryLength : this.maxLength;
+        const validators = super
+            .getValidators(field)
+            .concat([
+            convert(Validators.minLength(minLength), 'Enter at least ${minLength} characters'),
+            convert(Validators.maxLength(maxLength), 'Enter no more than ${maxLength} characters'),
+        ]);
+        if (this.isUsCountry) {
+            validators.push(convert(restrictedValueValidator('00000'), 'Enter a valid ZIP code'));
+        }
+        return validators;
+    }
+    createControlConfig(field) {
+        const config = this.createDefaultControlConfig(TextControlConfig, field);
+        config.icon = 'location';
+        if (this.isUsCountry) {
+            config.maskConfig = {
+                mask: () => new Array(this.usCountryLength).fill('9').join(''),
+                guide: false,
+                unmaskModelValue: true,
+                showMask: true,
+            };
+            config.inputMode = 'numeric';
+        }
+        else {
+            config.maxLength = this.maxLength;
+        }
+        return config;
+    }
+    getAutocomplete() {
+        return 'postal-code';
+    }
+    getDataType() {
+        return 'text';
+    }
+}
+ZipConverter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ZipConverter, deps: [{ token: SyncService }, { token: CountryService }], target: i0.ɵɵFactoryTarget.Injectable });
+ZipConverter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ZipConverter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ZipConverter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: SyncService }, { type: CountryService }]; } });
+
+const convertersMapToken = new InjectionToken('ConvertersTokensMap');
+const convertersMap = {
+    zip: ZipConverter,
+    email: EmailConverter,
+};
+
+class ControlConfigService {
+    constructor(convertersMap, injector) {
+        this.convertersMap = convertersMap;
+        this.injector = injector;
+    }
+    getFormControl(field) {
+        const converter = this.getConverter(field);
+        if (!converter) {
+            return null;
+        }
+        return converter.convertToFormControl(field);
+    }
+    getConverter(field) {
+        if (!field) {
+            return null;
+        }
+        const sanitizedName = field.name.replace(/^fix_/i, '');
+        let converter = this.convertersMap[sanitizedName];
+        if (!converter) {
+            converter = this.convertersMap[field.type];
+        }
+        if (!converter) {
+            return null;
+        }
+        return this.injector.get(converter);
+    }
+}
+ControlConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ControlConfigService, deps: [{ token: convertersMapToken }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ControlConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ControlConfigService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ControlConfigService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [convertersMapToken]
+                    }] }, { type: i0.Injector }];
+    } });
+
+class FormService {
+    constructor(controlConfigService) {
+        this.controlConfigService = controlConfigService;
+    }
+    createForm(fields) {
+        const controls = this.getVisibleFields(fields).reduce((result, field) => {
+            const formControl = this.controlConfigService.getFormControl(field);
+            if (formControl) {
+                result[field.name] = formControl;
+            }
+            return result;
+        }, {});
+        return new UntypedFormGroup(controls);
+    }
+    getVisibleFields(fields) {
+        return fields.filter(({ isVisible }) => isVisible === "1" /* XpsBoolean.true */);
+    }
+}
+FormService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: FormService, deps: [{ token: ControlConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+FormService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: FormService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: FormService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: ControlConfigService }]; } });
+
+class StatusUpdatedAction {
+    constructor(statusResponse) {
+        this.type = 'status_updated';
+        this.data = {
+            statusState: statusResponse.status.statusState,
+            invoice: statusResponse.status.invoice,
+            isSuccess: statusResponse.status.isSuccess,
+            isCanceled: statusResponse.status.isCanceled,
+            group: statusResponse.status.group,
+        };
+    }
+}
+
+class XpsApiPart {
+    constructor() {
+        this.response = new BehaviorSubject(null);
+    }
+    get response$() {
+        return this.response
+            .asObservable()
+            .pipe(filter((response) => response !== null));
+    }
+    emitResponse(response) {
+        this.response.next(response);
+    }
+    get currentValue() {
+        return this.response.getValue();
+    }
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+class StatusRequest extends XpsApiPartRequest {
+    constructor(parameters) {
+        super();
+        this.xps_fix_command = 'status';
+        if (parameters.token === null) {
+            throw new TokenError();
+        }
+        this.access_token = parameters.token;
+        this.xps_fix_invoice = parameters.invoice;
+        this.xps_fix_pid = parameters.pid;
+        this.xps_signature = parameters.signature;
+        this.xps_fix_testProject = parameters.testProject;
+        this.xps_fix_testPs = parameters.testPs;
+        this.xps_fix_testXsolla = parameters.testXsolla;
+        this.xps_fix_userReturnStatus = parameters.userReturnStatus;
+        this.xps_locale = parameters.locale;
+    }
+}
+
+const statusRequestFactoryToken = new InjectionToken('StatusRequest');
+const statusRequestFactoryProvider = {
+    provide: statusRequestFactoryToken,
+    useValue: (...args) => new StatusRequest(...args),
+};
+
+var StatusGroups;
+(function (StatusGroups) {
+    StatusGroups["troubled"] = "troubled";
+    StatusGroups["done"] = "done";
+    StatusGroups["invoice"] = "invoice";
+})(StatusGroups || (StatusGroups = {}));
+
+var StatusEnum;
+(function (StatusEnum) {
+    StatusEnum["created"] = "created";
+    StatusEnum["awaiting"] = "awaiting";
+    StatusEnum["processing"] = "processing";
+    StatusEnum["authorized"] = "authorized";
+    StatusEnum["held"] = "held";
+    StatusEnum["done"] = "done";
+    StatusEnum["error"] = "error";
+    StatusEnum["canceled"] = "canceled";
+})(StatusEnum || (StatusEnum = {}));
+
+class StatusResponse {
+    constructor(parameters) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if ((_a = parameters.errors) === null || _a === void 0 ? void 0 : _a[0]) {
+            this.error = {
+                code: parameters.errors[0].code.toString(),
+                message: parameters.errors[0].message,
+            };
+        }
+        if (!parameters.status) {
+            throw new TerminalError((_c = (_b = this.error) === null || _b === void 0 ? void 0 : _b.message) !== null && _c !== void 0 ? _c : '', (_e = (_d = this.error) === null || _d === void 0 ? void 0 : _d.code.toString()) !== null && _e !== void 0 ? _e : '');
+        }
+        this.status = {
+            statusState: parameters.status.statusData.stateText,
+            email: parameters.status.statusData.email,
+            webSocketUrl: parameters.status.statusData.webSocketChannelUrl,
+            webSocketChannelName: parameters.status.statusData.webSocketChannelName,
+            webSocketClientType: parameters.status.statusData.webSocketClientType,
+            financeInfo: parameters.status.text.info,
+            discount: parameters.status.text.info.discount
+                ? Math.abs(Number.parseFloat((_g = (_f = parameters.status.text.info.discount) === null || _f === void 0 ? void 0 : _f.value) !== null && _g !== void 0 ? _g : ''))
+                : null,
+            isCancelUser: parameters.status.isCancelUser,
+            postMessageStatus: parameters.status.isCancelUser
+                ? StatusGroups.troubled
+                : parameters.status.group,
+            virtualCurrencyAmount: parameters.status.statusData.out,
+            backUrlSettings: {
+                backUrl: parameters.status.text.backurl,
+                backUrlAction: parameters.status.text.backurl_action,
+                backUrlCaption: parameters.status.text.backurl_caption,
+                returnRegion: parameters.status.return_region,
+            },
+            additionalBackButton: this.getAdditionalBackButton(parameters.status),
+            group: parameters.status.group,
+            needToCheck: parameters.status.needToCheck,
+            autoRedirect: parameters.status.autoredirect,
+            statusMessage: parameters.status.text.state,
+            userId: parameters.status.statusData.v1,
+            invoice: parameters.status.statusData.invoice,
+            pid: parameters.status.statusData.pid,
+            projectAmount: this.getProjectAmount(parameters.status),
+            titleClass: parameters.status.title_class,
+            paymentCountryIso: parameters.status.statusData.payment_country_iso,
+            order: parameters.status.text.order,
+        };
+        if (parameters.form) {
+            this.status.userReturnStatus = this.getUserReturnStatus(parameters.form);
+        }
+        if (this.status.statusState === StatusEnum.done ||
+            this.status.statusState === StatusEnum.authorized) {
+            this.status.isSuccess = true;
+        }
+        if (this.status.statusState === StatusEnum.canceled ||
+            this.status.isCancelUser) {
+            this.status.isCanceled = true;
+        }
+    }
+    getUserReturnStatus(form) {
+        var _a;
+        const value = (_a = form['fix_userReturnStatus']) === null || _a === void 0 ? void 0 : _a.value;
+        if (value === 'undefined')
+            return undefined;
+        return value;
+    }
+    getProjectAmount(status) {
+        if (!status.statusData.projectAmount) {
+            return;
+        }
+        const [amount, currency] = status.statusData.projectAmount.split(' ');
+        return {
+            amount,
+            currency,
+        };
+    }
+    getAdditionalBackButton(status) {
+        var _a, _b, _c, _d;
+        if (!status.text.is_additional_back_url_enabled) {
+            return {
+                link: '',
+                action: '',
+                label: '',
+                region: '',
+                isEnabled: false,
+            };
+        }
+        return {
+            link: (_a = status.text.additional_back_url_link) !== null && _a !== void 0 ? _a : '',
+            action: (_b = status.text.additional_back_url_action) !== null && _b !== void 0 ? _b : '',
+            label: (_c = status.text.additional_back_url_label) !== null && _c !== void 0 ? _c : '',
+            region: (_d = status.additional_button_return_region) !== null && _d !== void 0 ? _d : '',
+            isEnabled: status.text.is_additional_back_url_enabled,
+        };
+    }
+}
+
+const statusResponseFactoryToken = new InjectionToken('StatusResponse');
+const statusResponseFactoryProvider = {
+    provide: statusResponseFactoryToken,
+    useValue: (...args) => new StatusResponse(...args),
+};
+
+class StatusRequestService extends XpsApiPart {
+    constructor(secureApiClient, settingsService, requestFactory, responseFactory) {
+        super();
+        this.secureApiClient = secureApiClient;
+        this.settingsService = settingsService;
+        this.requestFactory = requestFactory;
+        this.responseFactory = responseFactory;
+        this.apiRoute = 'directpayment';
+    }
+    setRequestParams(params) {
+        this.requestParams = {
+            locale: params.locale,
+            testProject: params.testProject,
+            testPs: params.testPs,
+            testXsolla: params.testXsolla,
+            userReturnStatus: params.userReturnStatus,
+            invoice: params.invoice,
+            pid: params.pid,
+            signature: params.signature,
+        };
+    }
+    request() {
+        const requestParams = this.requestFactory(Object.assign({ token: this.settingsService.token }, this.requestParams));
+        lastValueFrom(this.secureApiClient.post(this.apiRoute, new URLSearchParams(requestParams), {
+            headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+            responseType: 'json',
+        }))
+            .then((response) => {
+            const statusResponse = this.responseFactory({
+                status: response.status,
+                errors: response.errors,
+                form: response.form,
+            });
+            this.emitResponse(statusResponse);
+        })
+            .catch((e) => {
+            throw new TerminalError(e.message, e.code);
+        });
+    }
+}
+StatusRequestService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusRequestService, deps: [{ token: SecureApiClient }, { token: SettingsService }, { token: statusRequestFactoryToken }, { token: statusResponseFactoryToken }], target: i0.ɵɵFactoryTarget.Injectable });
+StatusRequestService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusRequestService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusRequestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: SecureApiClient }, { type: SettingsService }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [statusRequestFactoryToken]
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [statusResponseFactoryToken]
+                    }] }];
+    } });
+
+/* eslint-disable @typescript-eslint/naming-convention */
+class CheckStatusRequest extends XpsApiPartRequest {
+    constructor(token, invoice) {
+        super();
+        this.xps_fix_command = 'status';
+        this.section = 'getstatus';
+        if (token === null) {
+            throw new TokenError();
+        }
+        this.access_token = token;
+        this.invoice = invoice;
+    }
+}
+
+const checkStatusRequestFactoryToken = new InjectionToken('CheckStatusRequest');
+const checkStatusRequestFactoryProvider = {
+    provide: checkStatusRequestFactoryToken,
+    useValue: (...args) => new CheckStatusRequest(...args),
+};
+
+/* eslint-disable @typescript-eslint/naming-convention */
+class CheckStatusResponse {
+    constructor(parameters) {
+        this.status = parameters.status;
+        this.final = parameters.final;
+        this.isPaymentAccountAttached = parameters.isPaymentAccountAttached;
+    }
+}
+
+const checkStatusResponseFactoryToken = new InjectionToken('CheckStatusResponse');
+const checkStatusResponseFactoryProvider = {
+    provide: checkStatusResponseFactoryToken,
+    useValue: (...args) => new CheckStatusResponse(...args),
+};
+
+class CheckStatusService extends XpsApiPart {
+    constructor(secureApiClient, settingsService, requestFactory, responseFactory) {
+        super();
+        this.secureApiClient = secureApiClient;
+        this.settingsService = settingsService;
+        this.requestFactory = requestFactory;
+        this.responseFactory = responseFactory;
+        this.apiRoute = 'directpayment';
+    }
+    setRequestParams(invoice) {
+        this.invoice = invoice;
+    }
+    request() {
+        const requestParams = this.requestFactory(this.settingsService.token, this.invoice);
+        lastValueFrom(this.secureApiClient.post(this.apiRoute, new URLSearchParams(Object.assign({}, requestParams)), {
+            headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+            responseType: 'json',
+        }))
+            .then((response) => {
+            const checkStatusResponse = this.responseFactory({
+                status: response.status,
+                final: response.final,
+                isPaymentAccountAttached: response.is_payment_account_attached,
+            });
+            this.emitResponse(checkStatusResponse);
+        })
+            .catch((error) => {
+            throw new ResponseError(error.message);
+        });
+    }
+}
+CheckStatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CheckStatusService, deps: [{ token: SecureApiClient }, { token: SettingsService }, { token: checkStatusRequestFactoryToken }, { token: checkStatusResponseFactoryToken }], target: i0.ɵɵFactoryTarget.Injectable });
+CheckStatusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CheckStatusService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CheckStatusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: SecureApiClient }, { type: SettingsService }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [checkStatusRequestFactoryToken]
+                    }] }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [checkStatusResponseFactoryToken]
+                    }] }];
+    } });
+
+var WebSocketStatus;
+(function (WebSocketStatus) {
+    WebSocketStatus["statusChanged"] = "status_changed";
+    WebSocketStatus["troubledStatus"] = "troubled_status";
+})(WebSocketStatus || (WebSocketStatus = {}));
+
+var WebSocketClientType;
+(function (WebSocketClientType) {
+    WebSocketClientType["nchan"] = "nchan";
+    WebSocketClientType["centrifugo"] = "centrifugo";
+})(WebSocketClientType || (WebSocketClientType = {}));
+
+class NchanWebSocketService {
+    constructor() {
+        this.type = WebSocketClientType.nchan;
+        this.reconnectionTimerId = null;
+        this.incomingMessages$ = new Subject();
+        this.successfulReconnectionEventsProxy$ = new Subject();
+    }
+    open() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.openPromise && !this.isClosed()) {
+                return this.openPromise;
+            }
+            this.openPromise = this.createConnection()
+                .catch(() => __awaiter(this, void 0, void 0, function* () {
+                return this.waitWhileNotReconnect();
+            }))
+                .then(() => {
+                this.connection.onclose = () => __awaiter(this, void 0, void 0, function* () { return this.open(); });
+            });
+            return this.openPromise;
+        });
+    }
+    close() {
+        this.clearReconnectionTimer();
+        if (this.isClosed()) {
+            return;
+        }
+        this.connection.onclose = null;
+        this.connection.close();
+    }
+    get messages$() {
+        return this.incomingMessages$
+            .asObservable()
+            .pipe(map$1((event) => event.data));
+    }
+    subscribeOnSuccessfulReconnection(next) {
+        return this.successfulReconnectionEventsProxy$
+            .asObservable()
+            .subscribe(next);
+    }
+    isClosed() {
+        if (!this.connection) {
+            return true;
+        }
+        return [this.connection.CLOSED, this.connection.CLOSING].includes(this.connection.readyState);
+    }
+    clearReconnectionTimer() {
+        if (this.reconnectionTimerId) {
+            clearTimeout(this.reconnectionTimerId);
+            this.reconnectionTimerId = null;
+        }
+    }
+    setFirstReconnectionTimeout() {
+        const min = NchanWebSocketService.timeoutsMs.reconnection -
+            NchanWebSocketService.timeoutsMs.reconnectionMaxDeviation;
+        const max = NchanWebSocketService.timeoutsMs.reconnection +
+            NchanWebSocketService.timeoutsMs.reconnectionMaxDeviation;
+        this.reconnectionTimeoutMs =
+            Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    incrementReconnectionTimeout() {
+        this.reconnectionTimeoutMs =
+            this.reconnectionTimeoutMs *
+                NchanWebSocketService.reconnectionTimeoutIncrementFactor;
+    }
+    createConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connection = new WebSocket(this.url);
+            this.connection.onmessage = this.incomingMessages$.next.bind(this.incomingMessages$);
+            return new Promise((resolve, reject) => {
+                this.connection.onopen = () => {
+                    clearTimeout(this.openConnectionTimerId);
+                    resolve();
+                };
+                this.connection.onclose = () => {
+                    reject();
+                };
+            });
+        });
+    }
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clearReconnectionTimer();
+            return new Promise((resolve) => {
+                this.reconnectionTimerId = setTimeout(() => {
+                    this.createConnection()
+                        .then(() => resolve(true))
+                        .catch(() => resolve(false));
+                    this.incrementReconnectionTimeout();
+                }, this.reconnectionTimeoutMs);
+            });
+        });
+    }
+    waitWhileNotReconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clearReconnectionTimer();
+            this.setFirstReconnectionTimeout();
+            let isConnected = false;
+            while (!isConnected) {
+                isConnected = yield this.reconnect();
+            }
+            this.successfulReconnectionEventsProxy$.next();
+        });
+    }
+}
+NchanWebSocketService.reconnectionTimeoutIncrementFactor = 2;
+NchanWebSocketService.timeoutsMs = {
+    reconnection: 1500,
+    reconnectionMaxDeviation: 1500,
+};
+NchanWebSocketService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NchanWebSocketService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NchanWebSocketService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NchanWebSocketService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NchanWebSocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var ErrorTags;
+(function (ErrorTags) {
+    ErrorTags["APP"] = "appError";
+    ErrorTags["HTTP"] = "httpError";
+    ErrorTags["JS"] = "jsError";
+    ErrorTags["WS"] = "webSocket";
+    ErrorTags["ENCRYPT"] = "encrypt";
+    ErrorTags["APPLEPAY"] = "applepay";
+    ErrorTags["HEADLESS_UI"] = "headlessUi";
+    ErrorTags["GOOGLEPAY"] = "googlepay";
+    ErrorTags["PAYTM"] = "paytm";
+})(ErrorTags || (ErrorTags = {}));
+
+class TaggedError extends Error {
+    constructor(message, tags) {
+        super(message);
+        this.tags = [];
+        this.parentTag = ErrorTags.HEADLESS_UI;
+        this.tags = this.childTag
+            ? [this.parentTag, this.childTag]
+            : [this.parentTag];
+        if (tags) {
+            const newTags = tags.filter((t, i, arr) => !this.tags.includes(t) && arr.indexOf(t) == i);
+            this.tags = [...this.tags, ...newTags];
+        }
+    }
+}
+
+class WsError extends TaggedError {
+    constructor(message, channelName, tags) {
+        tags = tags ? [...tags, ErrorTags.WS] : [ErrorTags.WS];
+        const messageWithChannel = `${message}. ChannelName - ${channelName}`;
+        super(messageWithChannel, tags);
+    }
+}
+
+class ElkLoggerService {
+    constructor(window, settingsService, http, ngZone) {
+        this.window = window;
+        this.settingsService = settingsService;
+        this.http = http;
+        this.ngZone = ngZone;
+        this.vendors = new RegExp('node_modules\\/(@angular|zone).*.js$');
+        this.stackTrace = this.loadStackTrace();
+    }
+    handleError(error) {
+        this.ngZone.runOutsideAngular(() => {
+            if (isDevMode()) {
+                console.error(error);
+                return;
+            }
+            this.parseError(error).catch(console.log);
+        });
+    }
+    log(message, tags, extra) {
+        const logTags = [ErrorTags.HEADLESS_UI, ...tags];
+        if (isDevMode()) {
+            console.log(message, tags);
+            return;
+        }
+        const logMessage = {
+            additionalInfo: this.getAdditionalInfo(),
+            extra,
+            message,
+        };
+        this.sendLog(logMessage, logTags);
+    }
+    parseError(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errorObj = error instanceof TaggedError
+                ? error
+                : new TaggedError(error.message || error.toString());
+            errorObj.trace = yield this.getErrorTrace(errorObj);
+            errorObj.additionalInfo = this.getAdditionalInfo();
+            const { tags } = errorObj;
+            const cleanError = this.removeErrorMetaFields(errorObj);
+            this.sendLog(cleanError, tags);
+            return errorObj;
+        });
+    }
+    loadStackTrace() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const library = yield import('stacktrace-js');
+            return library.default;
+        });
+    }
+    getErrorTrace(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stackTrace = yield this.stackTrace;
+            const stackFramesArr = yield stackTrace.fromError(error);
+            const filteredFramesArr = stackFramesArr.filter(({ fileName }) => fileName && !this.vendors.test(fileName));
+            return filteredFramesArr
+                .map((stackFrame) => stackFrame.toString())
+                .join('\n');
+        });
+    }
+    getAdditionalInfo() {
+        const extractUrlHost = (url) => url.replace(/^https?:\/\/([^/?#]+).*$/i, '$1');
+        return {
+            location: {
+                url: this.window.location.href,
+            },
+            project: {
+                id: this.settingsService.project.id,
+            },
+            referrer: {
+                url: this.window.document.referrer,
+            },
+            viewport: {
+                width: this.window.document.documentElement.clientWidth,
+                height: this.window.document.documentElement.clientHeight,
+            },
+            cdn_address: this.settingsService.settings.cdnUrl
+                ? extractUrlHost(this.settingsService.settings.cdnUrl)
+                : 'none',
+            country: this.settingsService.user.country.value,
+            local: this.settingsService.user.country.localized_name,
+        };
+    }
+    removeErrorMetaFields(error) {
+        const metaPropList = [
+            'parentTag',
+            'childTag',
+            'RESTRICTED_KEYS_REGEXP',
+            'tags',
+        ];
+        Object.keys(error).forEach((key) => {
+            if (metaPropList.includes(key))
+                delete error[key];
+        });
+        // implementing own 'message' property from prototype
+        return Object.assign(Object.assign({}, error), { message: error.message });
+    }
+    sendLog(message, tags) {
+        const url = `https://logs-01.xsolla.com/tag/${tags.join(',')}`;
+        firstValueFrom(this.http.post(url, message, {
+            headers: new HttpHeaders().set('Content-Type', 'text/plain'),
+            responseType: 'text',
+        })).catch((err) => console.error('Elk Logger: request error', err));
+    }
+}
+ElkLoggerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ElkLoggerService, deps: [{ token: windowToken }, { token: SettingsService }, { token: i1.HttpClient }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+ElkLoggerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ElkLoggerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ElkLoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [windowToken]
+                    }] }, { type: SettingsService }, { type: i1.HttpClient }, { type: i0.NgZone }];
+    } });
+
+class CentrifugoWebSocketService {
+    constructor(elkLoggerService) {
+        this.elkLoggerService = elkLoggerService;
+        this.type = WebSocketClientType.centrifugo;
+        this.reconnectionTimerId = null;
+        this.isConnectionOpen = false;
+        this.isConnecting = false;
+        this.incomingMessages$ = new Subject();
+        this.successfulReconnectionEventsProxy$ = new Subject();
+    }
+    open(url, channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (url === this.url && channel === this.channel) {
+                return;
+            }
+            try {
+                this.url = url;
+                this.channel = channel;
+                yield this.createConnection(url, channel);
+            }
+            catch (error) {
+                // @ts-expect-error error is unknown
+                const message = ((error === null || error === void 0 ? void 0 : error.message) || error);
+                const unknownError = new WsError(`unknown websocket error: ${message}`, channel);
+                this.elkLoggerService.handleError(unknownError);
+            }
+        });
+    }
+    close() {
+        this.clearReconnectionTimer();
+        if (!this.isConnectionOpen) {
+            return;
+        }
+        this.connection.disconnect();
+    }
+    get messages$() {
+        return (this.incomingMessages$
+            .asObservable()
+            // event don't respect type from argument, it's weird
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            .pipe(map$1((event) => event.data)));
+    }
+    subscribeOnSuccessfulReconnection(next) {
+        return this.successfulReconnectionEventsProxy$
+            .asObservable()
+            .subscribe(next);
+    }
+    clearReconnectionTimer() {
+        if (this.reconnectionTimerId) {
+            clearTimeout(this.reconnectionTimerId);
+            this.reconnectionTimerId = null;
+        }
+    }
+    setFirstReconnectionTimeout() {
+        const min = CentrifugoWebSocketService.timeoutsMs.reconnection -
+            CentrifugoWebSocketService.timeoutsMs.reconnectionMaxDeviation;
+        const max = CentrifugoWebSocketService.timeoutsMs.reconnection +
+            CentrifugoWebSocketService.timeoutsMs.reconnectionMaxDeviation;
+        this.reconnectionTimeoutMs =
+            Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    incrementReconnectionTimeout() {
+        this.reconnectionTimeoutMs =
+            this.reconnectionTimeoutMs *
+                CentrifugoWebSocketService.reconnectionTimeoutIncrementFactor;
+    }
+    getCentrifugoClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return import('centrifuge').then((module) => module.Centrifuge);
+        });
+    }
+    createConnection(url, channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnectionOpen || this.isConnecting) {
+                return;
+            }
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            const CentrifugeClient = yield this.getCentrifugoClient();
+            const websocketUrl = url !== null && url !== void 0 ? url : this.url;
+            const websocketChannel = channel !== null && channel !== void 0 ? channel : this.channel;
+            this.connection = new CentrifugeClient(websocketUrl, {
+                debug: true,
+                maxReconnectDelay: 1500,
+                maxServerPingDelay: 1000,
+            });
+            return new Promise((resolve, reject) => {
+                this.connection
+                    .on('connecting', () => {
+                    this.isConnecting = true;
+                })
+                    .on('connected', () => {
+                    this.onConnect();
+                    resolve();
+                })
+                    .on('disconnected', (ctx) => {
+                    this.onDisconnect(ctx, websocketChannel);
+                    reject();
+                })
+                    .on('error', (ctx) => {
+                    const message = `code ${ctx.error.code} - ${ctx.error.message}`;
+                    this.elkLoggerService.log(`connection error: ${message}`, [ErrorTags.WS], {
+                        channel: websocketChannel,
+                    });
+                })
+                    .connect();
+                this.subscription = this.connection.newSubscription(websocketChannel, this.getSubscriptionOptions(websocketChannel));
+                this.subscription
+                    .on('subscribed', (ctx) => {
+                    this.subscriptionPosition = ctx.streamPosition;
+                    this.prevSubscribedChannel = websocketChannel;
+                })
+                    .on('publication', (ctx) => {
+                    const message = ctx.data;
+                    this.elkLoggerService.log(`websocket message received: ${message}`, [ErrorTags.WS], {
+                        channel: websocketChannel,
+                    });
+                    this.incomingMessages$.next(ctx);
+                })
+                    .on('error', (ctx) => {
+                    const message = `code ${ctx.error.code} - ${ctx.error.message}`;
+                    this.elkLoggerService.log(`subscription error: ${message}`, [ErrorTags.WS], {
+                        channel: websocketChannel,
+                    });
+                })
+                    .subscribe();
+            });
+        });
+    }
+    onConnect() {
+        clearTimeout(this.openConnectionTimerId);
+        this.isConnecting = false;
+        this.isConnectionOpen = true;
+    }
+    onDisconnect(ctx, websocketChannel) {
+        this.isConnecting = false;
+        this.isConnectionOpen = false;
+        /* If connection error, cause any connection error isn't 0 */
+        if (ctx.code !== 0) {
+            const message = `code ${ctx.code} - ${ctx.reason}`;
+            this.elkLoggerService.log(`disconnected error: ${message}`, [ErrorTags.WS], {
+                channel: websocketChannel,
+            });
+            (() => __awaiter(this, void 0, void 0, function* () {
+                yield this.waitWhileNotReconnect();
+            }))();
+        }
+    }
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clearReconnectionTimer();
+            return new Promise((resolve) => {
+                this.reconnectionTimerId = setTimeout(() => {
+                    this.createConnection()
+                        .then(() => resolve(true))
+                        .catch(() => resolve(false));
+                    this.incrementReconnectionTimeout();
+                }, this.reconnectionTimeoutMs);
+            });
+        });
+    }
+    waitWhileNotReconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clearReconnectionTimer();
+            this.setFirstReconnectionTimeout();
+            let isConnected = false;
+            const beforeTimer = performance.now();
+            while (!isConnected) {
+                isConnected = yield this.reconnect();
+            }
+            const afterTimer = performance.now();
+            const timerDuration = afterTimer - beforeTimer;
+            this.elkLoggerService.log(`fallback to reconnection timer: duration ${timerDuration}ms`, [ErrorTags.WS], {
+                channel: this.channel,
+            });
+            this.successfulReconnectionEventsProxy$.next();
+        });
+    }
+    getSubscriptionOptions(websocketChannel) {
+        const options = {
+            recoverable: true,
+        };
+        if (websocketChannel === this.prevSubscribedChannel &&
+            this.subscriptionPosition) {
+            options.since = this.subscriptionPosition;
+        }
+        return options;
+    }
+}
+CentrifugoWebSocketService.reconnectionTimeoutIncrementFactor = 2;
+CentrifugoWebSocketService.timeoutsMs = {
+    reconnection: 1000,
+    reconnectionMaxDeviation: 1000,
+};
+CentrifugoWebSocketService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CentrifugoWebSocketService, deps: [{ token: ElkLoggerService }], target: i0.ɵɵFactoryTarget.Injectable });
+CentrifugoWebSocketService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CentrifugoWebSocketService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CentrifugoWebSocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: ElkLoggerService }]; } });
+
+// @todo: remove this factory and switch to centrifugo client after centrifugo issues resolved
+class WebSocketFactory {
+    constructor(nchanWebSocket, centrifugoWebSocket) {
+        this.nchanWebSocket = nchanWebSocket;
+        this.centrifugoWebSocket = centrifugoWebSocket;
+    }
+    createWebSocketClient(url, clientType) {
+        if (clientType === WebSocketClientType.centrifugo) {
+            return this.centrifugoWebSocket;
+        }
+        this.nchanWebSocket.url = url;
+        return this.nchanWebSocket;
+    }
+}
+WebSocketFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: WebSocketFactory, deps: [{ token: NchanWebSocketService }, { token: CentrifugoWebSocketService }], target: i0.ɵɵFactoryTarget.Injectable });
+WebSocketFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: WebSocketFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: WebSocketFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: NchanWebSocketService }, { type: CentrifugoWebSocketService }]; } });
+
+class WebsocketStatusService {
+    get needCheckStatus$() {
+        return this.needCheckStatusSubject.asObservable();
+    }
+    get statusChanged$() {
+        return this.statusChangedSubject.asObservable();
+    }
+    constructor(webSocketFactory) {
+        this.webSocketFactory = webSocketFactory;
+        this.reinsuranceCheckStatus = {
+            timeoutId: null,
+            timeoutMs: 180000,
+        };
+        this.needCheckStatusSubject = new Subject();
+        this.statusChangedSubject = new Subject();
+        this.webSocketClient = null;
+    }
+    checkStatusWithWebSocket(webSocketUrl, webSocketChannelName, webSocketClientType) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.webSocketClient = this.webSocketFactory.createWebSocketClient(webSocketUrl, webSocketClientType);
+            yield this.webSocketClient.open(webSocketUrl, webSocketChannelName);
+            (_a = this.webSocketSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+            this.webSocketSubscription = this.webSocketClient.messages$.subscribe((message) => this.statusProcessing(message));
+            this.webSocketReconnectionSubscription =
+                this.webSocketClient.subscribeOnSuccessfulReconnection(() => {
+                    this.needCheckStatusSubject.next();
+                });
+            this.needCheckStatusSubject.next();
+            this.startReinsuranceCheckTimeout();
+        });
+    }
+    closeWebSocket() {
+        var _a;
+        this.removeSubscription();
+        (_a = this.webSocketClient) === null || _a === void 0 ? void 0 : _a.close();
+        this.clearReinsuranceCheckTimeout();
+    }
+    startReinsuranceCheckTimeout() {
+        this.clearReinsuranceCheckTimeout();
+        this.reinsuranceCheckStatus.timeoutId = setTimeout(() => {
+            this.needCheckStatusSubject.next();
+        }, this.reinsuranceCheckStatus.timeoutMs);
+    }
+    clearReinsuranceCheckTimeout() {
+        if (this.reinsuranceCheckStatus.timeoutId) {
+            clearTimeout(this.reinsuranceCheckStatus.timeoutId);
+            this.reinsuranceCheckStatus.timeoutId = null;
+        }
+    }
+    statusProcessing(message) {
+        if (message === WebSocketStatus.statusChanged) {
+            this.statusChangedSubject.next();
+            this.closeWebSocket();
+            this.clearReinsuranceCheckTimeout();
+        }
+        if (message === WebSocketStatus.troubledStatus) {
+            this.clearReinsuranceCheckTimeout();
+            this.closeWebSocket();
+        }
+    }
+    removeSubscription() {
+        var _a, _b;
+        (_a = this.webSocketSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        (_b = this.webSocketReconnectionSubscription) === null || _b === void 0 ? void 0 : _b.unsubscribe();
+    }
+}
+WebsocketStatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: WebsocketStatusService, deps: [{ token: WebSocketFactory }], target: i0.ɵɵFactoryTarget.Injectable });
+WebsocketStatusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: WebsocketStatusService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: WebsocketStatusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: WebSocketFactory }]; } });
+
+class ListenStatusService {
+    get websocketOpened$() {
+        return this.websocketOpenedSubject.asObservable();
+    }
+    get statusUpdated$() {
+        return this.statusUpdatedSubject.asObservable();
+    }
+    constructor(statusService, checkStatusService, websocketStatusService) {
+        this.statusService = statusService;
+        this.checkStatusService = checkStatusService;
+        this.websocketStatusService = websocketStatusService;
+        this.isListening = false;
+        this.websocketOpenedSubject = new Subject();
+        this.statusUpdatedSubject = new Subject();
+        this.statusDoneSubject = new Subject();
+        this.destroy$ = new Subject();
+    }
+    listen(invoice) {
+        if (this.isListening) {
+            this.stopListening();
+        }
+        this.destroy$ = new Subject();
+        this.isListening = true;
+        this.subscribeStatusUpdate(invoice);
+        this.subscribeCheckStatusUpdate();
+        this.subscribeWebsocketEvent();
+        this.checkStatusService.setRequestParams(invoice);
+        return this.statusDoneSubject.asObservable();
+    }
+    stopListening() {
+        this.isListening = false;
+        this.websocketStatusService.closeWebSocket();
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    subscribeStatusUpdate(invoice) {
+        this.statusService.response$
+            .pipe(filter$1((statusResponse) => {
+            var _a;
+            return ((_a = statusResponse === null || statusResponse === void 0 ? void 0 : statusResponse.status) === null || _a === void 0 ? void 0 : _a.invoice) === Number(invoice);
+        }), takeUntil(this.destroy$))
+            .subscribe((statusResponse) => {
+            if (!(statusResponse === null || statusResponse === void 0 ? void 0 : statusResponse.status)) {
+                return;
+            }
+            const statusSettings = {
+                statusState: statusResponse.status.statusState,
+                isCancelUser: statusResponse.status.isCancelUser,
+                needWebSocket: statusResponse.status.needToCheck,
+                backUrlSettings: statusResponse.status.backUrlSettings,
+                autoRedirect: statusResponse.status.autoRedirect,
+                webSocketUrl: statusResponse.status.webSocketUrl,
+                webSocketChannelName: statusResponse.status.webSocketChannelName,
+                webSocketClientType: statusResponse.status.webSocketClientType,
+            };
+            this.statusUpdatedSubject.next({
+                statusResponse: statusResponse,
+                statusSettings: statusSettings,
+            });
+            if (statusSettings.needWebSocket) {
+                this.openWebsocket(statusSettings);
+                return;
+            }
+            this.stopListening();
+            this.statusDoneSubject.next(statusSettings);
+        });
+    }
+    subscribeCheckStatusUpdate() {
+        this.checkStatusService.response$
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((checkStatusResponse) => {
+            if (!(checkStatusResponse === null || checkStatusResponse === void 0 ? void 0 : checkStatusResponse.status))
+                return;
+            if (checkStatusResponse.status === StatusEnum.done) {
+                this.statusService.request();
+                this.websocketStatusService.closeWebSocket();
+                return;
+            }
+            if (checkStatusResponse.final === false) {
+                this.websocketStatusService.startReinsuranceCheckTimeout();
+                return;
+            }
+        });
+    }
+    subscribeWebsocketEvent() {
+        this.websocketStatusService.needCheckStatus$
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(() => this.checkStatusService.request());
+        this.websocketStatusService.statusChanged$
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(() => this.statusService.request());
+    }
+    openWebsocket(statusSettings) {
+        void this.websocketStatusService.checkStatusWithWebSocket(statusSettings.webSocketUrl, statusSettings.webSocketChannelName, statusSettings.webSocketClientType);
+        this.websocketOpenedSubject.next(statusSettings);
+    }
+}
+ListenStatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ListenStatusService, deps: [{ token: StatusRequestService }, { token: CheckStatusService }, { token: WebsocketStatusService }], target: i0.ɵɵFactoryTarget.Injectable });
+ListenStatusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ListenStatusService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ListenStatusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: StatusRequestService }, { type: CheckStatusService }, { type: WebsocketStatusService }]; } });
+
+class ShowFieldsAction {
+    constructor(submitResponse) {
+        this.type = 'show_fields';
+        this.data = {
+            fields: [],
+            errors: [],
+            messages: [],
+            order: {},
+        };
+        this.data.fields = submitResponse.fields;
+        this.data.errors = submitResponse.errors;
+        this.data.messages = submitResponse.messages;
+        this.data.order = submitResponse.summary;
+    }
+}
+
+const showFieldsActionFactoryToken = new InjectionToken('ShowFieldsAction');
+const showFieldsActionFactoryProvider = {
+    provide: showFieldsActionFactoryToken,
+    useValue: {
+        factory: (...args) => new ShowFieldsAction(...args),
+        type: 'show_fields',
+    },
+};
+
+class CheckStatusAction {
+    constructor(submitResponse) {
+        var _a, _b, _c, _d, _e, _f;
+        this.type = 'check_status';
+        const status = submitResponse.parameters.status;
+        this.data = {
+            invoice: status === null || status === void 0 ? void 0 : status.invoice,
+            signature: (_a = submitResponse.parameters.form.signature) === null || _a === void 0 ? void 0 : _a.value,
+            locale: (_b = submitResponse.parameters.form.locale) === null || _b === void 0 ? void 0 : _b.value,
+            testPs: (_c = submitResponse.parameters.form.testPs) === null || _c === void 0 ? void 0 : _c.value,
+            testXsolla: (_d = submitResponse.parameters.form.testXsolla) === null || _d === void 0 ? void 0 : _d.value,
+            testProject: (_e = submitResponse.parameters.form.testProject) === null || _e === void 0 ? void 0 : _e.value,
+            userReturnStatus: (_f = submitResponse.parameters.form.userReturnStatus) === null || _f === void 0 ? void 0 : _f.value,
+        };
+    }
+}
+
+const checkStatusActionFactoryToken = new InjectionToken('CheckStatusAction');
+const checkStatusActionFactoryProvider = {
+    provide: checkStatusActionFactoryToken,
+    useValue: {
+        factory: (...args) => new CheckStatusAction(...args),
+        type: 'check_status',
+    },
+};
+
+const statusUpdatedActionFactoryToken = new InjectionToken('StatusUpdatedAction');
+const statusUpdatedActionFactoryProvider = {
+    provide: statusUpdatedActionFactoryToken,
+    useValue: {
+        factory: (...args) => new StatusUpdatedAction(...args),
+        type: 'status_updated',
+    },
+};
+
+const nextActionsToken = new InjectionToken('Action');
+const nextActions = [
+    showFieldsActionFactoryProvider,
+    checkStatusActionFactoryProvider,
+    statusUpdatedActionFactoryProvider,
+];
+
+const actionTypeCommandMap = {
+    [XpsCommand.check]: 'show_fields',
+    [XpsCommand.status]: 'check_status',
+};
+
+class NextActionService {
+    get flowUpdates$() {
+        return this.flowUpdatesSubject.asObservable();
+    }
+    constructor(nextActionTokens, injector) {
+        this.nextActionTokens = nextActionTokens;
+        this.injector = injector;
+        this.flowUpdatesSubject = new Subject();
+        this.nextActionsMap = new Map();
+        this.fillNextActionsMap();
+    }
+    getNextAction(submitResponse) {
+        if (!submitResponse.currentCommand) {
+            return null;
+        }
+        const nextActionFactory = this.findNextAction(submitResponse.currentCommand);
+        if (nextActionFactory) {
+            return nextActionFactory(submitResponse);
+        }
+        throw new Error('Next action is undefined.');
+    }
+    emitFlowUpdates(action) {
+        this.flowUpdatesSubject.next(action);
+    }
+    fillNextActionsMap() {
+        this.nextActionTokens.forEach((nextAction) => {
+            const item = this.injector.get(nextAction.provide);
+            this.nextActionsMap.set(item.type, item.factory);
+        });
+    }
+    findNextAction(command) {
+        const actionType = actionTypeCommandMap[command];
+        if (!actionType) {
+            return;
+        }
+        return this.nextActionsMap.get(actionType);
+    }
+}
+NextActionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, deps: [{ token: nextActionsToken }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+NextActionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [nextActionsToken]
+                    }] }, { type: i0.Injector }];
+    } });
+
+class StatusService {
+    constructor(statusRequestService, listenStatusService, nextActionService) {
+        this.statusRequestService = statusRequestService;
+        this.listenStatusService = listenStatusService;
+        this.nextActionService = nextActionService;
+    }
+    getStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.statusRequestService.setRequestParams(params);
+            this.startWaitingStatusUpdates(params.invoice);
+            this.statusRequestService.request();
+            const statusResponse = yield firstValueFrom(this.listenStatusService.statusUpdated$);
+            return statusResponse.statusResponse.status;
+        });
+    }
+    startWaitingStatusUpdates(invoice) {
+        this.listenStatusService.listen(invoice);
+        this.listenStatusService.statusUpdated$
+            .pipe(skip(1))
+            .subscribe(({ statusResponse }) => {
+            this.nextActionService.emitFlowUpdates(new StatusUpdatedAction(statusResponse));
+        });
+    }
+}
+StatusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, deps: [{ token: StatusRequestService }, { token: ListenStatusService }, { token: NextActionService }], target: i0.ɵɵFactoryTarget.Injectable });
+StatusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: StatusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: StatusRequestService }, { type: ListenStatusService }, { type: NextActionService }]; } });
+
+class PaymentService {
+    constructor(initializeService, submitService, syncService, formService, statusService, nextActionService) {
+        this.initializeService = initializeService;
+        this.submitService = submitService;
+        this.syncService = syncService;
+        this.formService = formService;
+        this.statusService = statusService;
+        this.nextActionService = nextActionService;
+        this.form = null;
+        this.data = null;
+        this.fields = [];
+    }
+    initialize(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.config = config;
+            this.data = yield this.initializeService.request(config);
+            this.fields = this.getFields();
+            this.form = this.formService.createForm(this.fields);
+            this.syncService.setup(this.form, this.fields);
+            return this.fields;
+        });
+    }
+    submit(fields, form) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const submitResponse = yield this.submitService.request(fields, form);
+            return this.nextActionService.getNextAction(submitResponse);
+        });
+    }
+    getFields() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.paymentForm) === null || _b === void 0 ? void 0 : _b.fields) !== null && _c !== void 0 ? _c : [];
+    }
+    validate(field) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.syncService.validate(field);
+        });
+    }
+    runThreeDs() {
+        throw new Error('Method not implemented.');
+    }
+    getFinanceDetails() {
+        throw new Error('Method not implemented.');
+    }
+    getStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.statusService.getStatus(Object.assign(Object.assign({}, params), { pid: this.config.paymentMethodId }));
+        });
+    }
+    changeFieldValue(name, value) {
+        var _a;
+        const formControl = (_a = this.form) === null || _a === void 0 ? void 0 : _a.get(name);
+        formControl === null || formControl === void 0 ? void 0 : formControl.setValue(value);
+    }
+}
+PaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, deps: [{ token: InitializeService }, { token: SubmitService }, { token: SyncService }, { token: FormService }, { token: StatusService }, { token: NextActionService }], target: i0.ɵɵFactoryTarget.Injectable });
+PaymentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: InitializeService }, { type: SubmitService }, { type: SyncService }, { type: FormService }, { type: StatusService }, { type: NextActionService }]; } });
+
 class RefundPolicyService {
     constructor(settingsService) {
         this.settingsService = settingsService;
@@ -529,88 +2658,17 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                 }]
         }], ctorParameters: function () { return [{ type: SettingsService }, { type: RefundPolicyService }, { type: SecureConnectionService }, { type: DisclaimerService }]; } });
 
-class InitializeService {
-    constructor(secureApi, settingsService, countryService) {
-        this.secureApi = secureApi;
-        this.settingsService = settingsService;
-        this.countryService = countryService;
-        this.apiRoute = 'directpayment';
-    }
-    request(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const requestParams = {
-                access_token: this.settingsService.token,
-                pid: String(config.paymentMethodId),
-                country: this.countryService.getCountry(),
-                returnUrl: config.returnUrl,
-            };
-            return lastValueFrom(this.secureApi.post(this.apiRoute, new URLSearchParams(Object.assign({}, requestParams)), {
-                headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
-                responseType: 'json',
-            })).catch((error) => {
-                throw new ResponseError(error.message);
-            });
-        });
-    }
-}
-InitializeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, deps: [{ token: SecureApiClient }, { token: SettingsService }, { token: CountryService }], target: i0.ɵɵFactoryTarget.Injectable });
-InitializeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: InitializeService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: SecureApiClient }, { type: SettingsService }, { type: CountryService }]; } });
-
-class PaymentService {
-    constructor(initializeService) {
-        this.initializeService = initializeService;
-        this.data = null;
-    }
-    initialize(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.data = yield this.initializeService.request(config);
-            return this.data;
-        });
-    }
-    submit() {
-        throw new Error('Method not implemented.');
-    }
-    getFields() {
-        throw new Error('Method not implemented.');
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    validate(field) {
-        throw new Error('Method not implemented.');
-    }
-    runThreeDs() {
-        throw new Error('Method not implemented.');
-    }
-    getFinanceDetails() {
-        throw new Error('Method not implemented.');
-    }
-    getStatus() {
-        throw new Error('Method not implemented.');
-    }
-}
-PaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, deps: [{ token: InitializeService }], target: i0.ɵɵFactoryTarget.Injectable });
-PaymentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: InitializeService }]; } });
-
 class CoreLibraryService {
-    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, legalService, paymentService) {
+    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, paymentService, deviceFingerPrintService, legalService, nextActionService) {
         this.settingsService = settingsService;
         this.countryService = countryService;
         this.paymentMethodsService = paymentMethodsService;
         this.savedMethodsService = savedMethodsService;
         this.userBalanceService = userBalanceService;
-        this.legalService = legalService;
         this.paymentService = paymentService;
+        this.deviceFingerPrintService = deviceFingerPrintService;
+        this.legalService = legalService;
+        this.nextActionService = nextActionService;
         this.paymentMethods = {
             getList: () => __awaiter(this, void 0, void 0, function* () { return this.paymentMethodsService.getList(); }),
             getQuickMethods: () => __awaiter(this, void 0, void 0, function* () { return this.paymentMethodsService.getQuickMethods(); }),
@@ -620,7 +2678,8 @@ class CoreLibraryService {
     }
     init(configuration) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.settingsService.init(configuration);
+            yield this.settingsService.init(configuration);
+            yield this.deviceFingerPrintService.init();
         });
     }
     setCountry(country) {
@@ -629,26 +2688,28 @@ class CoreLibraryService {
     createPayment(config) {
         return {
             initialize: () => __awaiter(this, void 0, void 0, function* () { return this.paymentService.initialize(config); }),
-            submit: () => this.paymentService.submit(),
+            submit: (fields, form) => __awaiter(this, void 0, void 0, function* () { return this.paymentService.submit(fields, form); }),
             getFields: () => this.paymentService.getFields(),
-            validate: (field) => this.paymentService.validate(field),
+            changeFieldValue: (name, value) => this.paymentService.changeFieldValue(name, value),
+            validate: (field) => __awaiter(this, void 0, void 0, function* () { return this.paymentService.validate(field); }),
             getFinanceDetails: () => this.paymentService.getFinanceDetails(),
             runThreeDs: () => this.paymentService.runThreeDs(),
-            getStatus: () => this.paymentService.getStatus(),
+            getStatus: (params) => __awaiter(this, void 0, void 0, function* () { return this.paymentService.getStatus(params); }),
+            flowUpdates$: this.nextActionService.flowUpdates$,
         };
     }
     getLegalComponentConfig() {
         return this.legalService.getLegalComponentConfig();
     }
 }
-CoreLibraryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, deps: [{ token: SettingsService }, { token: CountryService }, { token: PaymentMethodsService }, { token: SavedMethodsService }, { token: UserBalanceService }, { token: LegalService }, { token: PaymentService }], target: i0.ɵɵFactoryTarget.Injectable });
+CoreLibraryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, deps: [{ token: SettingsService }, { token: CountryService }, { token: PaymentMethodsService }, { token: SavedMethodsService }, { token: UserBalanceService }, { token: PaymentService }, { token: DeviceFingerPrintService }, { token: LegalService }, { token: NextActionService }], target: i0.ɵɵFactoryTarget.Injectable });
 CoreLibraryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: SettingsService }, { type: CountryService }, { type: PaymentMethodsService }, { type: SavedMethodsService }, { type: UserBalanceService }, { type: LegalService }, { type: PaymentService }]; } });
+        }], ctorParameters: function () { return [{ type: SettingsService }, { type: CountryService }, { type: PaymentMethodsService }, { type: SavedMethodsService }, { type: UserBalanceService }, { type: PaymentService }, { type: DeviceFingerPrintService }, { type: LegalService }, { type: NextActionService }]; } });
 
 class HttpError extends AppError {
     constructor(error, req) {
@@ -703,10 +2764,35 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1$1.Router }]; } });
 
+class FormModule {
+}
+FormModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: FormModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FormModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: FormModule, imports: [ReactiveFormsModule] });
+FormModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: FormModule, providers: [
+        FormService,
+        ControlConfigService,
+        ZipConverter,
+        EmailConverter,
+        { provide: convertersMapToken, useValue: convertersMap },
+    ], imports: [ReactiveFormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: FormModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ReactiveFormsModule],
+                    providers: [
+                        FormService,
+                        ControlConfigService,
+                        ZipConverter,
+                        EmailConverter,
+                        { provide: convertersMapToken, useValue: convertersMap },
+                    ],
+                }]
+        }] });
+
 class CoreLibraryModule {
 }
 CoreLibraryModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-CoreLibraryModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, imports: [HttpClientModule] });
+CoreLibraryModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, imports: [HttpClientModule, FormModule] });
 CoreLibraryModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, providers: [
         {
             provide: HTTP_INTERCEPTORS,
@@ -717,11 +2803,25 @@ CoreLibraryModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", versi
         paymentMethodsResponseFactoryProvider,
         savedMethodsResponseFactoryProvider,
         userBalanceResponseFactoryProvider,
-    ], imports: [HttpClientModule] });
+        initializeResponseFactoryProvider,
+        submitRequestFactoryProvider,
+        submitResponseFactoryProvider,
+        syncRequestFactoryProvider,
+        syncResponseFactoryProvider,
+        statusRequestFactoryProvider,
+        statusResponseFactoryProvider,
+        checkStatusRequestFactoryProvider,
+        checkStatusResponseFactoryProvider,
+        {
+            provide: nextActionsToken,
+            useValue: nextActions,
+        },
+        ...nextActions,
+    ], imports: [HttpClientModule, FormModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [HttpClientModule],
+                    imports: [HttpClientModule, FormModule],
                     providers: [
                         {
                             provide: HTTP_INTERCEPTORS,
@@ -732,6 +2832,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                         paymentMethodsResponseFactoryProvider,
                         savedMethodsResponseFactoryProvider,
                         userBalanceResponseFactoryProvider,
+                        initializeResponseFactoryProvider,
+                        submitRequestFactoryProvider,
+                        submitResponseFactoryProvider,
+                        syncRequestFactoryProvider,
+                        syncResponseFactoryProvider,
+                        statusRequestFactoryProvider,
+                        statusResponseFactoryProvider,
+                        checkStatusRequestFactoryProvider,
+                        checkStatusResponseFactoryProvider,
+                        {
+                            provide: nextActionsToken,
+                            useValue: nextActions,
+                        },
+                        ...nextActions,
                     ],
                 }]
         }] });