@xsolla/payment-client-core 0.0.2 → 0.0.3-2

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

@@ -7,397 +7,657 @@ import { HttpParams, HttpHeaders, HttpClientModule, HTTP_INTERCEPTORS } from '@a
 import { catchError } from 'rxjs/operators';
 import * as i1$1 from '@angular/router';
 
-class AppError extends Error {
-    constructor(message) {
-        super(message);
-    }
+class AppError extends Error {
+    constructor(message) {
+        super(message);
+    }
 }
 
-class EmptyUtilsResponseError extends AppError {
-    constructor() {
-        super('Utils response is empty or not requested. Check your token.');
-    }
+class EmptyUtilsResponseError extends AppError {
+    constructor() {
+        super('Utils response is empty or not requested. Check your token.');
+    }
 }
 
 const windowToken = new InjectionToken('window');
 
-const defaultApiUrl = 'https://secure.xsolla.com/paystation2/api/';
+const defaultApiUrl = 'https://secure.xsolla.com/paystation2/api/';
 const sandboxApiUrl = 'https://sandbox-secure.xsolla.com/paystation2/api/';
 
-class SecureApiClient {
-    constructor(httpClient, window) {
-        this.httpClient = httpClient;
-        this.window = window;
-        this.isSandboxMode = false;
-    }
-    setSandboxMode(isSandboxMode) {
-        this.isSandboxMode = isSandboxMode;
-    }
-    get(url, options) {
-        return this.httpClient.get(`${this.baseUrl}${url}`, options);
-    }
-    post(url, body, options) {
-        return this.httpClient.post(`${this.baseUrl}${url}`, body, options);
-    }
-    patch(url, body, options) {
-        return this.httpClient.patch(`${this.baseUrl}${url}`, body, options);
-    }
-    put(url, body, options) {
-        return this.httpClient.put(`${this.baseUrl}${url}`, body, options);
-    }
-    delete(url, options) {
-        return this.httpClient.delete(`${this.baseUrl}${url}`, options);
-    }
-    get baseUrl() {
-        let predefinedBaseUrl = null;
-        try {
-            predefinedBaseUrl = this.window.localStorage.getItem('devApiUrl');
-        }
-        catch (e) {
-            console.warn('localStorage is not available');
-        }
-        if (predefinedBaseUrl) {
-            return predefinedBaseUrl;
-        }
-        return this.isSandboxMode ? sandboxApiUrl : defaultApiUrl;
-    }
-}
-SecureApiClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureApiClient, deps: [{ token: i1.HttpClient }, { token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable });
-SecureApiClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureApiClient, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureApiClient, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () {
-        return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [windowToken]
-                    }] }];
+class SecureApiClient {
+    constructor(httpClient, window) {
+        this.httpClient = httpClient;
+        this.window = window;
+        this.isSandboxMode = false;
+    }
+    setSandboxMode(isSandboxMode) {
+        this.isSandboxMode = isSandboxMode;
+    }
+    get(url, options) {
+        return this.httpClient.get(`${this.baseUrl}${url}`, options);
+    }
+    post(url, body, options) {
+        return this.httpClient.post(`${this.baseUrl}${url}`, body, options);
+    }
+    patch(url, body, options) {
+        return this.httpClient.patch(`${this.baseUrl}${url}`, body, options);
+    }
+    put(url, body, options) {
+        return this.httpClient.put(`${this.baseUrl}${url}`, body, options);
+    }
+    delete(url, options) {
+        return this.httpClient.delete(`${this.baseUrl}${url}`, options);
+    }
+    get baseUrl() {
+        let predefinedBaseUrl = null;
+        try {
+            predefinedBaseUrl = this.window.localStorage.getItem('devApiUrl');
+        }
+        catch (e) {
+            console.warn('localStorage is not available');
+        }
+        if (predefinedBaseUrl) {
+            return predefinedBaseUrl;
+        }
+        return this.isSandboxMode ? sandboxApiUrl : defaultApiUrl;
+    }
+}
+SecureApiClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureApiClient, deps: [{ token: i1.HttpClient }, { token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable });
+SecureApiClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureApiClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureApiClient, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [windowToken]
+                    }] }];
     } });
 
