@esolve/ng-esolve-connect 0.38.1 → 0.40.0

package/fesm2015/esolve-ng-esolve-connect.mjs

@@ -1,17 +1,69 @@
+import { isPlatformBrowser, CommonModule, IMAGE_LOADER } from '@angular/common';
+import * as i1$1 from '@angular/common/http';
+import { HttpErrorResponse, HttpParams, HttpHeaders, HTTP_INTERCEPTORS, HttpClientModule } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { InjectionToken, PLATFORM_ID, Injectable, Inject, Optional, NgModule } from '@angular/core';
-import { isPlatformBrowser, CommonModule } from '@angular/common';
-import * as i1$2 from '@angular/common/http';
-import { HTTP_INTERCEPTORS, HttpClientModule, HttpErrorResponse, HttpParams, HttpHeaders } from '@angular/common/http';
-import * as i1 from 'ngx-cookie-service';
-import { CookieService } from 'ngx-cookie-service';
-import { BehaviorSubject, throwError, of, firstValueFrom, map as map$1, Subject, iif } from 'rxjs';
-import * as i1$1 from '@angular/platform-browser';
-import { map, catchError, tap, switchMap } from 'rxjs/operators';
+import { InjectionToken, Injectable, Inject, PLATFORM_ID, APP_INITIALIZER, NgModule, Directive, Input, HostListener } from '@angular/core';
+import * as i1 from 'ngx-cookie-service-ssr';
+import { SsrCookieService } from 'ngx-cookie-service-ssr';
 import { __awaiter } from 'tslib';
+import { BehaviorSubject, Subject, map, switchMap, timer, takeUntil, combineLatest, shareReplay, filter, distinctUntilChanged, throwError, of, firstValueFrom, iif } from 'rxjs';
+import { map as map$1, catchError, switchMap as switchMap$1, tap } from 'rxjs/operators';
+import { fromUnixTime } from 'date-fns';
+import * as i2 from '@angular/platform-browser';
 
 const ESOLVE_CONNECT_CONFIG = new InjectionToken('esolve.connect.config');
 
+class EsolveConfigService {
+    constructor(config) {
+        var _a, _b, _c, _d, _e, _f;
+        this.api_url = '';
+        this.wsid = '';
+        this.title_separator = '|';
+        this.session_storage_key = '_ng_eslv_token';
+        this.coupon_storage_key = '_ng_eslv_coupons';
+        this.device_designation = 'web';
+        if (config.api_url === '' || config.wsid === '') {
+            throw new Error('Invalid eSolve Eurus config');
+        }
+        this.api_url = config.api_url;
+        this.wsid = config.wsid;
+        this.title_prefix = (_a = config.title_prefix) !== null && _a !== void 0 ? _a : '';
+        this.title_suffix = (_b = config.title_suffix) !== null && _b !== void 0 ? _b : '';
+        this.default_seo_title = (_c = config.default_seo_title) !== null && _c !== void 0 ? _c : '';
+        this.default_seo_description = (_d = config.default_seo_description) !== null && _d !== void 0 ? _d : '';
+        this.default_seo_keywords = (_e = config.default_seo_keywords) !== null && _e !== void 0 ? _e : '';
+        this.native = (_f = config.native) !== null && _f !== void 0 ? _f : false;
+        if (config.session_storage_key) {
+            this.session_storage_key = config.session_storage_key;
+        }
+        if (config.title_separator) {
+            this.title_separator = config.title_separator;
+        }
+        if (config.coupon_storage_key) {
+            this.coupon_storage_key = config.coupon_storage_key;
+        }
+        if (this.native && config.device_designation) {
+            this.device_designation = config.device_designation;
+        }
+        this.legacy_cdn = config.legacy_cdn;
+        this.cdn = config.cdn;
+        this.error_image_path = config.error_image_path;
+    }
+}
+EsolveConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveConfigService, deps: [{ token: ESOLVE_CONNECT_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }];
+    } });
+
 /**
  * Generates a short hexadecimal hash that will be used to indicate a change in
  * state.
@@ -38,301 +90,653 @@ function esolveHexHash(...values) {
     return Math.abs(hash).toString(16);
 }
 
-class EsolveSession {
-    constructor(id = -1, location_id = 0, key = '', expiration_date) {
-        this.id = id;
-        this.location_id = location_id;
-        this.key = key;
-        this.expiration_date = expiration_date;
+class EsolveCookieService {
+    constructor(cookieService) {
+        this.cookieService = cookieService;
     }
-    get expired() {
-        const current_date = new Date();
-        return (this.expiration_date === undefined ||
-            current_date >= this.expiration_date);
+    check(name) {
+        return this.cookieService.check(name);
     }
-    get authenticated() {
-        return this.id > 0;
+    get(name) {
+        return this.cookieService.get(name);
     }
-    get valid() {
-        return (this.key !== '' &&
-            this.expiration_date !== undefined &&
-            this.id >= 0);
+    set(name, value, expires, path, domain, secure) {
+        this.cookieService.set(name, value, expires, path, domain, secure);
     }
-    updateUser(user_id) {
-        this.id = user_id;
-        this.state_hash = undefined;
+    delete(name, path, domain, secure) {
+        this.cookieService.delete(name, path, domain, secure);
     }
-    updateLocation(location_id) {
-        this.location_id = location_id;
-        this.state_hash = undefined;
+}
+EsolveCookieService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCookieService, deps: [{ token: i1.SsrCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveCookieService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCookieService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCookieService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SsrCookieService }]; } });
+
+class EsolveSessionService {
+    constructor(platformId, config, cookieService) {
+        this.platformId = platformId;
+        this.config = config;
+        this.cookieService = cookieService;
+        this.token$ = new BehaviorSubject('');
+        this.user_id$ = new BehaviorSubject(0);
+        this.location_id$ = new BehaviorSubject(0);
+        this.state_hash = '';
+        this.storage_key = '';
+        /* These are RxJS subjects used for managing the expiration of the user session. */
+        this.timer_start = new Subject();
+        this.timer_stop = new Subject();
+        this.expire = new Subject();
+        this.session_end = new Subject();
+        this.setStorageKey();
+        this._session = this.initSession();
+        this.is_browser = isPlatformBrowser(this.platformId);
+        this.getSession()
+            .pipe(map(({ token, user_id, location_id }) => {
+            return esolveHexHash(token, user_id, location_id);
+        }))
+            .subscribe((hash) => {
+            this.state_hash = hash;
+        });
+        this.timer_start
+            .pipe(switchMap((time) => {
+            return timer(time).pipe(takeUntil(this.timer_stop));
+        }))
+            .subscribe(() => {
+            // Stored time expired. Check if session is valid
+            this.session_end.next();
+        });
+        // Kill session and reset state
+        this.onExpire().subscribe(() => {
+            this.reset();
+        });
+    }
+    initSession() {
+        const session = {
+            token: this.onTokenUpdate(),
+            user_id: this.onUserIdUpdate(),
+            location_id: this.onLocationIdUpdate(),
+        };
+        return combineLatest(session).pipe(shareReplay(1));
+    }
+    isValid() {
+        return this.getToken() !== '';
+    }
+    getSession() {
+        return this._session;
+    }
+    getSessionValue() {
+        return {
+            token: this.token$.getValue(),
+            user_id: this.user_id$.getValue(),
+            location_id: this.location_id$.getValue(),
+        };
+    }
+    onSessionEnd() {
+        return this.session_end.asObservable();
+    }
+    onExpire() {
+        return this.expire.asObservable();
+    }
+    expireSession() {
+        this.expire.next();
+    }
+    getToken() {
+        return this.token$.getValue();
+    }
+    onTokenUpdate() {
+        return this.token$.asObservable().pipe(filter((token) => token !== ''), distinctUntilChanged());
+    }
+    updateToken(token) {
+        this.token$.next(token);
+    }
+    getUserId() {
+        return this.user_id$.getValue();
+    }
+    onUserIdUpdate() {
+        return this.user_id$.asObservable().pipe(distinctUntilChanged());
+    }
+    updateUserId(user_id) {
+        this.user_id$.next(user_id);
+    }
+    getLocationId() {
+        return this.location_id$.getValue();
+    }
+    onLocationIdUpdate() {
+        return this.location_id$.asObservable().pipe(distinctUntilChanged());
+    }
+    updateLocationId(location_id) {
+        this.location_id$.next(location_id);
     }
     getStateHash() {
-        if (!this.state_hash) {
-            this.state_hash = esolveHexHash(this.id, this.location_id, this.key);
-        }
         return this.state_hash;
     }
