@xsolla/payment-client-core 0.0.4 → 0.0.5

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

@@ -3,6 +3,7 @@ import { InjectionToken, Injectable, Inject, NgModule } from '@angular/core';
 import { firstValueFrom, lastValueFrom, map, throwError } from 'rxjs';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpHeaders, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { UntypedFormGroup, Validators, UntypedFormControl, ReactiveFormsModule } from '@angular/forms';
 import { catchError } from 'rxjs/operators';
 import * as i1$1 from '@angular/router';
 
@@ -397,6 +398,994 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                     args: [userBalanceResponseFactoryToken]
                 }] }, { type: SettingsService }, { type: SecureApiClient }]; } });
 
+class InitializeResponse {
+    constructor(response) {
+        this.paymentForm = null;
+        this.paymentForm = this.extractPaymentForm(response);
+    }
+    extractPaymentForm(response) {
+        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: response.messages ?? [],
+            title: response.title,
+            summary: response.summary,
+            skipForm: response.skipForm,
+            isSavedMethodPayment: !!response.form?.saved_method_id,
+            couponCode: response.form?.couponCode?.value || '',
+            publicId: response.public_id,
+            skipCheckout: response.skipCheckout,
+            koreaNotification: response.form.korea_limits_instruction,
+            isCheckout: response.isCheckout,
+            categories: response.categories,
+            hasFatalErrors: response.textAll?.fatal,
+            userSession: response.userSession,
+            statusText: response.status?.statusData?.stateText ?? 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';
+    }
+    async request(config) {
+        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({ ...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) {
+        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 = this.fields.find((field) => field.name === FieldNames.fixInvoice)?.value;
+        this.signature = this.fields.find((field) => field.name === FieldNames.signature)?.value;
+        this.hasFatalErrors = parameters.textAll?.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/';
+    }
+    async init() {
+        if (!this.settingsService.isInitialized) {
+            return;
+        }
+        this.fingerprintJs = await this.loadFingerprintJs();
+        this.hash = await this.buildHash();
+        this.antifraudFingerprintLibrary =
+            await this.loadAntifraudFingerprintLibrary();
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getHash() {
+        return this.hash;
+    }
+    async loadFingerprintJs() {
+        const { default: library, murmurX64Hash128: getHash } = await import('@fingerprintjs/fingerprintjs');
+        return { library, getHash };
+    }
+    async loadAntifraudFingerprintLibrary() {
+        const library = await import('@xsolla/antifraud-fingerprint');
+        return library.default;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async makeAntifraudFingerprint() {
+        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.
+     **/
+    async buildHash() {
+        const fingerPrintData = await this.generate();
+        const hash = await 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) {
+        return {
+            user_agent: navigator.userAgent,
+            language: components.languages.value?.shift()?.shift() ?? '',
+            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: components.plugins.value?.map((plugin) => plugin.name) ?? [],
+            canvas: components.canvas.value?.text,
+            webgl: components.canvas.value?.text,
+            webgl_vendor: components.vendor.value,
+            has_lied_resolution: this.getHasLiedResolution(),
+            touch_support: Object.values(components.touchSupport.value ?? {}),
+            js_fonts: components.fonts.value,
+        };
+    }
+    /**
+     * Получаем данные dfp с помощью FingerprintJS, мапим необходимые поля, добавляем хэш
+     **/
+    async generate() {
+        const { library, getHash } = this.fingerprintJs;
+        const fingerprint = await library.load();
+        const commonFingerPrintData = await fingerprint.get();
+        const fingerPrintData = this.getComponents(commonFingerPrintData.components);
+        fingerPrintData.hash = getHash(JSON.stringify(fingerPrintData));
+        return fingerPrintData;
+    }
+    /**
+     * Отправка dfp на сервер, в ответ получаем dfp_hash
+     **/
+    async send(fingerPrintData) {
+        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(async (hash) => {
+            const fingerprint = await this.makeAntifraudFingerprint();
+            if (!fingerprint) {
+                return null;
+            }
+            await fingerprint
+                ?.dispatch(hash['200'])
+                .catch((err) => console.log(err));
+            const afsHash = await fingerprint.hash();
+            return { '301': afsHash, ...hash };
+        })
+            .catch((error) => {
+            const response = error.getHttpErrorData().response;
+            throw new TerminalError(response.data?.errors[0]?.message ?? '', response.data?.errors[0]?.support_code ?? '');
+        });
+    }
+}
+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({
+            ...fieldsValues,
+            change_element: parameters.changedField.name,
+        });
+    }
+    getFieldsValues(changedField, fields, form) {
+        const fieldsMap = this.getFieldsMap(fields);
+        return changedField?.javascript?.change.params.reduce((xpsParams, fieldName) => {
+            const formControl = form.get(fieldName);
+            const field = fieldsMap.get(fieldName);
+            if (formControl || field) {
+                xpsParams[fieldName] = formControl?.value ?? 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) {
+        const fieldError = response?.errors?.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 = [];
+    }
+    async validate(field) {
+        if (!this.isReadyField(field)) {
+            return Promise.resolve(null);
+        }
+        const control = this.form.get(field.name);
+        const value = 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) => {
+            return response.rewritableError ?? null;
+        });
+    }
+    async request(field) {
+        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) {
+        const isSyncEnabled = !!field.javascript?.change;
+        const isExistsInForm = !!this.form?.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 = { ...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?.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 async () => 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 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',
+    },
+};
+
+const nextActionsToken = new InjectionToken('Action');
+const nextActions = [showFieldsActionFactoryProvider];
+
+const actionTypeCommandMap = {
+    [XpsCommand.check]: 'show_fields',
+};
+
+class NextActionService {
+    constructor(nextActionTokens, injector) {
+        this.nextActionTokens = nextActionTokens;
+        this.injector = injector;
+        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.');
+    }
+    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 PaymentService {
+    constructor(initializeService, submitService, syncService, formService, nextActionService) {
+        this.initializeService = initializeService;
+        this.submitService = submitService;
+        this.syncService = syncService;
+        this.formService = formService;
+        this.nextActionService = nextActionService;
+        this.form = null;
+        this.data = null;
+        this.fields = [];
+    }
+    async initialize(config) {
+        this.data = await 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;
+    }
+    async submit(fields, form) {
+        const submitResponse = await this.submitService.request(fields, form);
+        return this.nextActionService.getNextAction(submitResponse);
+    }
+    getFields() {
+        return this.data?.paymentForm?.fields ?? [];
+    }
+    async validate(field) {
+        return this.syncService.validate(field);
+    }
+    runThreeDs() {
+        throw new Error('Method not implemented.');
+    }
+    getFinanceDetails() {
+        throw new Error('Method not implemented.');
+    }
+    getStatus() {
+        throw new Error('Method not implemented.');
+    }
+    changeFieldValue(name, value) {
+        const formControl = this.form?.get(name);
+        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: 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: NextActionService }]; } });
+
 class RefundPolicyService {
     constructor(settingsService) {
         this.settingsService = settingsService;
@@ -499,84 +1488,16 @@ 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';
-    }
-    async request(config) {
-        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({ ...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;
-    }
-    async initialize(config) {
-        this.data = await 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) {
         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.paymentMethods = {
             getList: async () => this.paymentMethodsService.getList(),
             getQuickMethods: async () => this.paymentMethodsService.getQuickMethods(),
@@ -585,7 +1506,8 @@ class CoreLibraryService {
         };
     }
     async init(configuration) {
-        return this.settingsService.init(configuration);
+        await this.settingsService.init(configuration);
+        await this.deviceFingerPrintService.init();
     }
     setCountry(country) {
         this.countryService.setCountry(country);
@@ -593,9 +1515,10 @@ class CoreLibraryService {
     createPayment(config) {
         return {
             initialize: async () => this.paymentService.initialize(config),
-            submit: () => this.paymentService.submit(),
+            submit: async (fields, form) => this.paymentService.submit(fields, form),
             getFields: () => this.paymentService.getFields(),
-            validate: (field) => this.paymentService.validate(field),
+            changeFieldValue: (name, value) => this.paymentService.changeFieldValue(name, value),
+            validate: async (field) => this.paymentService.validate(field),
             getFinanceDetails: () => this.paymentService.getFinanceDetails(),
             runThreeDs: () => this.paymentService.runThreeDs(),
             getStatus: () => this.paymentService.getStatus(),
@@ -605,14 +1528,14 @@ class CoreLibraryService {
         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 }], 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 }]; } });
 
 class HttpError extends AppError {
     constructor(error, req) {
@@ -669,10 +1592,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,
@@ -683,11 +1631,21 @@ CoreLibraryModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", versi
         paymentMethodsResponseFactoryProvider,
         savedMethodsResponseFactoryProvider,
         userBalanceResponseFactoryProvider,
-    ], imports: [HttpClientModule] });
+        initializeResponseFactoryProvider,
+        submitRequestFactoryProvider,
+        submitResponseFactoryProvider,
+        syncRequestFactoryProvider,
+        syncResponseFactoryProvider,
+        {
+            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,
@@ -698,6 +1656,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                         paymentMethodsResponseFactoryProvider,
                         savedMethodsResponseFactoryProvider,
                         userBalanceResponseFactoryProvider,
+                        initializeResponseFactoryProvider,
+                        submitRequestFactoryProvider,
+                        submitResponseFactoryProvider,
+                        syncRequestFactoryProvider,
+                        syncResponseFactoryProvider,
+                        {
+                            provide: nextActionsToken,
+                            useValue: nextActions,
+                        },
+                        ...nextActions,
                     ],
                 }]
         }] });