-class SettingsService {
-    get project() {
-        if (!this.response) {
-            throw new EmptyUtilsResponseError();
-        }
-        return this.response.project;
-    }
-    get purchase() {
-        if (!this.response) {
-            throw new EmptyUtilsResponseError();
-        }
-        return this.response.purchase;
-    }
-    get settings() {
-        var _a, _b;
-        if (!this.response) {
-            throw new EmptyUtilsResponseError();
-        }
-        if ((_a = this.response) === null || _a === void 0 ? void 0 : _a.purchase_external_id) {
-            return Object.assign(Object.assign({}, this.response.settings), { purchase_external_id: this.response.purchase_external_id });
-        }
-        return (_b = this.response) === null || _b === void 0 ? void 0 : _b.settings;
-    }
-    get user() {
-        if (!this.response) {
-            throw new EmptyUtilsResponseError();
-        }
-        return this.response.user;
-    }
-    get utilsResponse() {
-        if (!this.response) {
-            throw new EmptyUtilsResponseError();
-        }
-        return this.response;
-    }
-    get isEmpty() {
-        return !this.response;
-    }
-    get token() {
-        return this._token;
-    }
-    get hasResponse() {
-        return !!this.response;
-    }
-    constructor(secureApi) {
-        this.secureApi = secureApi;
-        this.isInitialized = false;
-        this._token = '';
-        this.sandboxMode = false;
-    }
-    init(configuration) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!configuration.token) {
-                return Promise.reject('token is missing');
-            }
-            this._token = configuration.token;
-            this.sandboxMode = !!configuration.sandbox;
-            yield this.sendRequest(this.token);
-            this.isInitialized = true;
-        });
-    }
-    isSandboxMode() {
-        return this.sandboxMode;
-    }
-    sendRequest(token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = new HttpParams().set('access_token', token);
-            this.secureApi.setSandboxMode(this.isSandboxMode());
-            this.response = yield firstValueFrom(this.secureApi.get('utils', { params }));
-        });
-    }
-}
-SettingsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SettingsService, deps: [{ token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
-SettingsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SettingsService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SettingsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+class SettingsService {
+    get project() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response.project;
+    }
+    get purchase() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response.purchase;
+    }
+    get settings() {
+        var _a, _b;
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        if ((_a = this.response) === null || _a === void 0 ? void 0 : _a.purchase_external_id) {
+            return Object.assign(Object.assign({}, this.response.settings), { purchase_external_id: this.response.purchase_external_id });
+        }
+        return (_b = this.response) === null || _b === void 0 ? void 0 : _b.settings;
+    }
+    get user() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response.user;
+    }
+    get utilsResponse() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response;
+    }
+    get isEmpty() {
+        return !this.response;
+    }
+    get token() {
+        return this._token;
+    }
+    get hasResponse() {
+        return !!this.response;
+    }
+    constructor(secureApi) {
+        this.secureApi = secureApi;
+        this.isInitialized = false;
+        this._token = '';
+        this.sandboxMode = false;
+    }
+    init(configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!configuration.token) {
+                return Promise.reject('token is missing');
+            }
+            this._token = configuration.token;
+            this.sandboxMode = !!configuration.sandbox;
+            yield this.sendRequest(this.token);
+            this.isInitialized = true;
+        });
+    }
+    isSandboxMode() {
+        return this.sandboxMode;
+    }
+    sendRequest(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = new HttpParams().set('access_token', token);
+            this.secureApi.setSandboxMode(this.isSandboxMode());
+            this.response = yield firstValueFrom(this.secureApi.get('utils', { params }));
+        });
+    }
+}
+SettingsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SettingsService, deps: [{ token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
+SettingsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SettingsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
         }], ctorParameters: function () { return [{ type: SecureApiClient }]; } });
 