-}
-
-class EsolveCookieService {
-    constructor(ngxCookies, platformId, request, response) {
-        this.ngxCookies = ngxCookies;
-        this.platformId = platformId;
-        this.request = request;
-        this.response = response;
-        this.is_browser = isPlatformBrowser(this.platformId);
+    stopTimer() {
+        this.timer_stop.next();
     }
-    check(name) {
-        if (this.is_browser) {
-            return this.ngxCookies.check(name);
+    startTimer(time) {
+        this.timer_start.next(time);
+    }
+    getCachedSession() {
+        return this.getCache();
+    }
+    reset() {
+        this.removeCache();
+        this.timer_stop.next();
+    }
+    handleSession(session, expiry_date_unix, grace_unix) {
+        const expiry_date = fromUnixTime(expiry_date_unix);
+        const grace_expiry_date = fromUnixTime(expiry_date_unix + grace_unix);
+        this.setCache(session.token, grace_expiry_date);
+        this.updateToken(session.token);
+        this.updateUserId(session.user_id);
+        this.updateLocationId(session.location_id);
+        this.startTimer(expiry_date);
+    }
+    handleUpdateSession({ user_id, location_id, }) {
+        if (typeof user_id !== 'undefined') {
+            this.updateUserId(user_id);
         }
-        const server_cookies = this.request.headers.cookie;
-        if (!server_cookies) {
-            return false;
+        if (typeof location_id !== 'undefined') {
+            this.updateLocationId(location_id);
         }
-        name = encodeURIComponent(name);
-        const regExp = this.getCookieRegExp(name);
-        return regExp.test(server_cookies);
     }
-    get(name) {
-        var _a;
-        if (this.is_browser) {
-            return this.ngxCookies.get(name);
+    setStorageKey() {
+        if (typeof this.config.session_storage_key === 'string' &&
+            this.config.session_storage_key !== '') {
+            this.storage_key = this.config.session_storage_key;
         }
-        if (!this.check(name)) {
-            return '';
+    }
+    getCache() {
+        const data = this.cookieService.get(this.storage_key);
+        if (data !== '') {
+            return data;
         }
-        const server_cookies = (_a = this.request.headers.cookie) !== null && _a !== void 0 ? _a : '';
-        const regExp = this.getCookieRegExp(name);
-        const result = regExp.exec(server_cookies);
-        return result && result[1]
-            ? this.safeDecodeURIComponent(result[1])
-            : '';
+        if (!this.is_browser || !localStorage) {
+            return null;
+        }
+        return localStorage.getItem(this.storage_key);
     }
-    set(name, value, expires, path, domain, secure) {
-        if (this.is_browser) {
-            this.ngxCookies.set(name, value, expires, path, domain, secure);
+    setCache(data, expiration_date) {
+        this.cookieService.set(this.storage_key, data, expiration_date, '/');
+        if (!this.is_browser || !localStorage) {
             return;
         }
-        this.response.cookie(name, value, { domain, path, expires, secure });
+        localStorage.setItem(this.storage_key, data);
     }
-    delete(name, path, domain, secure) {
-        if (this.is_browser) {
-            this.ngxCookies.delete(name, path, domain, secure);
+    removeCache() {
+        this.cookieService.delete(this.storage_key, '/');
+        if (!this.is_browser || !localStorage) {
             return;
         }
-        this.response.clearCookie(name, { path, domain, secure });
+        localStorage.removeItem(this.storage_key);
     }
-    /*
-     * Following functions come from ngx-cookie-service project since they are primarily the same
-     */
-    /**
-     * Get cookie Regular Expression
-     *
-     * @param name Cookie name
-     * @returns property RegExp
-     *
-     * @link https://github.com/stevermeister/ngx-cookie-service/blob/bcb6ac203487c487fcd126896bffaa14981c709c/projects/ngx-cookie-service/src/lib/cookie.service.ts#L31
-     */
-    getCookieRegExp(name) {
-        const escapedName = name.replace(
-        // eslint-disable-next-line no-useless-escape
-        /([\[\]\{\}\(\)\|\=\;\+\?\,\.\*\^\$])/gi, '\\$1');
-        return new RegExp('(?:^' + escapedName + '|;\\s*' + escapedName + ')=(.*?)(?:;|$)', 'g');
+}
+EsolveSessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionService, deps: [{ token: PLATFORM_ID }, { token: EsolveConfigService }, { token: EsolveCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveSessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [PLATFORM_ID]
+                    }] }, { type: EsolveConfigService }, { type: EsolveCookieService }];
+    } });
+
+class EsolveResult {
+    constructor(status, code, message) {
+        this.status = status;
+        this.code = code;
+        this.message = message;
     }
+}
+
+class EsolveResponseResult {
+    constructor(response) {
+        this.success_log = [];
+        this.error_log = [];
+        this.error_log.push(...response.log.filter((log_item) => log_item.type === 'error'));
+        this.success_log.push(...response.log.filter((log_item) => log_item.type === 'success'));
+    }
+}
+
+class EsolveResponseHandlerService {
     /**
-     * Gets the unencoded version of an encoded component of a Uniform Resource Identifier (URI).
-     *
-     * @param encodedURIComponent A value representing an encoded URI component.
+     * Parse single HTTP response
      *
-     * @returns The unencoded version of an encoded component of a Uniform Resource Identifier (URI).
+     * @param http_response HTTP Response to eSolve service
+     * @param resultHandler Function to parse response to a result
      *
-     * @link https://github.com/stevermeister/ngx-cookie-service/blob/bcb6ac203487c487fcd126896bffaa14981c709c/projects/ngx-cookie-service/src/lib/cookie.service.ts#L47
+     * @returns Parsed result of response
      */
-    safeDecodeURIComponent(encodedURIComponent) {
-        try {
-            return decodeURIComponent(encodedURIComponent);
+    validateSingleHttpResponse(http_response, resultHandler) {
+        if (http_response.responses === undefined ||
+            http_response.responses.length <= 0) {
+            throw http_response;
         }
-        catch (_a) {
-            // probably it is not uri encoded. return as is
-            return encodedURIComponent;
+        const response = http_response.responses[0];
+        if (response.status.state === 'error' ||
+            response.status.state === 'none') {
+            throw response;
         }
+        return resultHandler(response);
     }
 }
-EsolveCookieService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCookieService, deps: [{ token: i1.CookieService }, { token: PLATFORM_ID }, { token: 'REQUEST', optional: true }, { token: 'RESPONSE', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-EsolveCookieService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCookieService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCookieService, decorators: [{
+EsolveResponseHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveResponseHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveResponseHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveResponseHandlerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveResponseHandlerService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: i1.CookieService }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [PLATFORM_ID]
-                    }] }, { type: undefined, decorators: [{
-                        type: Optional
-                    }, {
-                        type: Inject,
-                        args: ['REQUEST']
-                    }] }, { type: undefined, decorators: [{
-                        type: Optional
-                    }, {
-                        type: Inject,
-                        args: ['RESPONSE']
-                    }] }];
-    } });
+        }] });
 
-class EsolveSessionService {
-    get currentSession() {
-        return this._session.value;
+class EsolveHttpError extends Error {
+    constructor(type, code, message, ...params) {
+        // Pass remaining arguments (including vendor specific ones) to parent constructor
+        super(...[message, ...params]);
+        this.http_error = true;
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, EsolveHttpError);
+        }
+        this.name = 'EsolveHttpError';
+        this.type = type;
+        this.error_code = code;
     }
-    constructor(platformId, config, cookieService) {
-        this.platformId = platformId;
-        this.config = config;
-        this.cookieService = cookieService;
-        this.storage_key = 'ngEslvUserSession';
-        this.setStorageKey();
-        this._session = new BehaviorSubject(new EsolveSession());
-        this.session = this._session.asObservable();
-        this.is_browser = isPlatformBrowser(this.platformId);
+}
+
+class EsolveErrorHandlerService {
+    throwError(code, message) {
+        throw new EsolveHttpError('error', code, message);
     }
-    clearTimer() {
-        if (this.key_expiration_timer) {
-            clearTimeout(this.key_expiration_timer);
-        }
+    emitError(code, message) {
+        return throwError(() => new EsolveHttpError('error', code, message));
     }
-    getCachedSession() {
-        let json_data = this.cookieService.get(this.storage_key);
-        if (json_data === '') {
-            const local_store_data = this.getBackup();
-            if (local_store_data) {
-                json_data = local_store_data;
-            }
-        }
-        const stored_session = json_data
-            ? JSON.parse(json_data)
-            : null;
-        if (!stored_session) {
-            return null;
+    handleHttpPostError(service_type, errorRes) {
+        if (!(errorRes instanceof HttpErrorResponse) &&
+            !('service_type' in errorRes) &&
+            'id' in errorRes &&
+            'esolve_id' in errorRes &&
+            'transaction_type' in errorRes &&
+            'status' in errorRes &&
+            'log' in errorRes) {
+            return throwError(() => this.parsePostErrors(errorRes));
         }
-        const expiration_date = new Date(stored_session.expiration_date);
-        const loaded_session = new EsolveSession(stored_session.id, stored_session.location_id, stored_session.key, expiration_date);
-        return loaded_session;
-    }
-    resetSessionCache() {
-        this.cookieService.delete(this.storage_key, '/');
-        this.removeBackup();
+        return this.handleHttpError(service_type, errorRes);
     }
-    restore(expirationCallback, invalidSessionCallback) {
-        if (this.currentSession.valid) {
-            return;
+    handleHttpDeleteError(service_type, errorRes) {
+        const is_not_base = !(errorRes instanceof HttpErrorResponse) &&
+            !('service_type' in errorRes) &&
+            'id' in errorRes &&
+            'status' in errorRes &&
+            'message' in errorRes &&
+            'code' in errorRes;
+        if (is_not_base) {
+            return throwError(() => this.parseDeleteError(errorRes));
         }
-        let json_data = this.cookieService.get(this.storage_key);
-        if (json_data === '') {
-            const local_store_data = this.getBackup();
-            if (local_store_data) {
-                json_data = local_store_data;
+        return this.handleHttpError(service_type, errorRes);
+    }
+    handleHttpError(service_type, error_response) {
+        if (error_response instanceof HttpErrorResponse) {
+            if (error_response.status === 500) {
+                const server_error = error_response.error;
+                if ('service_type' in server_error &&
+                    server_error.service_type === service_type) {
+                    return throwError(() => this.parseException(server_error));
+                }
             }
         }
-        const stored_session = json_data
-            ? JSON.parse(json_data)
-            : null;
-        if (!stored_session) {
-            invalidSessionCallback();
-            return;
+        else {
+            if ('service_type' in error_response &&
+                error_response.service_type === service_type) {
+                if (error_response.type === 'exception') {
+                    return throwError(() => this.parseException(error_response));
+                }
+                else if (error_response.type === 'error') {
+                    return throwError(() => this.parseResponseError(error_response));
+                }
+            }
         }
-        const expiration_date = new Date(stored_session.expiration_date);
-        const loaded_session = new EsolveSession(stored_session.id, stored_session.location_id, stored_session.key, expiration_date);
-        if (!loaded_session.expired) {
-            this._session.next(loaded_session);
-            const expiration_duration = expiration_date.getTime() - new Date().getTime();
-            this.startTimer(expirationCallback, expiration_duration);
+        return throwError(() => error_response);
+    }
+    parseException(exception) {
+        const error = new EsolveHttpError('exception', exception.additional_data.exception_type || 'unknown', exception.message || 'Unknown exception has occurred');
+        return error;
+    }
+    parseResponseError(exception) {
+        const error = new EsolveHttpError('error', exception.code || 'unknown', exception.message || 'Unknown error has occurred');
+        return error;
+    }
+    parsePostErrors(response) {
+        let error_code = 'unknown';
+        let message = 'Unknown error has occurred';
+        if (response.status.state === 'none' && response.log.length > 0) {
+            error_code = 'no_response';
+            message = 'Response was provided';
         }
-        else {
-            expirationCallback(loaded_session);
+        else if (response.status.state === 'error') {
+            const login_error_log = response.log[0];
+            error_code = login_error_log.message_code;
+            message = login_error_log.message;
         }
+        return new EsolveHttpError('error', error_code, message);
+    }
+    parseDeleteError(result) {
+        return new EsolveHttpError('error', result.code, result.message);
     }
-    handleSession(user_id, location_id, key, expiry_time, expires, expirationCallback) {
-        const expiration_date = new Date(expiry_time * 1000);
-        const session = new EsolveSession(user_id, location_id, key, expiration_date);
-        const json_data = JSON.stringify(session);
-        this.cookieService.set(this.storage_key, json_data, expiration_date, '/');
-        this.setBackup(json_data);
-        this._session.next(session);
-        this.startTimer(expirationCallback, expires * 1000);
+}
+EsolveErrorHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveErrorHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveErrorHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveErrorHandlerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveErrorHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class EsolveSessionMetadataService {
+    constructor(config, http, errorHandler, responseHandler) {
+        this.config = config;
+        this.http = http;
+        this.errorHandler = errorHandler;
+        this.responseHandler = responseHandler;
     }
-    handleUpdateSession({ user_id, location_id }, callback) {
-        const current_session = this.currentSession;
-        if (typeof user_id !== 'undefined') {
-            current_session.updateUser(user_id);
+    set(type, metadata) {
+        return this.http
+            .post(`${this.config.api_url}/set-sessions-metadata.php`, metadata, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;',
+            },
+            responseType: 'json',
+            observe: 'body',
+            params: { type },
+        })
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveResponseResult(response))), catchError((errorRes) => {
+            return this.errorHandler.handleHttpPostError('set-sessions-metadata', errorRes);
+        }));
+    }
+    get(type) {
+        return this.http
+            .get(`${this.config.api_url}/get-sessions-metadata.php`, {
+            params: { type },
+        })
+            .pipe(map$1((response) => {
+            if (response.records === undefined ||
+                (Array.isArray(response.records) &&
+                    response.records.length === 0)) {
+                throw response;
+            }
+            return response.records;
+        }));
+    }
+    delete(type) {
+        return this.http
+            .delete(`${this.config.api_url}/delete-sessions-metadata.php`, {
+            params: { type },
+            responseType: 'json',
+            observe: 'body',
+        })
+            .pipe(map$1((http_response) => {
+            if (http_response.result === undefined ||
+                http_response.result === null ||
+                http_response.result.status !== 'success') {
+                throw http_response;
+            }
+            return new EsolveResult(http_response.result.status, http_response.result.code, http_response.result.message);
+        }), catchError((errorRes) => {
+            return this.errorHandler.handleHttpDeleteError('delete-sessions-metadata', errorRes);
+        }));
+    }
+}
+EsolveSessionMetadataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionMetadataService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveSessionMetadataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionMetadataService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionMetadataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }]; } });
+
+class EsolveAuthService {
+    constructor(config, http, session, errorHandler) {
+        this.config = config;
+        this.http = http;
+        this.session = session;
+        this.errorHandler = errorHandler;
+        this.session
+            .onSessionEnd()
+            .pipe(switchMap$1(() => this.checkAccessToken()), catchError(() => of(null)))
+            .subscribe((result) => {
+            if (result) {
+                this.session.handleSession({
+                    token: result.key,
+                    user_id: result.user_id,
+                    location_id: result.location_id,
+                }, result.expiry_time, result.grace_period);
+            }
+            else {
+                this.session.expireSession();
+            }
+        });
+        this.session.onExpire().subscribe(() => {
+            this.logout().catch(() => {
+                // Deal with error gracefully
+            });
+        });
+    }
+    getAccessToken(email, password, anonymous = false) {
+        let params = new HttpParams();
+        if (anonymous) {
+            params = params.set('anonymous', true);
         }
-        if (typeof location_id !== 'undefined') {
-            current_session.updateLocation(location_id);
+        if (email !== '') {
+            params = params.set('email', email);
         }
-        const json_data = JSON.stringify(current_session);
-        this.cookieService.set(this.storage_key, json_data, current_session.expiration_date, '/');
-        this.setBackup(json_data);
-        this._session.next(current_session);
-        if (typeof callback === 'function') {
-            callback();
+        if (password !== '') {
+            params = params.set('password', password);
         }
+        return this.http
+            .get(`${this.config.api_url}/get-access-token.php`, {
+            params,
+            headers: new HttpHeaders({
+                'Accept-Language': '*',
+            }),
+        })
+            .pipe(tap((response) => {
+            if (response.type === 'error' ||
+                response.type === 'exception') {
+                throw response;
+            }
+        }), catchError(this.handleError), tap((response) => {
+            this.handleAuthentication(response.additional_data);
+        }));
     }
-    setStorageKey() {
-        if (typeof this.config.user_session_storage_key === 'string' &&
-            this.config.user_session_storage_key !== '') {
-            this.storage_key = this.config.user_session_storage_key;
-        }
+    getAnonymousSession() {
+        return this.getAccessToken('', '', true);
     }
-    startTimer(callback, duration) {
-        if (this.is_browser) {
-            this.key_expiration_timer = setTimeout(callback, duration);
-        }
+    autoLogin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = yield this.restore();
+            try {
+                if (!result) {
+                    const response = yield firstValueFrom(this.getAnonymousSession());
+                    result = response.additional_data;
+                }
+                this.handleAuthentication(result);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
     }
-    getBackup() {
-        if (!this.is_browser) {
-            return null;
-        }
-        if (!localStorage) {
+    login(email, password) {
+        const body = {
+            login: {
+                email,
+                password,
+            },
+        };
+        return this.http
+            .post(`${this.config.api_url}/set-login.php`, body, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;',
+            },
+            responseType: 'json',
+            observe: 'body',
+        })
+            .pipe(map$1((response) => {
+            if (response.responses === undefined ||
+                response.responses.length <= 0) {
+                throw response;
+            }
+            const login_response = response.responses[0];
+            const result = response.additional_data;
+            if (login_response.status.state !== 'success' &&
+                login_response.status.state !== 'warning') {
+                throw login_response;
+            }
+            for (const response_log of login_response.log) {
+                if (response_log.type === 'success' &&
+                    response_log.message_code === 'login_success') {
+                    const user_id = +login_response.esolve_id;
+                    if (Array.isArray(result)) {
+                        throw new Error('Invalid login');
+                    }
+                    this.handleAuthentication({
+                        key: result.key,
+                        user_id: result.user_id,
+                        location_id: result.location_id,
+                        expires: result.expires,
+                        expiry_time: result.expiry_time,
+                        grace_period: result.grace_period,
+                    });
+                    return user_id;
+                }
+            }
+            throw login_response;
+        }), catchError((errorRes) => {
+            return this.errorHandler.handleHttpPostError('set-login', errorRes);
+        }));
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.session.stopTimer();
+            const response = yield firstValueFrom(this.getAccessToken('', '', true));
+            return response;
+        });
+    }
+    validateCachedTokens() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let valid = false;
+            try {
+                const session = this.session.getCachedSession();
+                if (!session) {
+                    throw new Error('Invalid session');
+                }
+                const result = yield this.checkAccessToken(session);
+                if (!result.key) {
+                    throw new Error('Invalid key');
+                }
+                valid = true;
+            }
+            catch (error) {
+                this.session.reset();
+            }
+            return valid;
+        });
+    }
+    checkAccessToken(token = this.session.getToken()) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (token === '') {
+                throw new Error('Invalid Token');
+            }
+            const response = yield firstValueFrom(this.http.get(`${this.config.api_url}/get-access-token.php`, {
+                params: { key: token },
+                headers: new HttpHeaders({
+                    'Accept-Language': '*',
+                    Authorization: `Bearer ${token}`,
+                }),
+            }));
+            if (response.type === 'error' || response.type === 'exception') {
+                throw response;
+            }
+            const additional_data = response.additional_data;
+            if (!additional_data.key_okay) {
+                throw response;
+            }
+            if (additional_data.key) {
+                token = additional_data.key;
+            }
+            const result = {
+                key: token,
+                expires: +additional_data.expires,
+                expiry_time: +additional_data.expiry_time,
+                grace_period: +additional_data.grace_period,
+                location_id: +additional_data.location_id,
+                user_id: +additional_data.user_id,
+            };
+            return result;
+        });
+    }
+    restore() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const token = this.session.getCachedSession();
+                if (!token) {
+                    throw new Error('Invalid token');
+                }
+                const result = yield this.checkAccessToken(token);
+                return result;
+            }
+            catch (error) {
+                this.session.reset();
+            }
             return null;
-        }
-        return localStorage.getItem(this.storage_key);
+        });
     }