-class CountryService {
-    constructor(settingsService) {
-        this.settingsService = settingsService;
-        this.userDefinedCountry = null;
-    }
-    setCountry(country) {
-        this.userDefinedCountry = country;
-    }
-    getCountry() {
-        var _a;
-        return (_a = this.userDefinedCountry) !== null && _a !== void 0 ? _a : this.getTokenCountry();
-    }
-    getTokenCountry() {
-        return this.settingsService.user.country.value;
-    }
-}
-CountryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CountryService, deps: [{ token: SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
-CountryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CountryService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CountryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+class CountryService {
+    constructor(settingsService) {
+        this.settingsService = settingsService;
+        this.userDefinedCountry = null;
+    }
+    setCountry(country) {
+        this.userDefinedCountry = country;
+    }
+    getCountry() {
+        var _a;
+        return (_a = this.userDefinedCountry) !== null && _a !== void 0 ? _a : this.getTokenCountry();
+    }
+    getTokenCountry() {
+        return this.settingsService.user.country.value;
+    }
+}
+CountryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CountryService, deps: [{ token: SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+CountryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CountryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CountryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
         }], ctorParameters: function () { return [{ type: SettingsService }]; } });
 
-class ResponseError extends AppError {
-    constructor(message) {
-        super('Response failed' + (message ? `: "${message}".` : '.'));
-    }
+class ResponseError extends AppError {
+    constructor(message) {
+        super('Response failed' + (message ? `: "${message}".` : '.'));
+    }
 }
 
-var BooleanNumber;
-(function (BooleanNumber) {
-    BooleanNumber[BooleanNumber["false"] = 0] = "false";
-    BooleanNumber[BooleanNumber["true"] = 1] = "true";
+var BooleanNumber;
+(function (BooleanNumber) {
+    BooleanNumber[BooleanNumber["false"] = 0] = "false";
+    BooleanNumber[BooleanNumber["true"] = 1] = "true";
 })(BooleanNumber || (BooleanNumber = {}));
 
-class PaymentMethodsResponse {
-    constructor(paymentMethods) {
-        this.especial = paymentMethods.especial.map((method) => this.mapPaymentMethod(method));
-        this.top = paymentMethods.top.map((method) => this.mapPaymentMethod(method));
-        this.remained = paymentMethods.remained.map((method) => this.mapPaymentMethod(method));
-        this.remainedCount = {
-            total: paymentMethods.remained_count.total,
-            visible: paymentMethods.remained_count.visible,
-        };
-    }
-    mapPaymentMethod(method) {
-        return {
-            id: method.id,
-            rank: method.rank,
-            name: method.name,
-            aliases: method.aliases,
-            categories: method.cat,
-            isVisible: method.is_visible,
-            recommended: method.recommended === BooleanNumber.true,
-            enabledSaveAccount: method.enabled_save_account,
-            iconName: method.switch_icon_name,
-        };
-    }
+class PaymentMethodsResponse {
+    constructor(paymentMethods) {
+        this.especial = paymentMethods.especial.map((method) => this.mapPaymentMethod(method));
+        this.top = paymentMethods.top.map((method) => this.mapPaymentMethod(method));
+        this.remained = paymentMethods.remained.map((method) => this.mapPaymentMethod(method));
+        this.remainedCount = {
+            total: paymentMethods.remained_count.total,
+            visible: paymentMethods.remained_count.visible,
+        };
+    }
+    mapPaymentMethod(method) {
+        return {
+            id: method.id,
+            rank: method.rank,
+            name: method.name,
+            aliases: method.aliases,
+            categories: method.cat,
+            isVisible: method.is_visible,
+            recommended: method.recommended === BooleanNumber.true,
+            enabledSaveAccount: method.enabled_save_account,
+            iconName: method.switch_icon_name,
+        };
+    }
+}
+
+const paymentMethodsResponseFactoryToken = new InjectionToken('PaymentMethodsResponse');
+const paymentMethodsResponseFactoryProvider = {
+    provide: paymentMethodsResponseFactoryToken,
+    useValue: (...args) => new PaymentMethodsResponse(...args),
+};
+
+class PaymentMethodsService {
+    constructor(responseFactory, settingsService, countryService, secureApi) {
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.countryService = countryService;
+        this.secureApi = secureApi;
+        this.apiRoute = 'remained_payment_methods';
+        this.cache = new Map();
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request();
+            return response.remained;
+        });
+    }
+    getQuickMethods() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request();
+            return response.especial;
+        });
+    }
+    request() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestParams = {
+                access_token: this.settingsService.token,
+                country: this.countryService.getCountry(),
+            };
+            const cacheKey = JSON.stringify(requestParams);
+            if (!this.cache.has(cacheKey)) {
+                this.cache.set(cacheKey, 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.payment_methods)))).catch((error) => {
+                    throw new ResponseError(error.message);
+                }));
+            }
+            // @ts-expect-error the map already has the cache with key
+            return this.cache.get(cacheKey);
+        });
+    }
+}
+PaymentMethodsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentMethodsService, deps: [{ token: paymentMethodsResponseFactoryToken }, { token: SettingsService }, { token: CountryService }, { token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
+PaymentMethodsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentMethodsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentMethodsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [paymentMethodsResponseFactoryToken]
+                    }] }, { type: SettingsService }, { type: CountryService }, { type: SecureApiClient }];
+    } });
+
+class SavedMethodsResponse {
+    constructor(savedMethods) {
+        this.list = savedMethods.list.map((method) => this.mapSavedMethod(method));
+    }
+    mapSavedMethod(method) {
+        return {
+            currency: method.currency,
+            form: method.form,
+            id: method.id,
+            isSelected: method.isSelected,
+            isBabkaPay: method.is_babka_pay,
+            name: method.name,
+            pid: method.pid,
+            psName: method.psName,
+            recurrentType: method.recurrent_type,
+            replaced: method.replaced,
+            type: method.type,
+            cardExpiryDate: method.card_expiry_date,
+            iconName: method.switch_icon_name,
+            partner: method.partner,
+        };
+    }
+}
+
+const savedMethodsResponseFactoryToken = new InjectionToken('SavedMethodsResponse');
+const savedMethodsResponseFactoryProvider = {
+    provide: savedMethodsResponseFactoryToken,
+    useValue: (...args) => new SavedMethodsResponse(...args),
+};
+
+class SavedMethodsService {
+    constructor(responseFactory, settingsService, countryService, secureApi) {
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.countryService = countryService;
+        this.secureApi = secureApi;
+        this.apiRoute = 'savedmethods';
+        this.cache = new Map();
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request();
+            return response.list;
+        });
+    }
+    request() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestParams = {
+                access_token: this.settingsService.token,
+            };
+            const cacheKey = JSON.stringify(requestParams);
+            if (!this.cache.has(cacheKey)) {
+                this.cache.set(cacheKey, 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);
+                }));
+            }
+            // @ts-expect-error the map already has the cache with key
+            return this.cache.get(cacheKey);
+        });
+    }
+}
+SavedMethodsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavedMethodsService, deps: [{ token: savedMethodsResponseFactoryToken }, { token: SettingsService }, { token: CountryService }, { token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
+SavedMethodsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavedMethodsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SavedMethodsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [savedMethodsResponseFactoryToken]
+                    }] }, { type: SettingsService }, { type: CountryService }, { type: SecureApiClient }];
+    } });
+
+class UserBalanceResponse {
+    constructor(userBalance) {
+        var _a, _b;
+        this.isEnoughUserBalance = (_a = userBalance.is_enough_user_balance) !== null && _a !== void 0 ? _a : false;
+        this.isEnoughUserRecurrentBalance =
+            (_b = userBalance.is_enough_user_recurrent_balance) !== null && _b !== void 0 ? _b : false;
+    }
 }
 
-const paymentMethodsResponseFactoryToken = new InjectionToken('PaymentMethodsResponse');
-const paymentMethodsResponseFactoryProvider = {
-    provide: paymentMethodsResponseFactoryToken,
-    useValue: (...args) => new PaymentMethodsResponse(...args),
+const userBalanceResponseFactoryToken = new InjectionToken('UserBalanceResponse');
+const userBalanceResponseFactoryProvider = {
+    provide: userBalanceResponseFactoryToken,
+    useValue: (...args) => new UserBalanceResponse(...args),
 };
 
-class PaymentMethodsService {
-    constructor(responseFactory, settingsService, countryService, secureApi) {
-        this.responseFactory = responseFactory;
-        this.settingsService = settingsService;
-        this.countryService = countryService;
-        this.secureApi = secureApi;
-        this.apiRoute = 'remained_payment_methods';
-        this.cache = new Map();
-    }
-    getList() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.request();
-            return response.remained;
-        });
-    }
-    getQuickMethods() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.request();
-            return response.especial;
-        });
-    }
-    request() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const requestParams = {
-                access_token: this.settingsService.token,
-                country: this.countryService.getCountry(),
-            };
-            const cacheKey = JSON.stringify(requestParams);
-            if (!this.cache.has(cacheKey)) {
-                this.cache.set(cacheKey, 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.payment_methods)))).catch((error) => {
-                    throw new ResponseError(error.message);
-                }));
-            }
-            // @ts-expect-error the map already has the cache with key
-            return this.cache.get(cacheKey);
-        });
-    }
-}
-PaymentMethodsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentMethodsService, deps: [{ token: paymentMethodsResponseFactoryToken }, { token: SettingsService }, { token: CountryService }, { token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
-PaymentMethodsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentMethodsService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentMethodsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [paymentMethodsResponseFactoryToken]
-                    }] }, { type: SettingsService }, { type: CountryService }, { type: SecureApiClient }];
+class UserBalanceService {
+    constructor(responseFactory, settingsService, secureApi) {
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.secureApi = secureApi;
+        this.apiRoute = 'balance/sufficiency';
+        this.cache = new Map();
+    }
+    getUserBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request();
+        });
+    }
+    request() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestParams = {
+                access_token: this.settingsService.token,
+            };
+            const cacheKey = JSON.stringify(requestParams);
+            if (!this.cache.has(cacheKey)) {
+                this.cache.set(cacheKey, 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);
+                }));
+            }
+            // @ts-expect-error the map already has the cache with key
+            return this.cache.get(cacheKey);
+        });
+    }
+}
+UserBalanceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: UserBalanceService, deps: [{ token: userBalanceResponseFactoryToken }, { token: SettingsService }, { token: SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable });
+UserBalanceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: UserBalanceService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: UserBalanceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [userBalanceResponseFactoryToken]
+                    }] }, { type: SettingsService }, { type: SecureApiClient }];
     } });
 