-    setBackup(data) {
-        if (!this.is_browser) {
-            return;
-        }
-        if (!localStorage) {
+    // Handlers
+    handleAuthentication(result) {
+        if (!result.key) {
             return;
         }
-        localStorage.setItem(this.storage_key, data);
+        this.session.handleSession({
+            token: result.key,
+            user_id: +result.user_id,
+            location_id: +result.location_id,
+        }, +result.expiry_time, +result.grace_period);
     }
-    removeBackup() {
-        if (!this.is_browser) {
-            return;
+    handleError(errorRes) {
+        const error = {
+            message: 'An unknown error occurred',
+            data: {},
+        };
+        if (!errorRes.type || !errorRes.service_type || !errorRes.message) {
+            return throwError(() => error);
         }
-        if (!localStorage) {
-            return;
+        if (errorRes.message.trim() !== '') {
+            error.message = errorRes.message;
         }
-        localStorage.removeItem(this.storage_key);
+        if (errorRes.additional_data) {
+            error.data = errorRes.additional_data;
+        }
+        return throwError(() => error);
     }
 }
-EsolveSessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionService, deps: [{ token: PLATFORM_ID }, { token: ESOLVE_CONNECT_CONFIG }, { token: EsolveCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
-EsolveSessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionService, decorators: [{
+EsolveAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }, { token: EsolveSessionService }, { token: EsolveErrorHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [PLATFORM_ID]
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: EsolveCookieService }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }, { type: EsolveSessionService }, { type: EsolveErrorHandlerService }]; } });
 
 class EsolveAuthInterceptorService {
     constructor(config, session) {
@@ -345,12 +749,11 @@ class EsolveAuthInterceptorService {
             const modified_url = req.url;
             let params = req.params;
             let headers = req.headers;
-            const session = this.session.currentSession;
-            if (session.valid) {
+            if (this.session.isValid()) {
                 if (service_identifier !== 'get-access-token.php') {
-                    params = params.set('key', session.key);
+                    headers = headers.set('Authorization', `Bearer ${this.session.getToken()}`);
                 }
-                const state_hash = session.getStateHash();
+                const state_hash = this.session.getStateHash();
                 headers = headers.set('X-Esolve-State-Hash', state_hash);
             }
             params = params.set('ws_id', this.config.wsid);
@@ -367,48 +770,175 @@ class EsolveAuthInterceptorService {
         return next.handle(req);
     }
 }
-EsolveAuthInterceptorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthInterceptorService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: EsolveSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveAuthInterceptorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthInterceptorService, deps: [{ token: EsolveConfigService }, { token: EsolveSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveAuthInterceptorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthInterceptorService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthInterceptorService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: EsolveSessionService }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: EsolveSessionService }]; } });
+
+const ESOLVE_EURUS_AUTO_LOGIN = {
+    provide: APP_INITIALIZER,
+    multi: true,
+    deps: [EsolveAuthService],
+    useFactory: (auth) => () => __awaiter(void 0, void 0, void 0, function* () {
+        yield auth.autoLogin();
+        return true;
+    }),
+};
 
 class NgEsolveConnectModule {
-    static forRoot(config) {
+    static forRoot(config, auto_login = false) {
+        const providers = [
+            {
+                provide: ESOLVE_CONNECT_CONFIG,
+                useValue: config,
+            },
+            {
+                provide: HTTP_INTERCEPTORS,
+                useClass: EsolveAuthInterceptorService,
+                multi: true,
+            },
+        ];
+        if (auto_login) {
+            providers.push(ESOLVE_EURUS_AUTO_LOGIN);
+        }
         return {
             ngModule: NgEsolveConnectModule,
-            providers: [
-                {
-                    provide: ESOLVE_CONNECT_CONFIG,
-                    useValue: config,
-                },
-                {
-                    provide: HTTP_INTERCEPTORS,
-                    useClass: EsolveAuthInterceptorService,
-                    multi: true,
-                },
-            ],
+            providers,
         };
     }
 }
 NgEsolveConnectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NgEsolveConnectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
 NgEsolveConnectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: NgEsolveConnectModule, imports: [CommonModule, HttpClientModule] });
-NgEsolveConnectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NgEsolveConnectModule, providers: [CookieService], imports: [CommonModule, HttpClientModule] });
+NgEsolveConnectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NgEsolveConnectModule, providers: [SsrCookieService], imports: [CommonModule, HttpClientModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NgEsolveConnectModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [],
                     imports: [CommonModule, HttpClientModule],
-                    providers: [CookieService],
+                    providers: [SsrCookieService],
                     exports: [],
                 }]
         }] });
 