-class CoreLibraryService {
-    constructor(settingsService, countryService, paymentMethodsService) {
-        this.settingsService = settingsService;
-        this.countryService = countryService;
-        this.paymentMethodsService = paymentMethodsService;
-        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(); }),
-        };
-    }
-    init(configuration) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.settingsService.init(configuration);
-        });
-    }
-    setCountry(country) {
-        this.countryService.setCountry(country);
-    }
-}
-CoreLibraryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryService, deps: [{ token: SettingsService }, { token: CountryService }, { token: PaymentMethodsService }], 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 }]; } });
+class RefundPolicyService {
+    constructor(settingsService) {
+        this.settingsService = settingsService;
+        this.defaultVersionId = 2;
+        this.defaultUrl = 'https://xsolla.com/refund-policy-ps';
+    }
+    get url() {
+        var _a, _b, _c, _d;
+        if (!this.settingsService.token) {
+            return 'https://xsolla.com/refundpolicy/en-us';
+        }
+        const language = (_a = this.settingsService.user.local) !== null && _a !== void 0 ? _a : 'en';
+        const versionId = (_c = (_b = this.settingsService.project.refundPolicySettings) === null || _b === void 0 ? void 0 : _b.policy_version_id) !== null && _c !== void 0 ? _c : this.defaultVersionId;
+        const countryIso = (_d = this.settingsService.user.country.value) !== null && _d !== void 0 ? _d : '';
+        const projectId = this.settingsService.project.id;
+        return `${this.defaultUrl}?policy_version_id=${versionId}&language=${language}&country=${countryIso}&project_id=${projectId}`;
+    }
+}
+RefundPolicyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RefundPolicyService, deps: [{ token: SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+RefundPolicyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RefundPolicyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RefundPolicyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: SettingsService }]; } });
+
+class SecureConnectionService {
+    get isWhiteLabel() {
+        var _a;
+        return !!((_a = this.settingsService.settings) === null || _a === void 0 ? void 0 : _a.white_label);
+    }
+    get secureConnectionUrl() {
+        this.setSecureConnectionUrl();
+        return this._secureConnectionUrl;
+    }
+    constructor(settingsService) {
+        this.settingsService = settingsService;
+        this.secureConnectionApi = 'https://verify.xsolla.com/?url=';
+    }
+    setSecureConnectionUrl() {
+        var _a;
+        const projectUrl = (_a = this.settingsService.project) === null || _a === void 0 ? void 0 : _a.projectUrl;
+        if (projectUrl) {
+            this._secureConnectionUrl = `${this.secureConnectionApi}${encodeURIComponent(projectUrl)}`;
+        }
+    }
+}
+SecureConnectionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureConnectionService, deps: [{ token: SettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+SecureConnectionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureConnectionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: SecureConnectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: SettingsService }]; } });
+
+class DisclaimerService {
+    get disclaimer() {
+        return 'disclaimer';
+    }
+}
+DisclaimerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DisclaimerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DisclaimerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DisclaimerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DisclaimerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class LegalService {
+    get isJapanUser() {
+        var _a;
+        return ((_a = this.settingsService.user) === null || _a === void 0 ? void 0 : _a.local) === 'ja';
+    }
+    constructor(settingsService, refundPolicyService, secureConnectionService, disclaimerService) {
+        this.settingsService = settingsService;
+        this.refundPolicyService = refundPolicyService;
+        this.secureConnectionService = secureConnectionService;
+        this.disclaimerService = disclaimerService;
+        this.sctlPolicyUrl = 'https://xsolla.com/sctl';
+    }
+    getLegalComponentConfig() {
+        return {
+            isJapanUser: this.isJapanUser,
+            refundPolicyUrl: this.refundPolicyService.url,
+            sctlPolicyUrl: this.sctlPolicyUrl,
+            secureConnection: {
+                secureConnectionUrl: this.secureConnectionService.secureConnectionUrl,
+                isWhiteLabel: this.secureConnectionService.isWhiteLabel,
+            },
+            disclaimer: this.disclaimerService.disclaimer
+        };
+    }
+}
+LegalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: LegalService, deps: [{ token: SettingsService }, { token: RefundPolicyService }, { token: SecureConnectionService }, { token: DisclaimerService }], target: i0.ɵɵFactoryTarget.Injectable });
+LegalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: LegalService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: LegalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: SettingsService }, { type: RefundPolicyService }, { type: SecureConnectionService }, { type: DisclaimerService }]; } });
 
-class HttpError extends AppError {
-    constructor(error, req) {
-        var _a;
-        super(error.message);
-        this.RESTRICTED_KEYS_REGEXP = new RegExp('.*(card_number|number|cvv|cvn|month|year|cardholdername|client_data|dfp|password).*', 'i');
-        this.httpErrorData = {
-            request: {
-                url: req.url,
-                method: req.method,
-                headers: req.headers,
-            },
-            response: {
-                status: error.status,
-                headers: error.headers,
-            },
-        };
-        if (req.body) {
-            this.httpErrorData.request.data = this.cleanPersonalData(req.body);
-        }
-        if (error.statusText) {
-            const errorData = error.error;
-            this.httpErrorData.response.data = {
-                statusText: error.statusText,
-                errors: (_a = errorData === null || errorData === void 0 ? void 0 : errorData.errors) !== null && _a !== void 0 ? _a : [],
-            };
-        }
-    }
-    getHttpErrorData() {
-        return this.httpErrorData;
-    }
-    cleanPersonalData(data) {
-        return Object.entries(data).reduce((acc, [key, val]) => {
-            return Object.assign(Object.assign({}, acc), { [key]: this.RESTRICTED_KEYS_REGEXP.test(key) ? '***' : val });
-        }, {});
-    }
+class CoreLibraryService {
+    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, legalService) {
+        this.settingsService = settingsService;
+        this.countryService = countryService;
+        this.paymentMethodsService = paymentMethodsService;
+        this.savedMethodsService = savedMethodsService;
+        this.userBalanceService = userBalanceService;
+        this.legalService = legalService;
+        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(); }),
+            getSavedMethods: () => __awaiter(this, void 0, void 0, function* () { return this.savedMethodsService.getList(); }),
+            getUserBalance: () => __awaiter(this, void 0, void 0, function* () { return this.userBalanceService.getUserBalance(); }),
+        };
+    }
+    init(configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.settingsService.init(configuration);
+        });
+    }
+    setCountry(country) {
+        this.countryService.setCountry(country);
+    }
+    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 }], 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 }]; } });
 