+function isEsolveCdnPath(path) {
+    const cdn_regex = /^\/?images\/(?:stock|media|news|assets|banners|documents|manufacturers|ranges|categories|subcategories|tags)\//;
+    return cdn_regex.test(path);
+}
+
+function isLegacyEsolveCdnPath(path) {
+    const cdn_regex = /^\/?images\/(?:media|news|assets|banners|documents|manufacturers|ranges|categories|subcategories|tags)\//;
+    return cdn_regex.test(path);
+}
+
+function isAbsoluteUrl(src) {
+    return /^https?:\/\//.test(src);
+}
+function normalizePath(path) {
+    return path.endsWith('/') ? path.slice(0, -1) : path;
+}
+function normalizeSrc(src) {
+    return src.startsWith('/') ? src.slice(1) : src;
+}
+function processEsolveImageSrc(src, cdn_url = '', legacy_cdn_url = '') {
+    if (isAbsoluteUrl(src)) {
+        return src;
+    }
+    cdn_url = normalizePath(cdn_url);
+    legacy_cdn_url = normalizePath(legacy_cdn_url);
+    if (cdn_url === '') {
+        return src;
+    }
+    if (legacy_cdn_url === '') {
+        legacy_cdn_url = cdn_url;
+    }
+    if (!isEsolveCdnPath(src)) {
+        return src;
+    }
+    src = normalizeSrc(src);
+    if (isLegacyEsolveCdnPath(src)) {
+        return `${legacy_cdn_url}/${src}`;
+    }
+    return `${cdn_url}/${src}`;
+}
+
+const ESOLVE_IMAGE_LOADER_PROVIDER = {
+    provide: IMAGE_LOADER,
+    useFactory: (esolveConfig) => {
+        return (config) => {
+            return processEsolveImageSrc(config.src, esolveConfig.cdn, esolveConfig.legacy_cdn);
+        };
+    },
+    deps: [EsolveConfigService],
+};
+
+/**
+ * An alternative to optimised images to load a new image
+ */
+class EsolveCdnSrcDirective {
+    constructor(el, config) {
+        this.el = el;
+        this.config = config;
+        this.src = '';
+        this.no_image = false;
+        this.error_image_path = '/assets/no_image.jpg';
+        if (this.config.error_image_path) {
+            this.error_image_path = this.config.error_image_path;
+        }
+        if (this.isImage(this.el.nativeElement)) {
+            this.el.nativeElement.loading = 'lazy';
+        }
+    }
+    ngOnChanges() {
+        this.init();
+    }
+    onError() {
+        this.setErrorImage();
+    }
+    init() {
+        this.no_image = false;
+        if (this.src === '') {
+            this.setErrorImage();
+            return;
+        }
+        const image_src = processEsolveImageSrc(this.src, this.config.cdn, this.config.legacy_cdn);
+        this.setSrc(image_src);
+    }
+    setSrc(src) {
+        if (this.isImage(this.el.nativeElement)) {
+            this.el.nativeElement.src = src;
+        }
+        else {
+            this.el.nativeElement.srcset = src;
+        }
+    }
+    setErrorImage() {
+        if (this.no_image) {
+            return;
+        }
+        this.setSrc(this.error_image_path);
+        this.no_image = true;
+    }
+    isImage(el) {
+        return 'loading' in this.el.nativeElement;
+    }
+}
+EsolveCdnSrcDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCdnSrcDirective, deps: [{ token: i0.ElementRef }, { token: EsolveConfigService }], target: i0.ɵɵFactoryTarget.Directive });
+EsolveCdnSrcDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.7", type: EsolveCdnSrcDirective, isStandalone: true, selector: "[eslvCdnSrc]", inputs: { src: ["eslvCdnSrc", "src"] }, host: { listeners: { "error": "onError()" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCdnSrcDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[eslvCdnSrc]',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: EsolveConfigService }]; }, propDecorators: { src: [{
+                type: Input,
+                args: ['eslvCdnSrc']
+            }], onError: [{
+                type: HostListener,
+                args: ['error']
+            }] } });
+
 class EsolveList {
     constructor(items = [], page = 0, rows = 0, total = 0) {
         this.items = items;
@@ -418,14 +948,6 @@ class EsolveList {
     }
 }
 
-class EsolveResult {
-    constructor(status, code, message) {
-        this.status = status;
-        this.code = code;
-        this.message = message;
-    }
-}
-
 class EsolveMultipleSelectFilter {
     constructor(field, options) {
         this.field = field;
@@ -609,166 +1131,22 @@ function convertToHttpParams(filters, http_params) {
         }
         return http_params;
     }
-    let params = {};
-    for (const filter of filters) {
-        params = Object.assign(Object.assign({}, params), filter.toHttpParams());
-    }
-    return params;
-}
-
-var esolveFilterFactory = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    convertToHttpParams: convertToHttpParams,
-    covertFromObj: covertFromObj,
-    createMultipleSelectWithValue: createMultipleSelectWithValue,
-    createRangeWithValue: createRangeWithValue,
-    createSingleSelectWithValue: createSingleSelectWithValue,
-    createToggleSelectWithValue: createToggleSelectWithValue
-});
-
-class EsolveResponseResult {
-    constructor(response) {
-        this.success_log = [];
-        this.error_log = [];
-        this.error_log.push(...response.log.filter((log_item) => log_item.type === 'error'));
-        this.success_log.push(...response.log.filter((log_item) => log_item.type === 'success'));
-    }
-}
-
-class EsolveResponseHandlerService {
-    /**
-     * Parse single HTTP response
-     *
-     * @param http_response HTTP Response to eSolve service
-     * @param resultHandler Function to parse response to a result
-     *
-     * @returns Parsed result of response
-     */
-    validateSingleHttpResponse(http_response, resultHandler) {
-        if (http_response.responses === undefined ||
-            http_response.responses.length <= 0) {
-            throw http_response;
-        }
-        const response = http_response.responses[0];
-        if (response.status.state === 'error' ||
-            response.status.state === 'none') {
-            throw response;
-        }
-        return resultHandler(response);
-    }
-}
-EsolveResponseHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveResponseHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-EsolveResponseHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveResponseHandlerService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveResponseHandlerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class EsolveHttpError extends Error {
-    constructor(type, code, message, ...params) {
-        // Pass remaining arguments (including vendor specific ones) to parent constructor
-        super(...[message, ...params]);
-        this.http_error = true;
-        // Maintains proper stack trace for where our error was thrown (only available on V8)
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, EsolveHttpError);
-        }
-        this.name = 'EsolveHttpError';
-        this.type = type;
-        this.error_code = code;
-    }
-}
-
-class EsolveErrorHandlerService {
-    throwError(code, message) {
-        throw new EsolveHttpError('error', code, message);
-    }
-    emitError(code, message) {
-        return throwError(() => new EsolveHttpError('error', code, message));
-    }
-    handleHttpPostError(service_type, errorRes) {
-        if (!(errorRes instanceof HttpErrorResponse) &&
-            !('service_type' in errorRes) &&
-            'id' in errorRes &&
-            'esolve_id' in errorRes &&
-            'transaction_type' in errorRes &&
-            'status' in errorRes &&
-            'log' in errorRes) {
-            return throwError(() => this.parsePostErrors(errorRes));
-        }
-        return this.handleHttpError(service_type, errorRes);
-    }
-    handleHttpDeleteError(service_type, errorRes) {
-        const is_not_base = !(errorRes instanceof HttpErrorResponse) &&
-            !('service_type' in errorRes) &&
-            'id' in errorRes &&
-            'status' in errorRes &&
-            'message' in errorRes &&
-            'code' in errorRes;
-        if (is_not_base) {
-            return throwError(() => this.parseDeleteError(errorRes));
-        }
-        return this.handleHttpError(service_type, errorRes);
-    }
-    handleHttpError(service_type, error_response) {
-        if (error_response instanceof HttpErrorResponse) {
-            if (error_response.status === 500) {
-                const server_error = error_response.error;
-                if ('service_type' in server_error &&
-                    server_error.service_type === service_type) {
-                    return throwError(() => this.parseException(server_error));
-                }
-            }
-        }
-        else {
-            if ('service_type' in error_response &&
-                error_response.service_type === service_type) {
-                if (error_response.type === 'exception') {
-                    return throwError(() => this.parseException(error_response));
-                }
-                else if (error_response.type === 'error') {
-                    return throwError(() => this.parseResponseError(error_response));
-                }
-            }
-        }
-        return throwError(() => error_response);
-    }
-    parseException(exception) {
-        const error = new EsolveHttpError('exception', exception.additional_data.exception_type || 'unknown', exception.message || 'Unknown exception has occurred');
-        return error;
-    }
-    parseResponseError(exception) {
-        const error = new EsolveHttpError('error', exception.code || 'unknown', exception.message || 'Unknown error has occurred');
-        return error;
-    }
-    parsePostErrors(response) {
-        let error_code = 'unknown';
-        let message = 'Unknown error has occurred';
-        if (response.status.state === 'none' && response.log.length > 0) {
-            error_code = 'no_response';
-            message = 'Response was provided';
-        }
-        else if (response.status.state === 'error') {
-            const login_error_log = response.log[0];
-            error_code = login_error_log.message_code;
-            message = login_error_log.message;
-        }
-        return new EsolveHttpError('error', error_code, message);
-    }
-    parseDeleteError(result) {
-        return new EsolveHttpError('error', result.code, result.message);
-    }
-}
-EsolveErrorHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveErrorHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-EsolveErrorHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveErrorHandlerService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveErrorHandlerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
+    let params = {};
+    for (const filter of filters) {
+        params = Object.assign(Object.assign({}, params), filter.toHttpParams());
+    }
+    return params;
+}
+
+var esolveFilterFactory = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    convertToHttpParams: convertToHttpParams,
+    covertFromObj: covertFromObj,
+    createMultipleSelectWithValue: createMultipleSelectWithValue,
+    createRangeWithValue: createRangeWithValue,
+    createSingleSelectWithValue: createSingleSelectWithValue,
+    createToggleSelectWithValue: createToggleSelectWithValue
+});
 
 // Types
 
@@ -807,24 +1185,12 @@ class EsolveSeoService {
         this.setPageKeywordsTags(seoInfo.keywords);
     }
     init() {
-        if (typeof this.config.title_prefix !== 'undefined') {
-            this.title_prefix = this.config.title_prefix;
-        }
-        if (typeof this.config.title_suffix !== 'undefined') {
-            this.title_suffix = this.config.title_suffix;
-        }
-        if (typeof this.config.title_separator !== 'undefined') {
-            this.title_separator = this.config.title_separator;
-        }
-        if (typeof this.config.default_seo_title !== 'undefined') {
-            this.default_seo_title = this.config.default_seo_title;
-        }
-        if (typeof this.config.default_seo_description !== 'undefined') {
-            this.default_seo_description = this.config.default_seo_description;
-        }
-        if (typeof this.config.default_seo_keywords !== 'undefined') {
-            this.default_seo_keywords = this.config.default_seo_keywords;
-        }
+        this.title_prefix = this.config.title_prefix;
+        this.title_suffix = this.config.title_suffix;
+        this.title_separator = this.config.title_separator;
+        this.default_seo_title = this.config.default_seo_title;
+        this.default_seo_description = this.config.default_seo_description;
+        this.default_seo_keywords = this.config.default_seo_keywords;
     }
     setPageTitleTags(title) {
         this.title.setTitle(title);
@@ -885,19 +1251,14 @@ class EsolveSeoService {
         return pageSeo;
     }
 }
-EsolveSeoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSeoService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.Title }, { token: i1$1.Meta }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveSeoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSeoService, deps: [{ token: EsolveConfigService }, { token: i2.Title }, { token: i2.Meta }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveSeoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSeoService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSeoService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$1.Title }, { type: i1$1.Meta }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i2.Title }, { type: i2.Meta }]; } });
 
 class EsolveGeocodeAddressResult {
     constructor(street_number, street, suburb, city, province, country, postal_code) {
@@ -947,7 +1308,7 @@ class EsolveGeocoderService {
                 postal_code,
             },
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 Array.isArray(response.records)) {
                 throw response;
@@ -964,7 +1325,7 @@ class EsolveGeocoderService {
                 longitude: longitude,
             },
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 Array.isArray(response.records)) {
                 throw response;
@@ -980,7 +1341,7 @@ class EsolveGeocoderService {
         return geocode_result;
     }
 }
-EsolveGeocoderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveGeocoderService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveGeocoderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveGeocoderService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveGeocoderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveGeocoderService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveGeocoderService, decorators: [{
             type: Injectable,
@@ -991,7 +1352,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
 class EsolveLinkedAsset {
@@ -1066,7 +1427,7 @@ class EsolveCategoryTreeService {
         }
         return this.http
             .get(`${this.config.api_url}/get-tree.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -1086,7 +1447,7 @@ class EsolveCategoryTreeService {
         params = params.set('special_id', special_id);
         return this.http
             .get(`${this.config.api_url}/get-special-tree.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -1130,7 +1491,7 @@ class EsolveCategoryTreeService {
             }
             return this.http
                 .get(`${this.config.api_url}/get-tree-item.php`, { params })
-                .pipe(map((response) => {
+                .pipe(map$1((response) => {
                 if (response.records === undefined ||
                     response.records.length <= 0) {
                     throw response;
@@ -1186,19 +1547,14 @@ class EsolveCategoryTreeService {
         return null;
     }
 }
-EsolveCategoryTreeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCategoryTreeService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveCategoryTreeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCategoryTreeService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveCategoryTreeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCategoryTreeService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCategoryTreeService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }]; } });
 
 class EsolveManufacturer {
     get original_image_src() {
@@ -1283,7 +1639,7 @@ class EsolveManufacturersService {
         if (options === null || options === void 0 ? void 0 : options.featured_only) {
             params = params.set('featured_only', options.featured_only);
         }
-        return this.getManufacturerRecords(params).pipe(map((records) => {
+        return this.getManufacturerRecords(params).pipe(map$1((records) => {
             const manufacturers = [];
             for (const record of records) {
                 manufacturers.push(this.processManufacturer(record));
@@ -1294,7 +1650,7 @@ class EsolveManufacturersService {
         }));
     }
     getManufacturerSingle(params) {
-        return this.getManufacturerRecords(params).pipe(map((records) => {
+        return this.getManufacturerRecords(params).pipe(map$1((records) => {
             const record = records[0];
             return this.processManufacturer(record);
         }));
@@ -1302,7 +1658,7 @@ class EsolveManufacturersService {
     getManufacturerRecords(params) {
         return this.http
             .get(`${this.config.api_url}/get-manufacturers.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length <= 0) {
                 throw response;
@@ -1314,19 +1670,14 @@ class EsolveManufacturersService {
         return new EsolveManufacturer(record);
     }
 }
-EsolveManufacturersService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveManufacturersService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveManufacturersService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveManufacturersService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveManufacturersService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveManufacturersService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveManufacturersService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }]; } });
 
 // Types
 
@@ -1409,7 +1760,7 @@ class EsolveRangesService {
         if (options === null || options === void 0 ? void 0 : options.manufacturers_id) {
             params = params.set('manufacturers_id', options.manufacturers_id);
         }
-        return this.getRangeRecords(params).pipe(map((records) => {
+        return this.getRangeRecords(params).pipe(map$1((records) => {
             const ranges = [];
             for (const record of records) {
                 ranges.push(this.processRange(record));
@@ -1420,7 +1771,7 @@ class EsolveRangesService {
         }));
     }
     getRangeSingle(params) {
-        return this.getRangeRecords(params).pipe(map((records) => {
+        return this.getRangeRecords(params).pipe(map$1((records) => {
             const record = records[0];
             return this.processRange(record);
         }));
@@ -1428,7 +1779,7 @@ class EsolveRangesService {
     getRangeRecords(params) {
         return this.http
             .get(`${this.config.api_url}/get-ranges.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length <= 0) {
                 throw response;
@@ -1440,7 +1791,7 @@ class EsolveRangesService {
         return new EsolveRange(record);
     }
 }
-EsolveRangesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveRangesService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveRangesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveRangesService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveRangesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveRangesService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveRangesService, decorators: [{
             type: Injectable,
@@ -1451,7 +1802,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
 class EsolveTag {
@@ -1505,7 +1856,7 @@ class EsolveTagsService {
         const params = this.parseOptions(options);
         return this.http
             .get(`${this.config.api_url}/get-tags.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -1549,7 +1900,7 @@ class EsolveTagsService {
         return tags;
     }
 }
-EsolveTagsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTagsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveTagsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTagsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveTagsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTagsService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTagsService, decorators: [{
             type: Injectable,
@@ -1560,7 +1911,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
 // Types
@@ -1599,7 +1950,7 @@ class EsolveTopicService {
         }
         return this.http
             .get(`${this.config.api_url}/get-topics.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -1617,7 +1968,7 @@ class EsolveTopicService {
         return topics;
     }
 }
-EsolveTopicService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTopicService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveTopicService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTopicService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveTopicService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTopicService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTopicService, decorators: [{
             type: Injectable,
@@ -1628,7 +1979,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
 class EsolveAsset {
@@ -1668,404 +2019,128 @@ class EsolveAsset {
         if (record.created) {
             this.created = record.created;
         }
-        if (record.category) {
-            this.category = new EsolveCategoryTreeItem(record.category.type, record.category.id, record.category.parent_id, record.category.description, record.category.sef_description, record.category.short_description, record.category.sort_priority, record.category.active, record.category.display_only, record.category.image, record.category.seo_page_title, record.category.seo_keywords, record.category.seo_description);
-        }
-        if (record.subcategory) {
-            this.subcategory = new EsolveCategoryTreeItem(record.subcategory.type, record.subcategory.id, record.subcategory.parent_id, record.subcategory.description, record.subcategory.sef_description, record.subcategory.short_description, record.subcategory.sort_priority, record.subcategory.active, record.subcategory.display_only, record.subcategory.image, record.subcategory.seo_page_title, record.subcategory.seo_keywords, record.subcategory.seo_description);
-        }
-        if (record.manufacturer) {
-            this.manufacturer = new EsolveManufacturer(record.manufacturer);
-        }
-        if (record.range) {
-            this.range = new EsolveRange(record.range);
-        }
-        if (record.topics && record.topics.length > 0) {
-            for (const topic of record.topics) {
-                this.topics.push(new EsolveTopic(topic));
-            }
-        }
-        if (record.tags && record.tags.length > 0) {
-            for (const tag of record.tags) {
-                this.tags.push(new EsolveTag(tag));
-            }
-        }
-    }
-    /**
-     * Retrieve image path
-     *
-     * @returns Image path on CDN, else empty string if no image exists
-     */
-    getImagePath() {
-        if (this.image_name !== '') {
-            return `/images/documents/${this.image_name}`;
-        }
-        return '';
-    }
-}
-
-class EsolveAssetsService {
-    constructor(config, http) {
-        this.config = config;
-        this.http = http;
-    }
-    getAsset(id) {
-        const params = new HttpParams({ fromObject: { assets_id: id } });
-        return this.getAssetRecords(params).pipe(map((response) => {
-            if (response.records === undefined ||
-                response.records.length <= 0) {
-                throw response;
-            }
-            const record = response.records[0];
-            return this.processAsset(record);
-        }));
-    }
-    getAssets(options) {
-        const params = this.parseOptions(options);
-        return this.getAssetRecords(params).pipe(map((response) => {
-            var _a, _b;
-            if (response.records === undefined) {
-                throw response;
-            }
-            const assets = [];
-            for (const record of response.records) {
-                assets.push(this.processAsset(record));
-            }
-            const page = (_a = options === null || options === void 0 ? void 0 : options.page) !== null && _a !== void 0 ? _a : 0;
-            const rows = (_b = options === null || options === void 0 ? void 0 : options.rows) !== null && _b !== void 0 ? _b : 0;
-            const total = +response.additional_data.total_records;
-            return new EsolveList(assets, page, rows, total);
-        }));
-    }
-    processAsset(record) {
-        return new EsolveAsset(record);
-    }
-    getAssetRecords(params) {
-        return this.http.get(`${this.config.api_url}/get-assets.php`, { params });
-    }
-    parseOptions(options) {
-        let params = new HttpParams();
-        if (!options) {
-            return params;
-        }
-        if (options.page) {
-            params = params.set('page', options.page);
-        }
-        if (options.rows) {
-            params = params.set('rows', options.rows);
-        }
-        if (options.asset_type) {
-            params = params.set('asset_type', options.asset_type);
-        }
-        if (options.category_id) {
-            params = params.set('category_id', options.category_id);
-        }
-        if (options.subcategory_id) {
-            params = params.set('subcategory_id', options.subcategory_id);
-        }
-        if (options.manufacturers_id) {
-            params = params.set('manufacturers_id', options.manufacturers_id);
-        }
-        if (options.ranges_id) {
-            params = params.set('ranges_id', options.ranges_id);
-        }
-        if (options.asset_category) {
-            params = params.set('asset_category', options.asset_category);
-        }
-        if (options.asset_sub_category) {
-            params = params.set('asset_sub_category', options.asset_sub_category);
-        }
-        if (options.document_number) {
-            params = params.set('document_number', options.document_number);
-        }
-        if (options.document_type) {
-            params = params.set('document_type', options.document_type);
-        }
-        if (options.area_of_application) {
-            params = params.set('area_of_application', options.area_of_application);
-        }
-        return params;
-    }
-}
-EsolveAssetsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAssetsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-EsolveAssetsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAssetsService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAssetsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
-    } });
-
-// Types
-
-class EsolveSessionMetadataService {
-    constructor(config, http, errorHandler, responseHandler) {
-        this.config = config;
-        this.http = http;
-        this.errorHandler = errorHandler;
-        this.responseHandler = responseHandler;
-    }
-    set(type, metadata) {
-        return this.http
-            .post(`${this.config.api_url}/set-sessions-metadata.php`, metadata, {
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;',
-            },
-            responseType: 'json',
-            observe: 'body',
-            params: { type },
-        })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveResponseResult(response))), catchError((errorRes) => {
-            return this.errorHandler.handleHttpPostError('set-sessions-metadata', errorRes);
-        }));
-    }
-    get(type) {
-        return this.http
-            .get(`${this.config.api_url}/get-sessions-metadata.php`, {
-            params: { type },
-        })
-            .pipe(map((response) => {
-            if (response.records === undefined ||
-                (Array.isArray(response.records) &&
-                    response.records.length === 0)) {
-                throw response;
-            }
-            return response.records;
-        }));
-    }
-    delete(type) {
-        return this.http
-            .delete(`${this.config.api_url}/delete-sessions-metadata.php`, {
-            params: { type },
-            responseType: 'json',
-            observe: 'body',
-        })
-            .pipe(map((http_response) => {
-            if (http_response.result === undefined ||
-                http_response.result === null ||
-                http_response.result.status !== 'success') {
-                throw http_response;
-            }
-            return new EsolveResult(http_response.result.status, http_response.result.code, http_response.result.message);
-        }), catchError((errorRes) => {
-            return this.errorHandler.handleHttpDeleteError('delete-sessions-metadata', errorRes);
-        }));
-    }
-}
-EsolveSessionMetadataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionMetadataService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
-EsolveSessionMetadataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionMetadataService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSessionMetadataService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
-    } });
-
-class EsolveAuthService {
-    constructor(config, http, session, errorHandler, cookieService) {
-        this.config = config;
-        this.http = http;
-        this.session = session;
-        this.errorHandler = errorHandler;
-        this.cookieService = cookieService;
-    }
-    static preValidate(auth) {
-        return () => {
-            return auth.validateCachedTokens();
-        };
-    }
-    getAccessToken(email, password, anonymous = false) {
-        let params = new HttpParams();
-        if (anonymous) {
-            params = params.set('anonymous', true);
-        }
-        if (email !== '') {
-            params = params.set('email', email);
+        if (record.category) {
+            this.category = new EsolveCategoryTreeItem(record.category.type, record.category.id, record.category.parent_id, record.category.description, record.category.sef_description, record.category.short_description, record.category.sort_priority, record.category.active, record.category.display_only, record.category.image, record.category.seo_page_title, record.category.seo_keywords, record.category.seo_description);
         }
-        if (password !== '') {
-            params = params.set('password', password);
+        if (record.subcategory) {
+            this.subcategory = new EsolveCategoryTreeItem(record.subcategory.type, record.subcategory.id, record.subcategory.parent_id, record.subcategory.description, record.subcategory.sef_description, record.subcategory.short_description, record.subcategory.sort_priority, record.subcategory.active, record.subcategory.display_only, record.subcategory.image, record.subcategory.seo_page_title, record.subcategory.seo_keywords, record.subcategory.seo_description);
         }
-        return this.http
-            .get(`${this.config.api_url}/get-access-token.php`, {
-            params,
-            headers: new HttpHeaders({
-                'Accept-Language': '*',
-            }),
-        })
-            .pipe(tap((responseData) => {
-            if (responseData.type === 'error' ||
-                responseData.type === 'exception') {
-                throw responseData;
+        if (record.manufacturer) {
+            this.manufacturer = new EsolveManufacturer(record.manufacturer);
+        }
+        if (record.range) {
+            this.range = new EsolveRange(record.range);
+        }
+        if (record.topics && record.topics.length > 0) {
+            for (const topic of record.topics) {
+                this.topics.push(new EsolveTopic(topic));
             }
-        }), catchError(this.handleError), tap((responseData) => {
-            this.handleAuthentication(responseData.additional_data);
-        }));
+        }
+        if (record.tags && record.tags.length > 0) {
+            for (const tag of record.tags) {
+                this.tags.push(new EsolveTag(tag));
+            }
+        }
     }
-    autoLogin() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.validateCachedTokens();
-            this.session.restore(this.handleExpiration(), () => {
-                firstValueFrom(this.getAccessToken('', '', true)).then(() => {
-                    // empty
-                }, (error) => {
-                    console.error(error);
-                });
-            });
-        });
+    /**
+     * Retrieve image path
+     *
+     * @returns Image path on CDN, else empty string if no image exists
+     */
+    getImagePath() {
+        if (this.image_name !== '') {
+            return `/images/documents/${this.image_name}`;
+        }
+        return '';
     }
-    login(email, password) {
-        const body = {
-            login: {
-                email,
-                password,
-            },
-        };
-        return this.http
-            .post(`${this.config.api_url}/set-login.php`, body, {
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;',
-            },
-            responseType: 'json',
-            observe: 'body',
-        })
-            .pipe(map((response) => {
-            if (response.responses === undefined ||
-                response.responses.length <= 0) {
+}
+
+class EsolveAssetsService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    getAsset(id) {
+        const params = new HttpParams({ fromObject: { assets_id: id } });
+        return this.getAssetRecords(params).pipe(map$1((response) => {
+            if (response.records === undefined ||
+                response.records.length <= 0) {
                 throw response;
             }
-            const login_response = response.responses[0];
-            if (login_response.status.state !== 'success' &&
-                login_response.status.state !== 'warning') {
-                throw login_response;
-            }
-            for (const response_log of login_response.log) {
-                if (response_log.type === 'success' &&
-                    response_log.message_code === 'login_success') {
-                    const session_data = login_response.session_data;
-                    const user_id = +login_response.esolve_id;
-                    const location_id = +session_data.location_id;
-                    this.session.handleUpdateSession({
-                        user_id: user_id,
-                        location_id: location_id,
-                    });
-                    return user_id;
-                }
-            }
-            throw login_response;
-        }), catchError((errorRes) => {
-            return this.errorHandler.handleHttpPostError('set-login', errorRes);
+            const record = response.records[0];
+            return this.processAsset(record);
         }));
     }
-    logout() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.session.clearTimer();
-            this.cookieService.delete('_ws_id');
-            const response = yield firstValueFrom(this.getAccessToken('', '', true));
-            if (response) {
-                return response;
-            }
-            throw new Error('Invalid response');
-        });
-    }
-    validateCachedTokens() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let valid = false;
-            try {
-                const session = this.session.getCachedSession();
-                if (!session) {
-                    throw new Error('Invalid session');
-                }
-                const result = yield firstValueFrom(this.checkAccessToken(session));
-                if (!result.key) {
-                    throw new Error('Invalid key');
-                }
-                if (session.id !== result.user_id) {
-                    throw new Error('Invalid authentication');
-                }
-                valid = true;
-            }
-            catch (error) {
-                this.session.resetSessionCache();
+    getAssets(options) {
+        const params = this.parseOptions(options);
+        return this.getAssetRecords(params).pipe(map$1((response) => {
+            var _a, _b;
+            if (response.records === undefined) {
+                throw response;
             }
-            return valid;
-        });
-    }
-    checkAccessToken(session) {
-        var _a;
-        session = session || this.session.currentSession;
-        const token = (_a = session === null || session === void 0 ? void 0 : session.key) !== null && _a !== void 0 ? _a : '';
-        return this.http
-            .get(`${this.config.api_url}/get-access-token.php`, {
-            params: { key: token },
-            headers: new HttpHeaders({
-                'Accept-Language': '*',
-            }),
-        })
-            .pipe(map((responseData) => {
-            if (responseData.type === 'error' ||
-                responseData.type === 'exception' ||
-                !responseData.additional_data.key_okay) {
-                throw responseData;
+            const assets = [];
+            for (const record of response.records) {
+                assets.push(this.processAsset(record));
             }
-            const additional_data = responseData.additional_data;
-            const result = {
-                key: token,
-                expires: additional_data.expires,
-                expiry_time: additional_data.expiry_time,
-                location_id: additional_data.location_id,
-                user_id: additional_data.user_id,
-            };
-            return result;
+            const page = (_a = options === null || options === void 0 ? void 0 : options.page) !== null && _a !== void 0 ? _a : 0;
+            const rows = (_b = options === null || options === void 0 ? void 0 : options.rows) !== null && _b !== void 0 ? _b : 0;
+            const total = +response.additional_data.total_records;
+            return new EsolveList(assets, page, rows, total);
         }));
     }
-    // Handlers
-    handleExpiration() {
-        return (session) => {
-            firstValueFrom(this.checkAccessToken(session)).then((response) => {
-                if (response) {
-                    this.handleAuthentication(response);
-                }
-            }, () => {
-                this.logout();
-            });
-        };
+    processAsset(record) {
+        return new EsolveAsset(record);
     }
-    handleAuthentication(result) {
-        if (!result.key) {
-            return;
-        }
-        this.session.handleSession(+result.user_id, +result.location_id, result.key, +result.expiry_time, +result.expires, this.handleExpiration());
+    getAssetRecords(params) {
+        return this.http.get(`${this.config.api_url}/get-assets.php`, { params });
     }
-    handleError(errorRes) {
-        const error = {
-            message: 'An unknown error occurred',
-            data: {},
-        };
-        if (!errorRes.type || !errorRes.service_type || !errorRes.message) {
-            return throwError(() => error);
+    parseOptions(options) {
+        let params = new HttpParams();
+        if (!options) {
+            return params;
         }
-        if (errorRes.message.trim() !== '') {
-            error.message = errorRes.message;
+        if (options.page) {
+            params = params.set('page', options.page);
         }
-        if (errorRes.additional_data) {
-            error.data = errorRes.additional_data;
+        if (options.rows) {
+            params = params.set('rows', options.rows);
         }
-        return throwError(() => error);
+        if (options.asset_type) {
+            params = params.set('asset_type', options.asset_type);
+        }
+        if (options.category_id) {
+            params = params.set('category_id', options.category_id);
+        }
+        if (options.subcategory_id) {
+            params = params.set('subcategory_id', options.subcategory_id);
+        }
+        if (options.manufacturers_id) {
+            params = params.set('manufacturers_id', options.manufacturers_id);
+        }
+        if (options.ranges_id) {
+            params = params.set('ranges_id', options.ranges_id);
+        }
+        if (options.asset_category) {
+            params = params.set('asset_category', options.asset_category);
+        }
+        if (options.asset_sub_category) {
+            params = params.set('asset_sub_category', options.asset_sub_category);
+        }
+        if (options.document_number) {
+            params = params.set('document_number', options.document_number);
+        }
+        if (options.document_type) {
+            params = params.set('document_type', options.document_type);
+        }
+        if (options.area_of_application) {
+            params = params.set('area_of_application', options.area_of_application);
+        }
+        return params;
     }
 }
-EsolveAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }, { token: EsolveSessionService }, { token: EsolveErrorHandlerService }, { token: EsolveCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
-EsolveAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAuthService, decorators: [{
+EsolveAssetsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAssetsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveAssetsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAssetsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAssetsService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -2074,9 +2149,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }, { type: EsolveSessionService }, { type: EsolveErrorHandlerService }, { type: EsolveCookieService }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
+// Types
+
 class EsolveAddress {
     constructor(id, recipient, address_type, pobox, place_name, street_number, street, suburb, city, province, country, postal_code, latitude, longitude) {
         this.id = id;
@@ -2561,7 +2638,7 @@ class EsolveLocationsService {
     getStockLocations() {
         return this.http
             .get(`${this.config.api_url}/get-locations.php`)
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -2588,7 +2665,7 @@ class EsolveLocationsService {
                 longitude,
             },
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -2611,7 +2688,7 @@ class EsolveLocationsService {
         return stock_locations;
     }
 }
-EsolveLocationsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveLocationsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveLocationsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveLocationsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveLocationsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveLocationsService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveLocationsService, decorators: [{
             type: Injectable,
@@ -2622,7 +2699,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
 class EsolveTransactionLocation extends EsolveLocation {
@@ -2720,16 +2797,15 @@ class EsolveTransactionsService {
             this._user_id = value;
         }
     }
-    constructor(config, http, sessionService, errorHandler, responseHandler) {
+    constructor(config, http, sessionService, errorHandler) {
         this.config = config;
         this.http = http;
         this.sessionService = sessionService;
         this.errorHandler = errorHandler;
-        this.responseHandler = responseHandler;
         this._user_id = 0;
-        this.sessionService.session.subscribe((session) => {
-            if (session.key !== '') {
-                this.user_id = session.id;
+        this.sessionService.getSession().subscribe((session) => {
+            if (session.token !== '') {
+                this.user_id = session.user_id;
             }
         });
     }
@@ -2767,7 +2843,7 @@ class EsolveTransactionsService {
                 .get(`${this.config.api_url}/get-transactions.php`, {
                 params: params,
             })
-                .pipe(map$1((response) => {
+                .pipe(map((response) => {
                 var _a, _b;
                 if (response.records === undefined) {
                     throw response;
@@ -2793,7 +2869,7 @@ class EsolveTransactionsService {
                     transaction_id: id,
                 },
             })
-                .pipe(map$1((response) => {
+                .pipe(map((response) => {
                 if (response.records === undefined ||
                     response.records.length <= 0) {
                     throw response;
@@ -2822,19 +2898,14 @@ class EsolveTransactionsService {
         return transactions;
     }
 }
-EsolveTransactionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTransactionsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }, { token: EsolveSessionService }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveTransactionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTransactionsService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }, { token: EsolveSessionService }, { token: EsolveErrorHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveTransactionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTransactionsService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveTransactionsService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }, { type: EsolveSessionService }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }, { type: EsolveSessionService }, { type: EsolveErrorHandlerService }]; } });
 
 class EsolveEmptyCartResult extends EsolveResponseResult {
 }
@@ -3037,7 +3108,7 @@ class EsolveCouponsService {
                 coupon_key,
             },
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 Array.isArray(response.records)) {
                 throw response;
@@ -3092,7 +3163,7 @@ class EsolveCouponsService {
                 coupons: coupon_ids.join(','),
             },
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -3216,7 +3287,7 @@ class EsolveCouponsService {
         return coupons;
     }
 }
-EsolveCouponsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCouponsService, deps: [{ token: PLATFORM_ID }, { token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }, { token: EsolveCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveCouponsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCouponsService, deps: [{ token: PLATFORM_ID }, { token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }, { token: EsolveCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveCouponsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCouponsService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCouponsService, decorators: [{
             type: Injectable,
@@ -3230,7 +3301,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                     }] }, { type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }, { type: EsolveCookieService }];
+                    }] }, { type: i1$1.HttpClient }, { type: EsolveCookieService }];
     } });
 
 // Classes
@@ -3257,7 +3328,7 @@ class EsolveCartService {
         }
         return this.http
             .get(`${this.config.api_url}/get-cart.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -3285,7 +3356,7 @@ class EsolveCartService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.responses === undefined) {
                 throw response;
             }
@@ -3305,7 +3376,7 @@ class EsolveCartService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
             this._cached_tracking = 0;
             return new EsolveEmptyCartResult(response);
         })), catchError((errorRes) => {
@@ -3324,7 +3395,7 @@ class EsolveCartService {
                 type: type !== null && type !== void 0 ? type : '',
             },
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 Array.isArray(response.records)) {
                 throw response;
@@ -3340,7 +3411,7 @@ class EsolveCartService {
     getTrackingCode() {
         return iif(() => this._cached_tracking > 0, of(this._cached_tracking), this.http
             .get(`${this.config.api_url}/get-checkout-tracking.php`)
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 Array.isArray(response.records)) {
                 throw response;
@@ -3363,7 +3434,7 @@ class EsolveCartService {
                 transaction_id,
             },
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 Array.isArray(response.records)) {
                 throw response;
@@ -3394,7 +3465,7 @@ class EsolveCartService {
             tracking: 0,
             time_slot,
         };
-        return this.getTrackingCode().pipe(switchMap((tracking) => {
+        return this.getTrackingCode().pipe(switchMap$1((tracking) => {
             if (tracking <= 0) {
                 throw tracking;
             }
@@ -3407,7 +3478,7 @@ class EsolveCartService {
                 responseType: 'json',
                 observe: 'body',
             })
-                .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
+                .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
                 this._cached_tracking = 0;
                 this.coupons.reset();
                 return new EsolveCheckoutResult(response);
@@ -3442,7 +3513,7 @@ class EsolveCartService {
         return cart_totals;
     }
 }
-EsolveCartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCartService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }, { token: EsolveCouponsService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveCartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCartService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }, { token: EsolveCouponsService }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveCartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCartService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveCartService, decorators: [{
             type: Injectable,
@@ -3453,7 +3524,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }, { type: EsolveCouponsService }];
+                    }] }, { type: i1$1.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }, { type: EsolveCouponsService }];
     } });
 
 class EsolveAccountService {
@@ -3473,9 +3544,9 @@ class EsolveAccountService {
         this.errorHandler = errorHandler;
         this.responseHandler = responseHandler;
         this._user_id = 0;
-        this.sessionService.session.subscribe((session) => {
-            if (session.key !== '') {
-                this.user_id = session.id;
+        this.sessionService.getSession().subscribe((session) => {
+            if (session.token !== '') {
+                this.user_id = session.user_id;
             }
         });
     }
@@ -3491,14 +3562,14 @@ class EsolveAccountService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveUserAccountResult(response))), catchError((errorRes) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveUserAccountResult(response))), catchError((errorRes) => {
             return this.errorHandler.handleHttpPostError('set-user-account', errorRes);
         }));
     }
     getUserAccount() {
         return this.http
             .get(`${this.config.api_url}/get-account.php`)
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length === 0) {
                 throw response;
@@ -3513,7 +3584,7 @@ class EsolveAccountService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => {
+            .pipe(map$1((http_response) => {
             if (http_response.result === undefined ||
                 http_response.result === null ||
                 http_response.result.status !== 'success') {
@@ -3536,7 +3607,7 @@ class EsolveAccountService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveAddressResult(response))), catchError((errorRes) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveAddressResult(response))), catchError((errorRes) => {
             return this.errorHandler.handleHttpPostError('set-address', errorRes);
         }));
     }
@@ -3547,7 +3618,7 @@ class EsolveAccountService {
                 .get(`${this.config.api_url}/get-addresses.php`, {
                 params: { user_id: this.user_id },
             })
-                .pipe(map((response) => {
+                .pipe(map$1((response) => {
                 if (response.records === undefined) {
                     throw response;
                 }
@@ -3565,7 +3636,7 @@ class EsolveAccountService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => {
+            .pipe(map$1((http_response) => {
             if (http_response.result === undefined ||
                 http_response.result === null ||
                 http_response.result.status !== 'success') {
@@ -3589,7 +3660,7 @@ class EsolveAccountService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
             if (response.auto_login) {
                 this.sessionService.handleUpdateSession({
                     user_id: +response.esolve_id,
@@ -3614,7 +3685,7 @@ class EsolveAccountService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
             return new EsolveChangePasswordResult(response);
         })), catchError((errorRes) => {
             return this.errorHandler.handleHttpPostError('set-change-password', errorRes);
@@ -3640,7 +3711,7 @@ class EsolveAccountService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
             if (response.auto_login) {
                 this.sessionService.handleUpdateSession({
                     user_id: +response.esolve_id,
@@ -3655,7 +3726,7 @@ class EsolveAccountService {
     sendForgotPasswordRequest(email) {
         return this.http
             .get(`${this.config.api_url}/get-forgot-password.php`, { params: { email } })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 !('reset_link_sent' in response.records)) {
                 throw response;
@@ -3677,7 +3748,7 @@ class EsolveAccountService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
             if (!response.login_required) {
                 this.sessionService.handleUpdateSession({
                     user_id: +response.esolve_id,
@@ -3727,7 +3798,7 @@ class EsolveAccountService {
             }
             return this.http
                 .get(`${this.config.api_url}/get-transactions.php`, { params })
-                .pipe(map((response) => {
+                .pipe(map$1((response) => {
                 var _a, _b;
                 if (response.records === undefined) {
                     throw response;
@@ -3756,7 +3827,7 @@ class EsolveAccountService {
                     transaction_id: id,
                 },
             })
-                .pipe(map((response) => {
+                .pipe(map$1((response) => {
                 if (response.records === undefined ||
                     response.records.length <= 0) {
                     throw response;
@@ -3774,7 +3845,7 @@ class EsolveAccountService {
             this.loginGuard();
             return this.http
                 .get(`${this.config.api_url}/get-client-account-balances.php`)
-                .pipe(map((response) => {
+                .pipe(map$1((response) => {
                 if (response.records === undefined) {
                     throw response;
                 }
@@ -3819,7 +3890,7 @@ class EsolveAccountService {
     }
     processClientBalances(records) {
         for (const record of records) {
-            if (!(+record.clients_id > 0)) {
+            if (+record.clients_id <= 0) {
                 return undefined;
             }
             const cart_totals = new EsolveCartTotals(record.cart_totals.records, +record.cart_totals.items, +record.cart_totals.total, +record.cart_totals.vat, +record.cart_totals.discount);
@@ -3841,7 +3912,7 @@ class EsolveAccountService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
             if (typeof response.esolve_id === 'string') {
                 throw new Error('Invalid response id.');
             }
@@ -3852,19 +3923,14 @@ class EsolveAccountService {
         })));
     }
 }
-EsolveAccountService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAccountService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }, { token: EsolveSessionService }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveAccountService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAccountService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }, { token: EsolveSessionService }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveAccountService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAccountService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveAccountService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }, { type: EsolveSessionService }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }, { type: EsolveSessionService }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }]; } });
 
 class EsolveBanner {
     constructor(id, banner_display_container, identifier, type, title, article, sort_priority, link, images) {
@@ -3936,7 +4002,7 @@ class EsolveBannerService {
         }
         return this.http
             .get(`${this.config.api_url}/get-banners.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -3996,19 +4062,14 @@ class EsolveBannerService {
         return banners;
     }
 }
-EsolveBannerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveBannerService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveBannerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveBannerService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveBannerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveBannerService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveBannerService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }]; } });
 
 // Types
 
@@ -4052,7 +4113,7 @@ class EsolveMenuService {
     getMenuTree(identifier) {
         return this.http
             .get(`${this.config.api_url}/get-menu-tree.php`, { params: { identifier } })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (!response || response.records === undefined) {
                 throw response;
             }
@@ -4072,19 +4133,14 @@ class EsolveMenuService {
         return menu;
     }
 }
-EsolveMenuService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveMenuService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveMenuService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveMenuService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveMenuService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveMenuService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveMenuService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }]; } });
 
 class EsolveNewsGroup {
     get image_src() {
@@ -4204,7 +4260,7 @@ class EsolveNewsService {
         const params = new HttpParams({
             fromObject: { sef_title: identifier },
         });
-        return this.getNewsRecords(params).pipe(map((response) => {
+        return this.getNewsRecords(params).pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length <= 0) {
                 throw response;
@@ -4218,7 +4274,7 @@ class EsolveNewsService {
     }
     getNewsArticles(options) {
         const params = this.parseOptions(options);
-        return this.getNewsRecords(params).pipe(map((response) => {
+        return this.getNewsRecords(params).pipe(map$1((response) => {
             var _a;
             if (response.records === undefined) {
                 throw response;
@@ -4239,7 +4295,7 @@ class EsolveNewsService {
                 enable_images,
             },
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -4294,19 +4350,14 @@ class EsolveNewsService {
         return params;
     }
 }
-EsolveNewsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveNewsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveNewsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveNewsService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveNewsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveNewsService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveNewsService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }]; } });
 
 // Types
 
@@ -4901,7 +4952,7 @@ class EsolveStockService {
                 code,
             },
         });
-        return this.getStockRecords(params).pipe(map((response) => {
+        return this.getStockRecords(params).pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length <= 0) {
                 throw response;
@@ -4921,7 +4972,7 @@ class EsolveStockService {
                 sef_name,
             },
         });
-        return this.getStockRecords(params).pipe(map((response) => {
+        return this.getStockRecords(params).pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length <= 0) {
                 throw response;
@@ -4989,7 +5040,7 @@ class EsolveStockService {
             }
             params = convertToHttpParams(filters, params);
         }
-        return this.getStockRecords(params).pipe(map((response) => {
+        return this.getStockRecords(params).pipe(map$1((response) => {
             var _a;
             if (response.records === undefined ||
                 response.records.length <= 0) {
@@ -5061,7 +5112,7 @@ class EsolveStockService {
             }
             params = convertToHttpParams(filters, params);
         }
-        return this.getStockHistoryRecords(params).pipe(map((response) => {
+        return this.getStockHistoryRecords(params).pipe(map$1((response) => {
             var _a;
             if (response.records === undefined ||
                 response.records.length <= 0) {
@@ -5082,7 +5133,7 @@ class EsolveStockService {
     getLinkedItems(code) {
         return this.http
             .get(`${this.config.api_url}/get-linked-items.php`, { params: { code } })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length <= 0) {
                 throw response;
@@ -5116,7 +5167,7 @@ class EsolveStockService {
         }
         return this.http
             .get(`${this.config.api_url}/get-recipe-items.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length <= 0) {
                 throw response;
@@ -5158,7 +5209,7 @@ class EsolveStockService {
         }
         return this.http
             .get(`${this.config.api_url}/get-media-linked-items.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length <= 0) {
                 throw response;
@@ -5175,7 +5226,7 @@ class EsolveStockService {
     getStockImageCollection(code) {
         return this.http
             .get(`${this.config.api_url}/get-item-image-collection.php`, { params: { code } })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 Array.isArray(response.records)) {
                 throw response;
@@ -5198,7 +5249,7 @@ class EsolveStockService {
         });
         return this.http
             .get(`${this.config.api_url}/get-item-filters.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -5286,7 +5337,7 @@ class EsolveStockService {
         return this.http.get(`${this.config.api_url}/get-items-transaction-history.php`, { params });
     }
 }
-EsolveStockService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveStockService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveStockService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveStockService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveStockService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveStockService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveStockService, decorators: [{
             type: Injectable,
@@ -5297,7 +5348,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
 class EsolveSpecialImage {
@@ -5407,7 +5458,7 @@ class EsolveSpecialsService {
         if (options === null || options === void 0 ? void 0 : options.special_type) {
             params = params.set('special_type', options.special_type);
         }
-        return this.getSpecialRecords(params).pipe(map((records) => {
+        return this.getSpecialRecords(params).pipe(map$1((records) => {
             const specials = [];
             for (const record of records) {
                 specials.push(this.processSpecial(record));
@@ -5418,7 +5469,7 @@ class EsolveSpecialsService {
         }));
     }
     getSpecialSingle(params) {
-        return this.getSpecialRecords(params).pipe(map((records) => {
+        return this.getSpecialRecords(params).pipe(map$1((records) => {
             const record = records[0];
             return this.processSpecial(record);
         }));
@@ -5426,7 +5477,7 @@ class EsolveSpecialsService {
     getSpecialRecords(params) {
         return this.http
             .get(`${this.config.api_url}/get-specials.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length <= 0) {
                 throw response;
@@ -5438,7 +5489,7 @@ class EsolveSpecialsService {
         return new EsolveSpecial(record);
     }
 }
-EsolveSpecialsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSpecialsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveSpecialsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSpecialsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveSpecialsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSpecialsService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSpecialsService, decorators: [{
             type: Injectable,
@@ -5449,7 +5500,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
 // Only export the types that are accessible to the public API
@@ -5594,7 +5645,7 @@ class EsolvePaymentService {
     getPaymentMethods(options) {
         return this.http
             .get(`${this.config.api_url}/get-payment-methods.php`, { params: Object.assign({}, options) })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -5611,7 +5662,7 @@ class EsolvePaymentService {
     getPaymentStatus(transaction_id) {
         return this.http
             .get(`${this.config.api_url}/get-payment-status.php`, { params: { cart_id: transaction_id } })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 Array.isArray(response.records)) {
                 throw response;
@@ -5633,7 +5684,7 @@ class EsolvePaymentService {
         }
         return this.http
             .get(`${this.config.api_url}/get-vault.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -5666,7 +5717,7 @@ class EsolvePaymentService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveVaultItemResult(response))), catchError((errorRes) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveVaultItemResult(response))), catchError((errorRes) => {
             return this.errorHandler.handleHttpPostError('set-vault', errorRes);
         }));
     }
@@ -5684,7 +5735,7 @@ class EsolvePaymentService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => {
+            .pipe(map$1((http_response) => {
             if (http_response.result === undefined ||
                 http_response.result === null ||
                 http_response.result.status !== 'success') {
@@ -5736,7 +5787,7 @@ class EsolvePaymentService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolvePaymentResult(response))), catchError((errorRes) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolvePaymentResult(response))), catchError((errorRes) => {
             return this.errorHandler.handleHttpPostError('set-payment', errorRes);
         }));
     }
@@ -5787,7 +5838,7 @@ class EsolvePaymentService {
         return `${month_string}${year_string}`;
     }
 }
-EsolvePaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolvePaymentService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolvePaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolvePaymentService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolvePaymentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolvePaymentService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolvePaymentService, decorators: [{
             type: Injectable,
@@ -5798,7 +5849,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
+                    }] }, { type: i1$1.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
     } });
 
 class EsolveShippingTotals {
@@ -5955,7 +6006,7 @@ class EsolveShippingService {
         }
         return this.http
             .get(`${this.config.api_url}/get-shipping-methods.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -5991,7 +6042,7 @@ class EsolveShippingService {
             }
             return this.http
                 .get(`${this.config.api_url}/get-shipping-cost.php`, { params })
-                .pipe(map((response) => {
+                .pipe(map$1((response) => {
                 if (response.records === undefined) {
                     throw response;
                 }
@@ -6020,7 +6071,7 @@ class EsolveShippingService {
             }
             return this.http
                 .get(`${this.config.api_url}/get-time-slots.php`, { params })
-                .pipe(map((response) => {
+                .pipe(map$1((response) => {
                 if (response.records === undefined ||
                     Array.isArray(response.records)) {
                     throw response;
@@ -6061,7 +6112,7 @@ class EsolveShippingService {
         return shipping_cost;
     }
 }
-EsolveShippingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveShippingService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveShippingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveShippingService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveShippingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveShippingService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveShippingService, decorators: [{
             type: Injectable,
@@ -6072,7 +6123,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
 class EsolveEnquiryResult extends EsolveResponseResult {
@@ -6099,24 +6150,19 @@ class EsolveEnquiryService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveEnquiryResult(response))), catchError((errorRes) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveEnquiryResult(response))), catchError((errorRes) => {
             return this.errorHandler.handleHttpPostError('set-enquiry', errorRes);
         }));
     }
 }
-EsolveEnquiryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveEnquiryService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveEnquiryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveEnquiryService, deps: [{ token: EsolveConfigService }, { token: i1$1.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveEnquiryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveEnquiryService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveEnquiryService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
-    } });
+        }], ctorParameters: function () { return [{ type: EsolveConfigService }, { type: i1$1.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }]; } });
 
 class EsolveWishlistItem {
     constructor(id, qty, vat_rate, price, price_incl, vat_total, total, total_incl, stock_item) {
@@ -6148,7 +6194,7 @@ class EsolveWishlistService {
      * @returns An `Observable` with an array of cart items
      */
     getWishlist() {
-        return this.getWishlistRecords().pipe(map((response) => {
+        return this.getWishlistRecords().pipe(map$1((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -6176,7 +6222,7 @@ class EsolveWishlistService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.responses === undefined) {
                 throw response;
             }
@@ -6197,7 +6243,7 @@ class EsolveWishlistService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
+            .pipe(map$1((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
             return new EsolveEmptyWishlistResult(response);
         })), catchError((errorRes) => {
             return this.errorHandler.handleHttpPostError('set-wishlist-empty', errorRes);
@@ -6230,7 +6276,7 @@ class EsolveWishlistService {
         return this.http.get(`${this.config.api_url}/get-wishlist.php`, { params });
     }
 }
-EsolveWishlistService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveWishlistService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveWishlistService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveWishlistService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveWishlistService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveWishlistService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveWishlistService, decorators: [{
             type: Injectable,
@@ -6241,7 +6287,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
+                    }] }, { type: i1$1.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
     } });
 
 class EsolveSupplier {
@@ -6285,7 +6331,7 @@ class EsolveSuppliersService {
         if (options === null || options === void 0 ? void 0 : options.internal_account) {
             params = params.set('internal_account', options.internal_account);
         }
-        return this.getSupplierRecords(params).pipe(map((records) => {
+        return this.getSupplierRecords(params).pipe(map$1((records) => {
             const suppliers = [];
             for (const record of records) {
                 suppliers.push(this.processSuppliers(record));
@@ -6298,7 +6344,7 @@ class EsolveSuppliersService {
     getSupplierRecords(params) {
         return this.http
             .get(`${this.config.api_url}/get-suppliers.php`, { params })
-            .pipe(map((response) => {
+            .pipe(map$1((response) => {
             if (response.records === undefined ||
                 response.records.length === 0) {
                 throw response;
@@ -6310,7 +6356,7 @@ class EsolveSuppliersService {
         return new EsolveSupplier(record);
     }
 }
-EsolveSuppliersService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSuppliersService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveSuppliersService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSuppliersService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 EsolveSuppliersService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSuppliersService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: EsolveSuppliersService, decorators: [{
             type: Injectable,
@@ -6321,7 +6367,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: [ESOLVE_CONNECT_CONFIG]
-                    }] }, { type: i1$2.HttpClient }];
+                    }] }, { type: i1$1.HttpClient }];
     } });
 
 /*
@@ -6332,5 +6378,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ESOLVE_CONNECT_CONFIG, EsolveAccountConfirmationResult, EsolveAccountService, EsolveAdditionalStockImage, EsolveAddress, EsolveAddressResult, EsolveAsset, EsolveAssetsService, EsolveAuthService, EsolveBankingDetails, EsolveBanner, EsolveBannerImage, EsolveBannerImageHotspot, EsolveBannerService, EsolveCartItem, EsolveCartService, EsolveCartStockItem, EsolveCartTotals, EsolveCategoryTreeItem, EsolveCategoryTreeService, EsolveChangePasswordResult, EsolveCheckoutResult, EsolveColour, EsolveCookieService, EsolveCoupon, EsolveCouponsService, EsolveDependantItem, EsolveEmptyCartResult, EsolveEmptyWishlistResult, EsolveEnquiryResult, EsolveEnquiryService, EsolveErrorHandlerService, esolveFilterFactory as EsolveFilterFactory, EsolveGeocodeAddressResult, EsolveGeocodeCoordsResult, EsolveGeocodeResult, EsolveGeocoderService, EsolveHttpError, EsolveLinkedAsset, EsolveLinkedStockItem, EsolveList, EsolveLocation, EsolveLocationAddress, EsolveLocationContactInfo, EsolveLocationGEO, EsolveLocationPOBoxAddress, EsolveLocationTradingDay, EsolveLocationTradingTimes, EsolveLocationUpdateResult, EsolveLocationsService, EsolveManufacturer, EsolveManufacturersService, EsolveMediaStockItem, EsolveMenuItem, EsolveMenuService, EsolveMultipleSelectFilter, EsolveNewsArticle, EsolveNewsArticleAuthor, EsolveNewsArticleList, EsolveNewsGroup, EsolveNewsService, EsolvePaymentMethod, EsolvePaymentResult, EsolvePaymentService, EsolveRange, EsolveRangeFilter, EsolveRangesService, EsolveRecipeStockItem, EsolveRegistrationResult, EsolveResetPasswordResult, EsolveResponseHandlerService, EsolveResponseResult, EsolveResult, EsolveSeoInfo, EsolveSeoService, EsolveSession, EsolveSessionMetadataService, EsolveSessionService, EsolveShippingCost, EsolveShippingMethod, EsolveShippingService, EsolveShippingTotals, EsolveSingleSelectFilter, EsolveSpecial, EsolveSpecialDates, EsolveSpecialImage, EsolveSpecialImageCollection, EsolveSpecialsService, EsolveStatement, EsolveStatementAgeing, EsolveStatementBalances, EsolveStatementTransaction, EsolveStockBadge, EsolveStockGroup, EsolveStockGroupItem, EsolveStockImage, EsolveStockImageCollection, EsolveStockItem, EsolveStockItemBase, EsolveStockItemList, EsolveStockLeadTimes, EsolveStockPrice, EsolveStockService, EsolveSupplier, EsolveSuppliersService, EsolveTag, EsolveTagsService, EsolveTimeSlot, EsolveTimeSlotConfig, EsolveTimeSlotDate, EsolveTimeSlotDays, EsolveTimeSlotTimes, EsolveToggleFilter, EsolveTopic, EsolveTopicService, EsolveTransaction, EsolveTransactionAddress, EsolveTransactionAnalyticsData, EsolveTransactionClient, EsolveTransactionItem, EsolveTransactionItemPrice, EsolveTransactionList, EsolveTransactionLocation, EsolveTransactionPaymentMethod, EsolveTransactionShippingMethod, EsolveTransactionUser, EsolveTransactionsService, EsolveUserAccount, EsolveUserAccountBusiness, EsolveUserAccountContact, EsolveUserAccountResult, EsolveUserClientAccount, EsolveUserClientAccountBalances, EsolveVaultItem, EsolveVaultItemResult, EsolveWishlistItem, EsolveWishlistService, NgEsolveConnectModule, esolveHexHash };
+export { ESOLVE_CONNECT_CONFIG, ESOLVE_EURUS_AUTO_LOGIN, ESOLVE_IMAGE_LOADER_PROVIDER, EsolveAccountConfirmationResult, EsolveAccountService, EsolveAdditionalStockImage, EsolveAddress, EsolveAddressResult, EsolveAsset, EsolveAssetsService, EsolveAuthInterceptorService, EsolveAuthService, EsolveBankingDetails, EsolveBanner, EsolveBannerImage, EsolveBannerImageHotspot, EsolveBannerService, EsolveCartItem, EsolveCartService, EsolveCartStockItem, EsolveCartTotals, EsolveCategoryTreeItem, EsolveCategoryTreeService, EsolveCdnSrcDirective, EsolveChangePasswordResult, EsolveCheckoutResult, EsolveColour, EsolveConfigService, EsolveCookieService, EsolveCoupon, EsolveCouponsService, EsolveDependantItem, EsolveEmptyCartResult, EsolveEmptyWishlistResult, EsolveEnquiryResult, EsolveEnquiryService, EsolveErrorHandlerService, esolveFilterFactory as EsolveFilterFactory, EsolveGeocodeAddressResult, EsolveGeocodeCoordsResult, EsolveGeocodeResult, EsolveGeocoderService, EsolveHttpError, EsolveLinkedAsset, EsolveLinkedStockItem, EsolveList, EsolveLocation, EsolveLocationAddress, EsolveLocationContactInfo, EsolveLocationGEO, EsolveLocationPOBoxAddress, EsolveLocationTradingDay, EsolveLocationTradingTimes, EsolveLocationUpdateResult, EsolveLocationsService, EsolveManufacturer, EsolveManufacturersService, EsolveMediaStockItem, EsolveMenuItem, EsolveMenuService, EsolveMultipleSelectFilter, EsolveNewsArticle, EsolveNewsArticleAuthor, EsolveNewsArticleList, EsolveNewsGroup, EsolveNewsService, EsolvePaymentMethod, EsolvePaymentResult, EsolvePaymentService, EsolveRange, EsolveRangeFilter, EsolveRangesService, EsolveRecipeStockItem, EsolveRegistrationResult, EsolveResetPasswordResult, EsolveResponseHandlerService, EsolveResponseResult, EsolveResult, EsolveSeoInfo, EsolveSeoService, EsolveSessionMetadataService, EsolveSessionService, EsolveShippingCost, EsolveShippingMethod, EsolveShippingService, EsolveShippingTotals, EsolveSingleSelectFilter, EsolveSpecial, EsolveSpecialDates, EsolveSpecialImage, EsolveSpecialImageCollection, EsolveSpecialsService, EsolveStatement, EsolveStatementAgeing, EsolveStatementBalances, EsolveStatementTransaction, EsolveStockBadge, EsolveStockGroup, EsolveStockGroupItem, EsolveStockImage, EsolveStockImageCollection, EsolveStockItem, EsolveStockItemBase, EsolveStockItemList, EsolveStockLeadTimes, EsolveStockPrice, EsolveStockService, EsolveSupplier, EsolveSuppliersService, EsolveTag, EsolveTagsService, EsolveTimeSlot, EsolveTimeSlotConfig, EsolveTimeSlotDate, EsolveTimeSlotDays, EsolveTimeSlotTimes, EsolveToggleFilter, EsolveTopic, EsolveTopicService, EsolveTransaction, EsolveTransactionAddress, EsolveTransactionAnalyticsData, EsolveTransactionClient, EsolveTransactionItem, EsolveTransactionItemPrice, EsolveTransactionList, EsolveTransactionLocation, EsolveTransactionPaymentMethod, EsolveTransactionShippingMethod, EsolveTransactionUser, EsolveTransactionsService, EsolveUserAccount, EsolveUserAccountBusiness, EsolveUserAccountContact, EsolveUserAccountResult, EsolveUserClientAccount, EsolveUserClientAccountBalances, EsolveVaultItem, EsolveVaultItemResult, EsolveWishlistItem, EsolveWishlistService, NgEsolveConnectModule, esolveHexHash, isEsolveCdnPath, isLegacyEsolveCdnPath, processEsolveImageSrc };
 //# sourceMappingURL=esolve-ng-esolve-connect.mjs.map