-class HttpExceptionsInterceptor {
-    constructor(router) {
-        this.router = router;
-    }
-    intercept(req, next) {
-        return next.handle(req).pipe(catchError((error) => {
-            return throwError(() => new HttpError(error, req));
-        }));
-    }
-}
-HttpExceptionsInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: HttpExceptionsInterceptor, deps: [{ token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
-HttpExceptionsInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: HttpExceptionsInterceptor });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: HttpExceptionsInterceptor, decorators: [{
-            type: Injectable
+class HttpError extends AppError {
+    constructor(error, req) {
+        var _a;
+        super(error.message);
+        this.RESTRICTED_KEYS_REGEXP = new RegExp('.*(card_number|number|cvv|cvn|month|year|cardholdername|client_data|dfp|password).*', 'i');
+        this.httpErrorData = {
+            request: {
+                url: req.url,
+                method: req.method,
+                headers: req.headers,
+            },
+            response: {
+                status: error.status,
+                headers: error.headers,
+            },
+        };
+        if (req.body) {
+            this.httpErrorData.request.data = this.cleanPersonalData(req.body);
+        }
+        if (error.statusText) {
+            const errorData = error.error;
+            this.httpErrorData.response.data = {
+                statusText: error.statusText,
+                errors: (_a = errorData === null || errorData === void 0 ? void 0 : errorData.errors) !== null && _a !== void 0 ? _a : [],
+            };
+        }
+    }
+    getHttpErrorData() {
+        return this.httpErrorData;
+    }
+    cleanPersonalData(data) {
+        return Object.entries(data).reduce((acc, [key, val]) => {
+            return Object.assign(Object.assign({}, acc), { [key]: this.RESTRICTED_KEYS_REGEXP.test(key) ? '***' : val });
+        }, {});
+    }
+}
+
+class HttpExceptionsInterceptor {
+    constructor(router) {
+        this.router = router;
+    }
+    intercept(req, next) {
+        return next.handle(req).pipe(catchError((error) => {
+            return throwError(() => new HttpError(error, req));
+        }));
+    }
+}
+HttpExceptionsInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: HttpExceptionsInterceptor, deps: [{ token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpExceptionsInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: HttpExceptionsInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: HttpExceptionsInterceptor, decorators: [{
+            type: Injectable
         }], ctorParameters: function () { return [{ type: i1$1.Router }]; } });
 
-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.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, providers: [
-        {
-            provide: HTTP_INTERCEPTORS,
-            useClass: HttpExceptionsInterceptor,
-            multi: true,
-        },
-        { provide: windowToken, useValue: window },
-        paymentMethodsResponseFactoryProvider,
-    ], imports: [HttpClientModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [HttpClientModule],
-                    providers: [
-                        {
-                            provide: HTTP_INTERCEPTORS,
-                            useClass: HttpExceptionsInterceptor,
-                            multi: true,
-                        },
-                        { provide: windowToken, useValue: window },
-                        paymentMethodsResponseFactoryProvider,
-                    ],
-                }]
+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.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, providers: [
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: HttpExceptionsInterceptor,
+            multi: true,
+        },
+        { provide: windowToken, useValue: window },
+        paymentMethodsResponseFactoryProvider,
+        savedMethodsResponseFactoryProvider,
+        userBalanceResponseFactoryProvider,
+    ], imports: [HttpClientModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: CoreLibraryModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [HttpClientModule],
+                    providers: [
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: HttpExceptionsInterceptor,
+                            multi: true,
+                        },
+                        { provide: windowToken, useValue: window },
+                        paymentMethodsResponseFactoryProvider,
+                        savedMethodsResponseFactoryProvider,
+                        userBalanceResponseFactoryProvider,
+                    ],
+                }]
         }] });
 
-/*
- * Public API Surface of core-library
+/*
+ * Public API Surface of core-library
  */
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { CoreLibraryModule, CoreLibraryService };