@esolve/ng-esolve-connect 0.6.1 → 0.7.3

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

@@ -0,0 +1,2651 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i1$1 from '@angular/common/http';
+import { HttpParams, HTTP_INTERCEPTORS, HttpClientModule, HttpErrorResponse, HttpHeaders } from '@angular/common/http';
+import * as i4 from 'ngx-cookie-service';
+import { CookieService } from 'ngx-cookie-service';
+import { BehaviorSubject, throwError, iif, of } from 'rxjs';
+import * as i1 from '@angular/platform-browser';
+import { map, tap, catchError, switchMap } from 'rxjs/operators';
+
+const ESOLVE_CONNECT_CONFIG = new InjectionToken('esolve.connect.config');
+// For future development
+// export const GLOBAL_CONFIG = {
+//     images_url: '',
+//     media_path: '/media',
+//     stock_path: '/stock',
+//     banner_path: '/banners'
+// };
+
+class EsolveSession {
+    constructor(id = -1, _key = '', _key_expiration_date) {
+        this.id = id;
+        this._key = _key;
+        this._key_expiration_date = _key_expiration_date;
+    }
+    get key() {
+        return this._key;
+    }
+    get expired() {
+        const current_date = new Date();
+        return ((this._key_expiration_date === undefined) ||
+            (current_date >= this._key_expiration_date));
+    }
+    get authenticated() {
+        return (this.id > 0);
+    }
+    get valid() {
+        return ((this._key !== '') &&
+            (this._key_expiration_date !== undefined) &&
+            (this.id >= 0));
+    }
+    updateUser(user_id) {
+        this.id = user_id;
+    }
+}
+
+class EsolveSessionService {
+    constructor(config) {
+        this.config = config;
+        this.storage_key = 'ngEslvUserSession';
+        this.setStorageKey();
+        this._session = new BehaviorSubject(new EsolveSession(0, ''));
+        this.session = this._session.asObservable();
+    }
+    get currentSession() {
+        return this._session.value;
+    }
+    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;
+        }
+    }
+    startTimer(callback, duration) {
+        this.key_expiration_timer = setTimeout(callback, duration);
+    }
+    clearTimer() {
+        if (this.key_expiration_timer) {
+            clearTimeout(this.key_expiration_timer);
+        }
+    }
+    restore(expirationCallback, invalidSessionCallback) {
+        if (!this.currentSession.valid) {
+            const stored_session_json = localStorage.getItem(this.storage_key);
+            const stored_session = (stored_session_json ? JSON.parse(stored_session_json) : null);
+            if (!stored_session) {
+                invalidSessionCallback();
+                return;
+            }
+            const expiration_date = new Date(stored_session._key_expiration_date);
+            const loaded_session = new EsolveSession(stored_session.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);
+            }
+            else {
+                expirationCallback(loaded_session);
+            }
+        }
+    }
+    handleSession(user_id, key, expiry_time, expires, expirationCallback) {
+        const expiration_date = new Date(expiry_time * 1000);
+        const session = new EsolveSession(user_id, key, expiration_date);
+        localStorage.setItem(this.storage_key, JSON.stringify(session));
+        this._session.next(session);
+        this.startTimer(expirationCallback, expires * 1000);
+    }
+    handleUpdateSession(user_id, callback) {
+        const current_session = this.currentSession;
+        current_session.updateUser(user_id);
+        localStorage.setItem(this.storage_key, JSON.stringify(current_session));
+        this._session.next(current_session);
+        if (typeof callback === 'function') {
+            callback();
+        }
+    }
+}
+EsolveSessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveSessionService, deps: [{ token: ESOLVE_CONNECT_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveSessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveSessionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveSessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }];
+    } });
+
+class EsolveAuthInterceptorService {
+    constructor(config, session) {
+        this.config = config;
+        this.session = session;
+    }
+    intercept(req, next) {
+        if (req.url.startsWith(`${this.config.api_url}/service/`)) {
+            const service_identifier = req.url.replace(`${this.config.api_url}/service/`, '');
+            const old_params_keys = req.params.keys();
+            const modified_url = req.url;
+            let params = new HttpParams();
+            const session = this.session.currentSession;
+            if (session.valid) {
+                if (service_identifier !== 'get-access-token.php') {
+                    params = params.set('key', session.key);
+                }
+            }
+            old_params_keys.forEach(key => {
+                params = params.set(key, req.params.get(key) || '');
+            });
+            const modified_req = req.clone({
+                url: modified_url,
+                params
+            });
+            return next.handle(modified_req);
+        }
+        return next.handle(req);
+    }
+}
+EsolveAuthInterceptorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveAuthInterceptorService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: EsolveSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveAuthInterceptorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveAuthInterceptorService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveAuthInterceptorService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: EsolveSessionService }];
+    } });
+
+class NgEsolveConnectModule {
+    static forRoot(config) {
+        return {
+            ngModule: NgEsolveConnectModule,
+            providers: [
+                {
+                    provide: ESOLVE_CONNECT_CONFIG,
+                    useValue: config
+                },
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: EsolveAuthInterceptorService,
+                    multi: true
+                }
+            ]
+        };
+    }
+}
+NgEsolveConnectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: NgEsolveConnectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgEsolveConnectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: NgEsolveConnectModule, imports: [CommonModule,
+        HttpClientModule] });
+NgEsolveConnectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: NgEsolveConnectModule, providers: [CookieService], imports: [[
+            CommonModule,
+            HttpClientModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: NgEsolveConnectModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule
+                    ],
+                    providers: [CookieService],
+                    exports: []
+                }]
+        }] });
+
+class EsolveHttpError {
+    constructor(type, message, error_code) {
+        this.type = type;
+        this.message = message;
+        this.error_code = error_code;
+    }
+}
+
+class EsolveErrorHandlerService {
+    constructor() { }
+    parseException(exception) {
+        const error = new EsolveHttpError('exception', exception.message || 'Unknown exception has occurred', exception.additional_data.exception_type || 'unknown');
+        return error;
+    }
+    parseErrors(response) {
+        const error = new EsolveHttpError('error', 'Unknown error has occurred', 'unknown');
+        if ((response.status.state === 'none') && (response.log.length > 0)) {
+            error.error_code = 'no_response';
+            error.message = 'Response was provided';
+        }
+        else if (response.status.state === 'error') {
+            const login_error_log = response.log[0];
+            error.error_code = login_error_log.message_code;
+            error.message = login_error_log.message;
+        }
+        return error;
+    }
+    handleHttpPostError(service_type, errorRes) {
+        if (errorRes instanceof HttpErrorResponse) {
+            if (errorRes.status === 500) {
+                const server_error = errorRes.error;
+                if ((server_error.service_type === service_type) ||
+                    (server_error.type !== undefined) ||
+                    (server_error.message !== undefined) ||
+                    (server_error.additional_data !== undefined)) {
+                    return throwError(this.parseException(server_error));
+                }
+            }
+        }
+        else {
+            if (errorRes.type !== undefined) {
+                if ((errorRes.type === 'exception') || (errorRes.type === 'error')) {
+                    return throwError(this.parseException(errorRes));
+                }
+            }
+            else if (errorRes.transaction_type !== undefined) {
+                return throwError(this.parseErrors(errorRes));
+            }
+        }
+        return throwError(errorRes);
+    }
+}
+EsolveErrorHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveErrorHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveErrorHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveErrorHandlerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveErrorHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+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 {
+    constructor() { }
+    /**
+     * 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: "13.0.0", ngImport: i0, type: EsolveResponseHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveResponseHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveResponseHandlerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveResponseHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+/**
+ * Search Engine Optimization information.
+ */
+class EsolveSEOInfo {
+    constructor(title = '', description = '', keywords = '') {
+        this.title = title;
+        this.description = description;
+        this.keywords = keywords;
+    }
+}
+
+class EsolveSeoService {
+    constructor(config, title, meta) {
+        this.config = config;
+        this.title = title;
+        this.meta = meta;
+        this.title_prefix = '';
+        this.title_suffix = '';
+        this.title_separator = '|';
+        this.default_seo_title = '';
+        this.default_seo_description = '';
+        this.default_seo_keywords = '';
+        this.init();
+    }
+    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;
+        }
+    }
+    setPageTitleTags(title) {
+        this.title.setTitle(title);
+        this.meta.updateTag({ property: 'og:title', content: title });
+    }
+    setPageDescriptionTags(description) {
+        this.meta.updateTag({ name: 'description', content: description });
+        this.meta.updateTag({ property: 'og:description', content: description });
+    }
+    setPageKeywordsTags(keywords) {
+        this.meta.updateTag({ name: 'keywords', content: keywords });
+    }
+    validateAndSanitizeSeoInfo(seoInfo) {
+        const pageSeo = new EsolveSEOInfo(this.default_seo_title, this.default_seo_description, this.default_seo_keywords);
+        if (seoInfo.description.trim() !== '') {
+            pageSeo.description = seoInfo.description;
+        }
+        if (seoInfo.title.trim() !== '') {
+            const titlePartsArray = [];
+            if (this.title_prefix !== '') {
+                titlePartsArray.push(this.title_prefix);
+                if (this.title_separator !== '') {
+                    titlePartsArray.push(this.title_separator);
+                }
+            }
+            titlePartsArray.push(seoInfo.title);
+            if (this.title_suffix !== '') {
+                if (this.title_separator !== '') {
+                    titlePartsArray.push(this.title_separator);
+                }
+                titlePartsArray.push(this.title_suffix);
+            }
+            pageSeo.title = titlePartsArray.join(' ');
+            if (seoInfo.keywords.trim() === '') {
+                const clean_title = seoInfo.title.replace(/[^a-zA-Z0-9\. ]+/gi, '').trim();
+                const keywords = clean_title.split(' ');
+                const clean_keywords = [];
+                for (let keyword of keywords) {
+                    keyword = keyword.trim();
+                    if (keyword.length > 2) {
+                        keyword = keyword.toLocaleLowerCase();
+                        if (!clean_keywords.includes(keyword)) {
+                            clean_keywords.push(keyword);
+                        }
+                    }
+                }
+                seoInfo.keywords = clean_keywords.join(',');
+            }
+        }
+        if (seoInfo.keywords.trim() !== '') {
+            pageSeo.keywords = seoInfo.keywords;
+        }
+        return pageSeo;
+    }
+    /**
+     * Sets SEO tags for page
+     * @param seoInfo SEO object
+     */
+    setTags(seoInfo) {
+        seoInfo = this.validateAndSanitizeSeoInfo(seoInfo);
+        this.setPageTitleTags(seoInfo.title);
+        this.setPageDescriptionTags(seoInfo.description);
+        this.setPageKeywordsTags(seoInfo.keywords);
+    }
+}
+EsolveSeoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveSeoService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1.Title }, { token: i1.Meta }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveSeoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveSeoService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveSeoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1.Title }, { type: i1.Meta }];
+    } });
+
+class EsolveAuthService {
+    constructor(config, http, session, errorHandler, cookieService) {
+        this.config = config;
+        this.http = http;
+        this.session = session;
+        this.errorHandler = errorHandler;
+        this.cookieService = cookieService;
+    }
+    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 : '';
+        const params = new HttpParams({
+            fromObject: {
+                key: token,
+                ws_id: this.config.wsid
+            }
+        });
+        return this.http.get(`${this.config.api_url}/service/get-access-token.php`, {
+            params,
+            headers: new HttpHeaders({
+                'Accept-Language': '*'
+            })
+        }).pipe(map(responseData => {
+            if ((responseData.type === 'error') ||
+                (responseData.type === 'exception') ||
+                (!responseData.additional_data.key_okay)) {
+                throw responseData;
+            }
+            responseData.additional_data.key = token;
+            return responseData;
+        })).toPromise();
+    }
+    getAccessToken(email, password, anonymous = false) {
+        let params = new HttpParams();
+        if (anonymous) {
+            params = params.set('anonymous', '1');
+        }
+        if (email !== '') {
+            params = params.set('email', email);
+        }
+        if (password !== '') {
+            params = params.set('password', password);
+        }
+        params = params.set('ws_id', this.config.wsid);
+        return this.http.get(`${this.config.api_url}/service/get-access-token.php`, {
+            params,
+            headers: new HttpHeaders({
+                'Accept-Language': '*'
+            })
+        }).pipe(tap(responseData => {
+            if ((responseData.type === 'error') ||
+                (responseData.type === 'exception')) {
+                throw responseData;
+            }
+        }), catchError(this.handleError), tap(responseData => {
+            this.handleAuthentication(responseData);
+        }));
+    }
+    autoLogin() {
+        this.session.restore(this.handleExpiration(), () => {
+            this.getAccessToken('', '', true).toPromise().then(_ => { }, error => {
+                console.log(error);
+            });
+        });
+    }
+    login(email, password) {
+        const body = {
+            login: {
+                email,
+                password
+            }
+        };
+        return this.http.post(`${this.config.api_url}/service/set-login.php`, body, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;'
+            },
+            params: {
+                ws_id: this.config.wsid
+            },
+            responseType: 'json',
+            observe: 'body'
+        }).pipe(map(response => {
+            if ((response.responses === undefined) ||
+                (response.responses.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')) {
+                    this.session.handleUpdateSession(login_response.esolve_id);
+                    return login_response.esolve_id;
+                }
+            }
+            throw login_response;
+        }), catchError((errorRes) => {
+            return this.errorHandler.handleHttpPostError('set-login', errorRes);
+        }));
+    }
+    logout() {
+        this.session.clearTimer();
+        this.cookieService.delete('_ws_id');
+        return this.getAccessToken('', '', true).toPromise();
+    }
+    // Handlers
+    handleExpiration() {
+        return (session) => {
+            this.checkAccessToken(session).then((response) => {
+                this.handleAuthentication(response);
+            }, () => {
+                this.logout();
+            });
+        };
+    }
+    handleAuthentication(responseData) {
+        if (responseData.additional_data.key) {
+            this.session.handleSession(responseData.additional_data.user_id, responseData.additional_data.key, +responseData.additional_data.expiry_time, +responseData.additional_data.expires, this.handleExpiration());
+        }
+    }
+    handleError(errorRes) {
+        const error = {
+            message: 'An unknown error occurred',
+            data: {}
+        };
+        if ((!errorRes.type) ||
+            (!errorRes.service_type) ||
+            (!errorRes.message)) {
+            return throwError(error);
+        }
+        if (errorRes.message.trim() !== '') {
+            error.message = errorRes.message;
+        }
+        if (errorRes.additional_data) {
+            error.data = errorRes.additional_data;
+        }
+        return throwError(error);
+    }
+}
+EsolveAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveAuthService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }, { token: EsolveSessionService }, { token: EsolveErrorHandlerService }, { token: i4.CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveAuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }, { type: EsolveSessionService }, { type: EsolveErrorHandlerService }, { type: i4.CookieService }];
+    } });
+
+class EsolveAddress {
+    constructor(id, recipient, address_type, pobox, place_name, street_number, street, suburb, city, province, country, postal_code, latitude, longitude) {
+        this.id = id;
+        this.recipient = recipient;
+        this.address_type = address_type;
+        this.pobox = pobox;
+        this.place_name = place_name;
+        this.street_number = street_number;
+        this.street = street;
+        this.suburb = suburb;
+        this.city = city;
+        this.province = province;
+        this.country = country;
+        this.postal_code = postal_code;
+        this.latitude = latitude;
+        this.longitude = longitude;
+    }
+}
+
+class EsolveAddressResult extends EsolveResponseResult {
+    constructor(response) {
+        super(response);
+        this.id = response.esolve_id;
+        this.address_validated = response.address_validated;
+        this.geocode_status = response.geocode_status;
+        this.geocode_result = response.geocode_result;
+    }
+}
+
+class EsolveUserAccount {
+    constructor(esolve_id, email, registration_type, title, first_name, last_name, initials, gender, identification_number) {
+        this.esolve_id = esolve_id;
+        this.email = email;
+        this.registration_type = registration_type;
+        this.title = title;
+        this.first_name = first_name;
+        this.last_name = last_name;
+        this.initials = initials;
+        this.gender = gender;
+        this.identification_number = identification_number;
+    }
+}
+class EsolveUserAccountBusiness {
+    constructor(name, vat_number, description, type) {
+        this.name = name;
+        this.vat_number = vat_number;
+        this.description = description;
+        this.type = type;
+    }
+}
+class EsolveUserAccountContact {
+    constructor(tel_number, cell_number, fax_number) {
+        this.tel_number = tel_number;
+        this.cell_number = cell_number;
+        this.fax_number = fax_number;
+    }
+}
+
+class EsolveUserAccountResult extends EsolveResponseResult {
+    constructor(response) {
+        super(response);
+        this.id = 0;
+        this.id = +response.esolve_id;
+    }
+}
+
+class EsolveRegistrationResult extends EsolveResponseResult {
+    constructor(response) {
+        super(response);
+        this.user_id = response.esolve_id;
+        this.guest = response.guest;
+        this.auto_login = response.auto_login;
+        this.authentication_required = response.authentication_required;
+    }
+}
+
+class EsolveAccountService {
+    constructor(config, http, sessionService, errorHandler, responseHandler) {
+        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;
+            }
+        });
+    }
+    get user_id() {
+        return this._user_id;
+    }
+    set user_id(value) {
+        value = ((value > 0) ? value : 0);
+        if (this._user_id !== value) {
+            this._user_id = value;
+        }
+    }
+    processUserAccount(record) {
+        if (!record) {
+            throw new Error('Invalid record');
+        }
+        if (+record.userid !== this._user_id) {
+            throw new Error('Invalid user account retrieved');
+        }
+        const user_account = new EsolveUserAccount(+record.userid, record.email, record.registration_type, record.title, record.firstname, record.surname, record.initials, record.gender, record.idnumber);
+        user_account.contact_details = new EsolveUserAccountContact(record.telnumber, record.cellnumber, record.fax);
+        user_account.business_details = new EsolveUserAccountBusiness(record.busname, record.vatnum, record.busdescript, record.business_type);
+        return user_account;
+    }
+    processUserAddress(records) {
+        const user_addresses = [];
+        if (!records || (this._user_id === 0)) {
+            return user_addresses;
+        }
+        for (const record of records) {
+            if (+record.userid !== this._user_id) {
+                continue;
+            }
+            user_addresses.push(new EsolveAddress(+record.id, record.recipient, record.address_type, record.pobox, record.place_name, record.street_number, record.street, record.suburb, record.city, record.province, record.country, record.postal_code, +record.latitude, +record.longitude));
+        }
+        return user_addresses;
+    }
+    updateUserAccount(user_account_data) {
+        const body = {
+            account: user_account_data
+        };
+        return this.http.post(`${this.config.api_url}/service/set-user-account.php`, body, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;'
+            },
+            params: {
+                ws_id: this.config.wsid
+            },
+            responseType: 'json',
+            observe: 'body'
+        }).pipe(map((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}/service/get-account.php`, {
+            params: {
+                ws_id: this.config.wsid
+            }
+        }).pipe(map(response => {
+            if ((response.records === undefined) ||
+                (response.records.length === 0)) {
+                throw response;
+            }
+            const record = response.records[0];
+            return this.processUserAccount(record);
+        }));
+    }
+    setAddress(address_post_data) {
+        const body = {
+            address: address_post_data
+        };
+        return this.http.post(`${this.config.api_url}/service/set-address.php`, body, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;'
+            },
+            params: {
+                ws_id: this.config.wsid
+            },
+            responseType: 'json',
+            observe: 'body'
+        }).pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveAddressResult(response))), catchError((errorRes) => {
+            return this.errorHandler.handleHttpPostError('set-registration', errorRes);
+        }));
+    }
+    getAddresses() {
+        if (this.user_id <= 0) {
+            return throwError('Log in is required');
+        }
+        return this.http.get(`${this.config.api_url}/service/get-addresses.php`, {
+            params: {
+                ws_id: this.config.wsid,
+                user_id: this.user_id
+            }
+        }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processUserAddress(response.records);
+        }));
+    }
+    register(user_registration) {
+        const body = {
+            user: user_registration
+        };
+        return this.http.post(`${this.config.api_url}/service/set-registration.php`, body, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;'
+            },
+            params: {
+                ws_id: this.config.wsid
+            },
+            responseType: 'json',
+            observe: 'body'
+        }).pipe(map(http_response => this.responseHandler.validateSingleHttpResponse(http_response, (response) => {
+            if (response.auto_login) {
+                this.sessionService.handleUpdateSession(response.esolve_id);
+            }
+            return new EsolveRegistrationResult(response);
+        })), catchError((errorRes) => {
+            return this.errorHandler.handleHttpPostError('set-registration', errorRes);
+        }));
+    }
+}
+EsolveAccountService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveAccountService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }, { token: EsolveSessionService }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveAccountService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveAccountService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveAccountService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }, { type: EsolveSessionService }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
+    } });
+
+class EsolveMediaArticle {
+    constructor(identifier, title, article, image_url = '', tags = [], topics = [], seo_title = '', seo_keywords = '', seo_description = '') {
+        this.identifier = identifier;
+        this.title = title;
+        this.article = article;
+        this.image_url = image_url;
+        this.tags = tags;
+        this.topics = topics;
+        if (seo_title.trim() === '') {
+            seo_title = this.title;
+        }
+        this.seo_details = new EsolveSEOInfo(seo_title, seo_description, seo_keywords);
+    }
+}
+
+class EsolveTag {
+    constructor(id, tag_phrase, tag_weight, description) {
+        this.id = id;
+        this.tag_phrase = tag_phrase;
+        this.tag_weight = tag_weight;
+        this.description = description;
+    }
+}
+
+class EsolveTopic {
+    constructor(id, name, short_description, sort_priority) {
+        this.id = id;
+        this.name = name;
+        this.short_description = short_description;
+        this.sort_priority = sort_priority;
+    }
+}
+
+class EsolveMediaService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    processMediaRecord(record) {
+        const tags = [];
+        const topics = [];
+        if ((record.tags) && (record.tags.length > 0)) {
+            for (const tag of record.tags) {
+                tags.push(new EsolveTag(+tag.id, tag.tag_phrase, +tag.tag_weight, tag.description));
+            }
+        }
+        if ((record.topics) && (record.topics.length > 0)) {
+            for (const topic of record.topics) {
+                topics.push(new EsolveTopic(+topic.id, topic.name, topic.short_description, +topic.sort_priority));
+            }
+        }
+        return new EsolveMediaArticle(record.identifier, record.title, record.article, record.image_url, tags, topics, record.seo_page_title, record.seo_keywords, record.seo_description);
+    }
+    /**
+     * Retrieves media records from eSolve instance.
+     * @param params Header params
+     */
+    getMediaRecords(params) {
+        params = params.set('ws_id', this.config.wsid);
+        return this.http.get(`${this.config.api_url}/service/get-media.php`, { params });
+    }
+    /**
+     * Retrieves the media record from the eSolve instance using the identifier.
+     * @param identifier String representing the eSolve media indentifier
+     */
+    getMediaArticle(identifier) {
+        const params = new HttpParams({
+            fromObject: {
+                identifier
+            }
+        });
+        // TODO: Error Handling
+        return this.getMediaRecords(params).pipe(map(response => {
+            if ((response.records === undefined) || (response.records.length <= 0)) {
+                throw response;
+            }
+            const mediaRecord = response.records[0];
+            if (!mediaRecord.active) {
+                throw response;
+            }
+            return this.processMediaRecord(mediaRecord);
+        }));
+    }
+    /**
+     * Retrieves a group of media records from the eSolve instance linked to a group.
+     * @param media_group String representing the eSolve media group
+     */
+    getGroupedMediaArticles(media_group) {
+        const params = new HttpParams({
+            fromObject: {
+                media_group_sef: media_group
+            }
+        });
+        return this.getMediaRecords(params).pipe(map(response => {
+            const mediaArticles = [];
+            if ((response.records !== undefined) && (response.records.length > 0)) {
+                for (const mediaRecord of response.records) {
+                    if (mediaRecord.active) {
+                        mediaArticles.push(this.processMediaRecord(mediaRecord));
+                    }
+                }
+            }
+            return mediaArticles;
+        }));
+    }
+}
+EsolveMediaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveMediaService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveMediaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveMediaService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveMediaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }];
+    } });
+
+class EsolveNewsArticle {
+    constructor(id, title, sef_title, article, short_description, txdate, active, image, featured, author, seo_title = '', seo_keywords = '') {
+        this.id = id;
+        this.title = title;
+        this.sef_title = sef_title;
+        this.article = article;
+        this.short_description = short_description;
+        this.txdate = txdate;
+        this.active = active;
+        this.image = image;
+        this.featured = featured;
+        this.author = author;
+        if (seo_title.trim() === '') {
+            seo_title = this.title;
+        }
+        this.seo_details = new EsolveSEOInfo(seo_title, short_description, seo_keywords);
+    }
+}
+
+class EsolveNewsGroup {
+    constructor(id, name, description, sef_name) {
+        this.id = id;
+        this.name = name;
+        this.description = description;
+        this.sef_name = sef_name;
+    }
+}
+
+class EsolveNewsArticleList {
+    constructor(newsArticles, total, page) {
+        this.newsArticles = newsArticles;
+        this.total = total;
+        this.page = page;
+    }
+}
+
+class EsolveNewsArticleAuthor {
+    constructor(userid, email, firstname, surname) {
+        this.userid = userid;
+        this.email = email;
+        this.firstname = firstname;
+        this.surname = surname;
+    }
+}
+
+class EsolveNewsService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    getNewsRecords(params) {
+        params = params.set('ws_id', this.config.wsid);
+        return this.http.get(`${this.config.api_url}/service/get-news.php`, { params });
+    }
+    getNewsArticle(identifier) {
+        const params = new HttpParams({
+            fromObject: {
+                sef_title: identifier
+            }
+        });
+        return this.getNewsRecords(params).pipe(map(response => {
+            if ((response.records === undefined) || (response.records.length <= 0)) {
+                throw response;
+            }
+            const newsRecord = response.records[0];
+            if (!newsRecord.active) {
+                throw response;
+            }
+            return this.processNewsArticle(newsRecord);
+        }));
+    }
+    getNewsArticles(options) {
+        let params = new HttpParams();
+        if (options.news_group_id) {
+            params = params.set('news_group_id', options.news_group_id.toString());
+        }
+        else if (options.news_group_sef) {
+            params = params.set('news_group_sef', options.news_group_sef.toString());
+        }
+        if (options.page) {
+            params = params.set('page', options.page.toString());
+        }
+        if (options.rows) {
+            params = params.set('rows', options.rows.toString());
+        }
+        if (options.feature_only) {
+            params = params.set('feature_only', options.feature_only.toString());
+        }
+        if (options.manufacturers_id) {
+            params = params.set('manufacturers_id', options.manufacturers_id.toString());
+        }
+        if (options.ranges_id) {
+            params = params.set('ranges_id', options.ranges_id.toString());
+        }
+        if (options.from_date) {
+            params = params.set('from_date', options.from_date.toString());
+        }
+        if (options.to_date) {
+            params = params.set('to_date', options.to_date.toString());
+        }
+        return this.getNewsRecords(params).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            const newsArticles = [];
+            response.records.forEach(newsArticleRecord => {
+                newsArticles.push(this.processNewsArticle(newsArticleRecord));
+            });
+            return new EsolveNewsArticleList(newsArticles, response.additional_data.total_records, options.page || 0);
+        }));
+    }
+    getNewsGroups() {
+        let params = new HttpParams();
+        params = params.set('ws_id', this.config.wsid);
+        return this.http.get(`${this.config.api_url}/service/get-news-groups.php`, { params }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            const newsGroups = [];
+            response.records.forEach(newsGroupRecord => {
+                newsGroups.push(new EsolveNewsGroup(newsGroupRecord.id, newsGroupRecord.name, newsGroupRecord.description, newsGroupRecord.sef_name));
+            });
+            return newsGroups;
+        }));
+    }
+    processNewsArticle(newsRecord) {
+        const author = new EsolveNewsArticleAuthor(newsRecord.user.userid, newsRecord.user.email, newsRecord.user.firstname, newsRecord.user.surname);
+        return new EsolveNewsArticle(newsRecord.id, newsRecord.title, newsRecord.sef_title, newsRecord.article, newsRecord.short_description, newsRecord.txdate, newsRecord.active, newsRecord.image, newsRecord.featured, author, newsRecord.seo_page_title, newsRecord.seo_keywords);
+    }
+}
+EsolveNewsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveNewsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveNewsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveNewsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveNewsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }];
+    } });
+
+class EsolveBanner {
+    constructor(id, banner_display_container, identifier, type, title, article, sort_priority, link, images) {
+        this.id = id;
+        this.banner_display_container = banner_display_container;
+        this.identifier = identifier;
+        this.type = type;
+        this.title = title;
+        this.article = article;
+        this.sort_priority = sort_priority;
+        this.link = link;
+        this.desktop_images = [];
+        this.mobile_images = [];
+        this.sub_images = [];
+        if (images.desktop) {
+            this.desktop_images = images.desktop;
+        }
+        if (images.mobile) {
+            this.mobile_images = images.mobile;
+        }
+        if (images.sub) {
+            this.sub_images = images.sub;
+        }
+    }
+}
+
+class EsolveBannerImage {
+    constructor(id, image_type, width, height, filename, hotspots) {
+        this.id = id;
+        this.image_type = image_type;
+        this.width = width;
+        this.height = height;
+        this.filename = filename;
+        this.hotspots = hotspots;
+    }
+    get src() {
+        return '/images/banners/' + this.filename;
+    }
+}
+
+class EsolveBannerImageHotspot {
+    constructor(url, target, coords, coords_string) {
+        this.url = url;
+        this.target = target;
+        this.coords = coords;
+        this.coords_string = coords_string;
+    }
+}
+
+class EsolveBannerService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    processBannerImageHotspots(hotspot_records) {
+        const hotspots = [];
+        if (hotspot_records.length > 0) {
+            for (const hotspot_record of hotspot_records) {
+                const hotspot = new EsolveBannerImageHotspot(hotspot_record.url, hotspot_record.target, hotspot_record.coords, hotspot_record.coords_string);
+                hotspots.push(hotspot);
+            }
+        }
+        return hotspots;
+    }
+    processBannerImages(image_records, banner_type) {
+        const images = [];
+        if (image_records.length > 0) {
+            for (const image_record of image_records) {
+                const image = new EsolveBannerImage(+image_record.id, image_record.image_type, +image_record.width, +image_record.height, image_record.filename);
+                if ((banner_type === 'hotspot') && (image_record.hotspots)) {
+                    const hotspots = this.processBannerImageHotspots(image_record.hotspots);
+                    image.hotspots = hotspots;
+                }
+                images.push(image);
+            }
+        }
+        return images;
+    }
+    /**
+     * Process banner records into banner objects
+     * @param records Array of records
+     * @returns List of banners
+     */
+    processBanners(records) {
+        const banners = [];
+        if ((records) && (records.length > 0)) {
+            for (const record of records) {
+                const image_sets = {};
+                if (record.images.desktop) {
+                    image_sets.desktop = this.processBannerImages(record.images.desktop, record.type);
+                }
+                if (record.images.mobile) {
+                    image_sets.mobile = this.processBannerImages(record.images.mobile, record.type);
+                }
+                if (record.images.sub) {
+                    image_sets.sub = this.processBannerImages(record.images.sub, record.type);
+                }
+                const banner = new EsolveBanner(+record.id, record.banner_display_container, record.identifier, record.type, record.title, record.article, +record.sort_priority, {
+                    url: record.link.url,
+                    target: record.link.target
+                }, image_sets);
+                banners.push(banner);
+            }
+        }
+        return banners;
+    }
+    /**
+     * Retrieves banners records from eSolve instance
+     *
+     * @returns An observable of eSolve banners.
+     */
+    getBanners(identifier, banner_display_container, enable_date_filter = false) {
+        let params = new HttpParams({
+            fromObject: {
+                ws_id: this.config.wsid,
+                enable_date_filter
+            }
+        });
+        if (identifier) {
+            params = params.set('identifier', identifier);
+        }
+        if (banner_display_container) {
+            params = params.set('banner_display_container', banner_display_container);
+        }
+        return this.http.get(`${this.config.api_url}/service/get-banners.php`, { params }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processBanners(response.records);
+        }));
+    }
+}
+EsolveBannerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveBannerService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveBannerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveBannerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveBannerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }];
+    } });
+
+class EsolveMenuItem {
+    constructor(url, name, target, children = []) {
+        this.url = url;
+        this.name = name;
+        this.target = target;
+        this.children = children;
+    }
+}
+
+class EsolveMenuService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    getMenuTree(identifier) {
+        let menuParams = new HttpParams();
+        menuParams = menuParams.set('identifier', identifier);
+        menuParams = menuParams.set('ws_id', this.config.wsid);
+        return this.http.get(`${this.config.api_url}/service/get-menu-tree.php`, { params: menuParams }).pipe(map(response => {
+            if ((!response) || (response.records === undefined)) {
+                throw response;
+            }
+            else if (response.records.length === 0) {
+                return [];
+            }
+            return this.handleMenu(response.records);
+        }));
+    }
+    handleMenu(records) {
+        const menu = [];
+        if (typeof records !== 'undefined') {
+            for (const menuTreeRecord of records) {
+                menu.push(new EsolveMenuItem(menuTreeRecord.sef_url, menuTreeRecord.name, menuTreeRecord.target, this.handleMenu(menuTreeRecord.children)));
+            }
+        }
+        return menu;
+    }
+}
+EsolveMenuService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveMenuService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveMenuService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveMenuService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveMenuService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }];
+    } });
+
+class EsolveTopicService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    processTopics(records) {
+        const topics = [];
+        if (records) {
+            for (const record of records) {
+                const topic = new EsolveTopic(+record.id, record.name, record.short_description, +record.sort_priority);
+                topics.push(topic);
+            }
+        }
+        return topics;
+    }
+    /**
+     * Retrieves active topics from the list of topic ID's. Note that inactive or expired
+     * topics will not be retrieved.
+     *
+     * @param topic_id_list List of topic ID's that need to be retrieved
+     */
+    getTopics(topic_id_list = []) {
+        let params = new HttpParams({
+            fromObject: {
+                ws_id: this.config.wsid
+            }
+        });
+        if (topic_id_list.length > 0) {
+            params = params.append('topic_id', topic_id_list.join(','));
+        }
+        return this.http.get(`${this.config.api_url}/service/get-topics.php`, { params }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processTopics(response.records);
+        }));
+    }
+}
+EsolveTopicService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", 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: "13.0.0", ngImport: i0, type: EsolveTopicService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveTopicService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }];
+    } });
+
+class EsolveStockBadge {
+    constructor(id, text, identifier, font_colour, badge_colour, sort_priority) {
+        this.id = id;
+        this.text = text;
+        this.identifier = identifier;
+        this.font_colour = font_colour;
+        this.badge_colour = badge_colour;
+        this.sort_priority = sort_priority;
+    }
+}
+
+/**
+ * Price of eSolve stock item
+ */
+class EsolveStockPrice {
+    /**
+     * Create stock price instance
+     * @param base_price Price without tax
+     * @param base_price_with_tax Price with tax
+     * @param sell_price Price without tax and with discounts applied if appilcable
+     * @param sell_price_with_tax Price with tax and with discounts applied if appilcable
+     */
+    constructor(
+    /**
+     * Price without tax
+     */
+    base_price, 
+    /**
+     * Price with tax
+     */
+    base_price_with_tax, 
+    /**
+     * Price without tax and with discounts applied if appilcable
+     */
+    sell_price, 
+    /**
+     * Price with tax and with discounts applied if appilcable
+     */
+    sell_price_with_tax) {
+        this.base_price = base_price;
+        this.base_price_with_tax = base_price_with_tax;
+        this.sell_price = sell_price;
+        this.sell_price_with_tax = sell_price_with_tax;
+        if ((this.base_price === 0) && (this.sell_price > 0)) {
+            this.base_price = this.sell_price;
+            this.base_price_with_tax = this.sell_price_with_tax;
+        }
+        else if ((this.base_price > 0) && (this.sell_price === 0)) {
+            this.sell_price = this.base_price;
+            this.sell_price_with_tax = this.base_price_with_tax;
+        }
+    }
+}
+
+/**
+ * Stock Item object. It can be a service or a product (physical and/or digital).
+ */
+class EsolveStockItem {
+    /**
+     * Constructs an instance of EsolveStockItem
+     *
+     * @param id eSolve Generated ID
+     * @param code Code identifying the stock item
+     * @param name Name of the stock item
+     * @param sef_name Search engine friendly name
+     * @param description Short description of stock item
+     * @param active Active state
+     * @param featured Featured state
+     * @param image_name Image filename
+     * @param price Default price
+     * @param tags Linked tags
+     * @param topics Linked topics
+     * @param seo_title SEO page title
+     * @param seo_keywords SEO page keywords
+     */
+    constructor(
+    /**
+     * eSolve Generated ID
+     */
+    id, 
+    /**
+     * Code identifying the stock item
+     */
+    code, 
+    /**
+     * Name of the stock item
+     */
+    name, 
+    /**
+     * Search engine friendly name
+     */
+    sef_name, 
+    /**
+     * Short description of stock item
+     */
+    description, 
+    /**
+     * Active state
+     */
+    active, 
+    /**
+     * Featured state
+     */
+    featured, 
+    /**
+     * Image filename
+     */
+    image_name, 
+    /**
+     * Default price
+     */
+    price, 
+    /**
+     * Linked tags
+     */
+    tags, 
+    /**
+     * Linked topics
+     */
+    topics, 
+    /**
+     * Stock badges
+     */
+    badges, 
+    /**
+     * ID of default category linked to the stock item
+     */
+    category_id, 
+    /**
+     * ID of default subcategory linked to the stock item
+     */
+    subcategory_id, seo_title = '', seo_keywords = '') {
+        this.id = id;
+        this.code = code;
+        this.name = name;
+        this.sef_name = sef_name;
+        this.description = description;
+        this.active = active;
+        this.featured = featured;
+        this.image_name = image_name;
+        this.price = price;
+        this.tags = tags;
+        this.topics = topics;
+        this.badges = badges;
+        this.category_id = category_id;
+        this.subcategory_id = subcategory_id;
+        if (seo_title.trim() === '') {
+            seo_title = this.name;
+        }
+        this.seo_details = new EsolveSEOInfo(seo_title, description, seo_keywords);
+    }
+    /**
+     * Path to tiny stock image
+     */
+    get tiny_image_src() {
+        return '/images/' + (this.image_name ? 'stock/tiny/' + this.image_name : 'no_image.jpg');
+    }
+    /**
+     * Path to thumbnail stock image
+     */
+    get thumbnail_image_src() {
+        return '/images/' + (this.image_name ? 'stock/thumb/' + this.image_name : 'no_image.jpg');
+    }
+    /**
+     * Path to small stock image
+     */
+    get small_image_src() {
+        return '/images/' + (this.image_name ? 'stock/small/' + this.image_name : 'no_image.jpg');
+    }
+    /**
+     * Path to big stock image
+     */
+    get big_image_src() {
+        return '/images/' + (this.image_name ? 'stock/big/' + this.image_name : 'no_image.jpg');
+    }
+    /**
+     * Path to original stock image
+     */
+    get original_image_src() {
+        return '/images/' + (this.image_name ? 'stock/original/' + this.image_name : 'no_image.jpg');
+    }
+}
+
+/**
+ * Stock item object list
+ */
+class EsolveStockItemList {
+    constructor(stock_items, total, page) {
+        this.stock_items = stock_items;
+        this.total = total;
+        this.page = page;
+    }
+}
+
+class EsolveStockService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    /**
+     * Processes the eSolve stock item record and converts it to StockItem object.
+     * @param record eSolve stock item record
+     */
+    processStockItem(record) {
+        const tags = [];
+        const topics = [];
+        const badges = [];
+        if ((record.tags) && (record.tags.length > 0)) {
+            for (const tag of record.tags) {
+                tags.push(new EsolveTag(+tag.id, tag.tag_phrase, +tag.tag_weight, tag.description));
+            }
+        }
+        if ((record.topics) && (record.topics.length > 0)) {
+            for (const topic of record.topics) {
+                topics.push(new EsolveTopic(+topic.id, topic.name, topic.short_description, +topic.sort_priority));
+            }
+        }
+        if ((record.badges) && (record.badges.length > 0)) {
+            for (const badge of record.badges) {
+                badges.push(new EsolveStockBadge(+badge.id, badge.text, badge.identifier, badge.font_colour, badge.badge_colour, +badge.sort_priority));
+            }
+        }
+        const price = new EsolveStockPrice(record.regular_sellprice, record.regular_sellprice_inclusive, record.sellprice, record.sellprice_inclusive);
+        return new EsolveStockItem(+record.id, record.code, record.name, record.sef_name, record.description, !!+record.is_active, !!+record.is_featured, record.image_name, price, tags, topics, badges, record.category_id, +record.subcategory_id, record.seo_page_title, record.seo_keywords);
+    }
+    /**
+     * Retrieves stock records from HTTP params.
+     * @param params HTTP client parameters
+     */
+    getStockRecords(params) {
+        params = params.set('ws_id', this.config.wsid);
+        return this.http.get(`${this.config.api_url}/service/get-items.php`, { params });
+    }
+    /**
+     * Retrieves the stock record from the eSolve instance using the code.
+     * @param code eSolve stock code
+     */
+    getStockItem(code) {
+        const params = new HttpParams({
+            fromObject: {
+                code
+            }
+        });
+        return this.getStockRecords(params).pipe(map(response => {
+            if ((response.records === undefined) || (response.records.length <= 0)) {
+                throw response;
+            }
+            const stockRecord = response.records[0];
+            return this.processStockItem(stockRecord);
+        }));
+    }
+    /**
+     * Retrieves the stock record from the eSolve instance using the SEF name.
+     * @param sef_name SEF name of the stock item
+     */
+    getStockItemFromSEF(sef_name) {
+        const params = new HttpParams({
+            fromObject: {
+                sef_name
+            }
+        });
+        return this.getStockRecords(params).pipe(map(response => {
+            if ((response.records === undefined) || (response.records.length <= 0)) {
+                throw response;
+            }
+            const stockRecord = response.records[0];
+            return this.processStockItem(stockRecord);
+        }));
+    }
+    /**
+     * Retrieves list of stock from the eSolve instance using info provided
+     * @param options Stock filter options
+     */
+    getStockItems(options) {
+        let params = new HttpParams();
+        if (options.page) {
+            params = params.set('page', options.page);
+        }
+        if (options.rows) {
+            params = params.set('rows', options.rows);
+        }
+        if (options.display_only) {
+            params = params.set('display_only', options.display_only);
+        }
+        if (options.is_active) {
+            params = params.set('is_active', options.is_active);
+        }
+        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.tag_id_list) {
+            if (options.tag_id_list.length > 0) {
+                params = params.set('tag_id', options.tag_id_list.join(','));
+            }
+        }
+        if (options.topic_id_list) {
+            if (options.topic_id_list.length > 0) {
+                params = params.set('topic_id', options.topic_id_list.join(','));
+            }
+        }
+        return this.getStockRecords(params).pipe(map(response => {
+            var _a;
+            if ((response.records === undefined) || (response.records.length <= 0)) {
+                throw response;
+            }
+            const stockItems = [];
+            response.records.forEach(stockRecord => {
+                stockItems.push(this.processStockItem(stockRecord));
+            });
+            return new EsolveStockItemList(stockItems, +response.additional_data.total_records, (_a = options.page) !== null && _a !== void 0 ? _a : 0);
+        }));
+    }
+}
+EsolveStockService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", 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: "13.0.0", ngImport: i0, type: EsolveStockService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveStockService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }];
+    } });
+
+class EsolveCategoryTreeItem {
+    constructor(type, esolve_id, parent_id, description, sef_description, short_description, sort_priority, active, display_only, image_name, seo_title, seo_keywords, seo_description, children) {
+        this.type = type;
+        this.esolve_id = esolve_id;
+        this.parent_id = parent_id;
+        this.description = description;
+        this.sef_description = sef_description;
+        this.short_description = short_description;
+        this.sort_priority = sort_priority;
+        this.active = active;
+        this.display_only = display_only;
+        this.image_name = image_name;
+        this.image_path = '';
+        this.id = '';
+        if (this.type === 'category') {
+            this.id = `<<CAT>>${this.esolve_id}`;
+            if (children != null) {
+                this.children = children;
+            }
+            this.image_path = '/images/categories/';
+        }
+        else {
+            this.id = `<<SUB>>${this.esolve_id}`;
+            this.image_path = '/images/subcategories/';
+        }
+        if (seo_title.trim() === '') {
+            seo_title = this.description;
+        }
+        this.seo_details = new EsolveSEOInfo(seo_title, seo_description, seo_keywords);
+    }
+    generateImagePath(image_size) {
+        if (this.image_name !== '') {
+            return `${this.image_path}${image_size}/${this.image_name}`;
+        }
+        return '';
+    }
+    get small_image_src() {
+        return this.generateImagePath('small');
+    }
+    get thumbnail_image_src() {
+        return this.generateImagePath('thumb');
+    }
+    get tiny_image_src() {
+        return this.generateImagePath('tiny');
+    }
+}
+
+class EsolveCategoryTreeService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    /**
+     * Processes the eSolve tree records and converts them into the correct format.
+     * @param tree_records Records to process
+     */
+    processTree(tree_records) {
+        const tree_items = [];
+        if (tree_records) {
+            for (const tree_record of tree_records) {
+                let esolve_id = '';
+                let parent_id = '';
+                let children = [];
+                if (tree_record.type === 'category') {
+                    children = this.processTree(tree_record.children);
+                    esolve_id = tree_record.menu_id;
+                    parent_id = tree_record.owner_menu_id;
+                }
+                else {
+                    esolve_id = tree_record.id;
+                    parent_id = tree_record.menu_id;
+                }
+                tree_items.push(new EsolveCategoryTreeItem(tree_record.type, esolve_id, parent_id, tree_record.description, tree_record.sef_description, tree_record.seo_description, tree_record.sort_priority, tree_record.active, tree_record.display_only, tree_record.image, tree_record.seo_page_title, tree_record.seo_keywords, tree_record.short_description, children));
+            }
+        }
+        return tree_items;
+    }
+    processTreeItem(record) {
+        return new EsolveCategoryTreeItem(record.type, record.id, record.parent_id, record.description, record.sef_description, record.short_description, record.sort_priority, record.active, record.display_only, '', record.seo_page_title, record.seo_keywords, record.seo_description);
+    }
+    processID(id) {
+        let type;
+        let esolve_id;
+        const type_code_regex = /^\<\<(CAT|SUB)\>\>/g;
+        const match_results = id.match(type_code_regex);
+        if (match_results) {
+            const type_code = match_results[0];
+            type = (type_code === '<<CAT>>' ? 'category' : 'subcategory');
+            esolve_id = id.replace(type_code_regex, '');
+            return {
+                type,
+                esolve_id
+            };
+        }
+        return null;
+    }
+    /**
+     * Retrieves the category tree from eSolve instance and coverts it to the correct format.
+     */
+    getCategoryTree() {
+        let params = new HttpParams();
+        params = params.set('ws_id', this.config.wsid);
+        return this.http.get(`${this.config.api_url}/service/get-tree.php`, { params }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processTree(response.records);
+        }));
+    }
+    /**
+     * Retrieve the details of a category tree item from the eSolve instance and converts it to the correct format.
+     * @param options Filter options
+     */
+    getCategoryTreeItem(options) {
+        let type;
+        let esolve_id;
+        let sef_description;
+        if (options.id) {
+            const categoryIdentifier = this.processID(options.id);
+            if (categoryIdentifier) {
+                type = categoryIdentifier.type;
+                esolve_id = categoryIdentifier.esolve_id;
+            }
+        }
+        else if (options.type) {
+            type = options.type;
+            if (options.esolve_id) {
+                esolve_id = options.esolve_id;
+            }
+            else if (options.sef_description) {
+                sef_description = options.sef_description;
+            }
+        }
+        if (type && (esolve_id || sef_description)) {
+            let params = new HttpParams();
+            params = params.set('ws_id', this.config.wsid.toString());
+            params = params.set('type', type.toString());
+            if (esolve_id) {
+                params = params.set('id', esolve_id.toString());
+            }
+            if (sef_description) {
+                params = params.set('sef_description', sef_description.toString());
+            }
+            return this.http.get(`${this.config.api_url}/service/get-tree-item.php`, { params }).pipe(map(response => {
+                if ((response.records === undefined) || (response.records.length <= 0)) {
+                    throw response;
+                }
+                return this.processTreeItem(response.records[0]);
+            }));
+        }
+        return throwError('Invalid options');
+    }
+}
+EsolveCategoryTreeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveCategoryTreeService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveCategoryTreeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveCategoryTreeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveCategoryTreeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }];
+    } });
+
+class EsolveCartItem {
+    constructor(id, stock_item, qty, type, price, discount, discount_interval, vat_rate, allow_quotes, allow_orders, must_collect, requested_assembly, price_incl, discount_price, discount_price_incl, discount_total, vat_total, total, total_incl) {
+        this.id = id;
+        this.stock_item = stock_item;
+        this.qty = qty;
+        this.type = type;
+        this.price = price;
+        this.discount = discount;
+        this.discount_interval = discount_interval;
+        this.vat_rate = vat_rate;
+        this.allow_quotes = allow_quotes;
+        this.allow_orders = allow_orders;
+        this.must_collect = must_collect;
+        this.requested_assembly = requested_assembly;
+        this.price_incl = price_incl;
+        this.discount_price = discount_price;
+        this.discount_price_incl = discount_price_incl;
+        this.discount_total = discount_total;
+        this.vat_total = vat_total;
+        this.total = total;
+        this.total_incl = total_incl;
+    }
+}
+
+/**
+ * Totals in cart
+ */
+class EsolveCartTotals {
+    constructor(
+    /**
+     * Number of unique records in cart
+     */
+    records = 0, 
+    /**
+     * Total quantity of all items in a cart
+     */
+    items = 0, 
+    /**
+     * Total in cart before discount and VAT is added
+     */
+    sub_total = 0, 
+    /**
+     * Total VAT of all the items in the cart
+     */
+    vat_total = 0, 
+    /**
+     * Total discount of all the item in the cart
+     */
+    discount_total = 0) {
+        this.records = records;
+        this.items = items;
+        this.sub_total = sub_total;
+        this.vat_total = vat_total;
+        this.discount_total = discount_total;
+    }
+    /**
+     * Grand total of cart which includes discount and VAT (NOTE: shipping and insurance is not included)
+     */
+    get total() {
+        return this.sub_total + this.vat_total - this.discount_total;
+    }
+}
+
+class EsolveCheckoutResult extends EsolveResponseResult {
+    constructor(response) {
+        super(response);
+        this.id = 0;
+        this.id = +response.esolve_id;
+    }
+}
+
+class EsolveCartStockItem {
+    constructor(code, name, sef_name, description, active, items_in_pack, delivery_category, image_name) {
+        this.code = code;
+        this.name = name;
+        this.sef_name = sef_name;
+        this.description = description;
+        this.active = active;
+        this.items_in_pack = items_in_pack;
+        this.delivery_category = delivery_category;
+        this.image_name = image_name;
+    }
+    /**
+     * Path to tiny stock image
+     */
+    get tiny_image_src() {
+        return '/images/' + (this.image_name ? 'stock/tiny/' + this.image_name : 'no_image.jpg');
+    }
+    /**
+     * Path to thumbnail stock image
+     */
+    get thumbnail_image_src() {
+        return '/images/' + (this.image_name ? 'stock/thumb/' + this.image_name : 'no_image.jpg');
+    }
+    /**
+     * Path to small stock image
+     */
+    get small_image_src() {
+        return '/images/' + (this.image_name ? 'stock/small/' + this.image_name : 'no_image.jpg');
+    }
+    /**
+     * Path to big stock image
+     */
+    get big_image_src() {
+        return '/images/' + (this.image_name ? 'stock/big/' + this.image_name : 'no_image.jpg');
+    }
+    /**
+     * Path to original stock image
+     */
+    get original_image_src() {
+        return 'images/' + (this.image_name ? 'stock/original/' + this.image_name : 'no_image.jpg');
+    }
+}
+
+class EsolveCartService {
+    constructor(config, http, errorHandler, responseHandler) {
+        this.config = config;
+        this.http = http;
+        this.errorHandler = errorHandler;
+        this.responseHandler = responseHandler;
+        this._cached_tracking = 0;
+    }
+    /**
+     * Processes the eSolve tree records.
+     * @param cart_item_records Records to process
+     * @returns An array of processed cart items
+     */
+    processCart(cart_item_records) {
+        const cart_items = [];
+        if (cart_item_records) {
+            for (const cart_item_record of cart_item_records) {
+                const cart_stock_item = new EsolveCartStockItem(cart_item_record.code, cart_item_record.name, cart_item_record.sef_name, cart_item_record.description, cart_item_record.is_active, +cart_item_record.items_in_pack, cart_item_record.delivery_category, cart_item_record.image_name);
+                cart_items.push(new EsolveCartItem(+cart_item_record.id, cart_stock_item, +cart_item_record.qty, cart_item_record.type, +cart_item_record.price, +cart_item_record.discount, +cart_item_record.discount_interval, cart_item_record.vat_rate, cart_item_record.allow_quotes, cart_item_record.allow_orders, cart_item_record.must_collect, cart_item_record.requested_assembly, +cart_item_record.price_incl, +cart_item_record.discount_price, +cart_item_record.discount_price_incl, +cart_item_record.discount_total, +cart_item_record.vat_total, +cart_item_record.line_total, +cart_item_record.line_total_incl));
+            }
+        }
+        return cart_items;
+    }
+    /**
+     * Processes the eSolve cart totals
+     * @param record Data to process
+     * @returns Processed cart totals
+     */
+    processCartTotals(record) {
+        const cart_totals = new EsolveCartTotals(+record.records, +record.items, +record.total, +record.vat, +record.discount);
+        return cart_totals;
+    }
+    /**
+     * Retrieves the current cart
+     * @returns An `Observable` with an array of cart items
+     */
+    getCart() {
+        return this.http.get(`${this.config.api_url}/service/get-cart.php`, {
+            params: {
+                ws_id: this.config.wsid
+            }
+        }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processCart(response.records);
+        }));
+    }
+    /**
+     * Updates the cart by preforming various actions, such as adding, editing or removing items from the cart.
+     * @param items An array of options to update the cart
+     * @param action The default action to preform
+     * @returns An `Observable` with an array of responses that gives feedback on the requested changes
+     */
+    setCart(items, action = 'add') {
+        const body = {
+            items,
+            action
+        };
+        return this.http.post(`${this.config.api_url}/service/set-cart-item.php`, body, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;'
+            },
+            params: {
+                ws_id: this.config.wsid
+            },
+            responseType: 'json',
+            observe: 'body'
+        }).pipe(map(response => {
+            if (response.responses === undefined) {
+                throw response;
+            }
+            return response.responses;
+        }));
+    }
+    /**
+     * Retrieves the totals of the cart with all the totals calculated
+     * @returns An `Observable` with an object containing cart totals
+     */
+    getTotals() {
+        return this.http.get(`${this.config.api_url}/service/get-cart-totals.php`, {
+            params: {
+                ws_id: this.config.wsid
+            }
+        }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processCartTotals(response.records);
+        }));
+    }
+    /**
+     * Retrieves a tracking code for the cart
+     * @returns An `Observable` with the cart tracking code
+     */
+    getTrackingCode() {
+        return iif(() => this._cached_tracking > 0, of(this._cached_tracking), this.http.get(`${this.config.api_url}/service/get-checkout-tracking.php`, {
+            params: {
+                ws_id: this.config.wsid
+            }
+        }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            this._cached_tracking = response.records.tracking;
+            return response.records.tracking;
+        })));
+    }
+    /**
+     * Initiates checkout of the cart items
+     * @param type The cart type that needs to be checked out
+     * @param addresses_id The ID of the delivery address
+     * @param shipping_id The ID of the shipping method
+     * @param payment_method_id The ID of the selected payment method
+     * @param location_id The ID of the selected branch from with shipping needs to be calculated
+     * @param comments Additional comments on the cart
+     * @returns An `Observable` with the transaction ID
+     */
+    checkout(type, addresses_id, shipping_id, payment_method_id = 0, location_id = 0, comments = '') {
+        const body = {
+            type,
+            addresses_id,
+            shipping_id,
+            payment_method_id,
+            location_id,
+            comments,
+            tracking: 0
+        };
+        return this.getTrackingCode().pipe(switchMap((tracking) => {
+            if (tracking <= 0) {
+                throw tracking;
+            }
+            body.tracking = tracking;
+            return this.http.post(`${this.config.api_url}/service/set-checkout.php`, body, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;'
+                },
+                params: {
+                    ws_id: this.config.wsid
+                },
+                responseType: 'json',
+                observe: 'body'
+            }).pipe(map(http_response => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveCheckoutResult(response))), catchError((errorRes) => {
+                return this.errorHandler.handleHttpPostError('set-checkout', errorRes);
+            }));
+        }));
+    }
+}
+EsolveCartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveCartService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1$1.HttpClient }, { token: EsolveErrorHandlerService }, { token: EsolveResponseHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveCartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveCartService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveCartService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
+    } });
+
+class EsolveVaultItemResult extends EsolveResponseResult {
+    constructor(response) {
+        super(response);
+        this.id = +response.esolve_id;
+        if (typeof response.token !== 'undefined') {
+            this.token = response.token;
+        }
+        if (typeof response.card_valid !== 'undefined') {
+            this.card_valid = response.card_valid;
+        }
+        if (typeof response.card_details_validated !== 'undefined') {
+            this.card_details_validated = response.card_details_validated;
+        }
+        if (typeof response.gateway_error_message !== 'undefined') {
+            this.gateway_error_message = response.gateway_error_message;
+        }
+    }
+}
+
+class EsolveVaultItem {
+    constructor(id, last4, brand, expiry_timestamp) {
+        this.id = id;
+        this.last4 = last4;
+        this.brand = brand;
+        this.expiry = new Date(expiry_timestamp * 1000);
+    }
+    get expiry_month() {
+        const month = this.expiry.getMonth() + 1;
+        return month.toString().padStart(2, '0');
+    }
+    get expiry_year() {
+        return this.expiry.getFullYear();
+    }
+    get masked_number() {
+        return this.last4.padStart(19, '**** ');
+    }
+}
+
+class EsolvePaymentResult extends EsolveResponseResult {
+    constructor(response) {
+        super(response);
+        if (typeof response.gateway_error_message !== 'undefined') {
+            this.gateway_error_message = response.gateway_error_message;
+        }
+        if (typeof response.three_d_secure !== 'undefined') {
+            this.three_d_secure = response.three_d_secure;
+        }
+        if (typeof response.redirect_url !== 'undefined') {
+            this.redirect_url = response.redirect_url;
+        }
+        if (typeof response.form_inputs !== 'undefined') {
+            this.form_inputs = response.form_inputs;
+        }
+        if (typeof response.form_html !== 'undefined') {
+            this.form_html = response.form_html;
+        }
+    }
+}
+
+class EsolvePaymentMethod {
+    constructor(record) {
+        this.id = +record.id;
+        this.location_id = +record.location_id;
+        this.paymethod_name = record.paymethod_name;
+        this.description = record.description;
+        this.display_banking_details = record.display_banking_details;
+        this.currency_code = record.currency_code;
+        this.terminal_id = record.terminal_id;
+        this.terminal_id_secondary = record.terminal_id_secondary;
+        this.merchant_id = record.merchant_id;
+        this.application_id = record.application_id;
+        this.api_username = record.api_username;
+        this.api_password = record.api_password;
+        this.api_signature = record.api_signature;
+        this.is_gateway = record.is_gateway;
+        this.must_store_card_details = record.must_store_card_details;
+        this.allow_budget = record.allow_budget;
+        this.integration_type = record.integration_type;
+        this.bank_gateway_id = record.bank_gateway_id;
+        this.accepted_card_types = record.accepted_card_types;
+        this.post_transactions_to_gateway = record.post_transactions_to_gateway;
+        this.three_d_secure_url = record.three_d_secure_url;
+        this.gateway_url = record.gateway_url;
+        this.generate_token_url = record.generate_token_url;
+        this.widget_url = record.widget_url;
+        this.successful_url = record.successful_url;
+        this.failed_url = record.failed_url;
+        this.enable_callback = record.enable_callback;
+        this.live = record.live;
+        this.default_module_id = +record.default_module_id;
+        this.service_provider = record.service_provider;
+        this.on_account = record.on_account;
+        this.sort_priority = +record.sort_priority;
+        this.image_url = record.image_url;
+        this.banking_details = new EsolveBankingDetails(record.bank_name, record.account_holder, record.account, record.account_type, record.swift_number, record.branch_code);
+    }
+}
+class EsolveBankingDetails {
+    constructor(bank_name, account_holder, account, account_type, swift_number, branch_code) {
+        this.bank_name = bank_name;
+        this.account_holder = account_holder;
+        this.account = account;
+        this.account_type = account_type;
+        this.swift_number = swift_number;
+        this.branch_code = branch_code;
+    }
+}
+
+class EsolvePaymentService {
+    constructor(config, http, errorHandler, responseHandler) {
+        this.config = config;
+        this.http = http;
+        this.errorHandler = errorHandler;
+        this.responseHandler = responseHandler;
+    }
+    /**
+     * Processes the eSolve payment method records.
+     * @param records Records to process
+     * @returns An array of processed payment methods.
+     */
+    processPaymentMethods(records) {
+        const payment_methods = [];
+        if (records) {
+            for (const record of records) {
+                const payment_method = new EsolvePaymentMethod(record);
+                payment_methods.push(payment_method);
+            }
+        }
+        return payment_methods;
+    }
+    /**
+     * Processes the eSolve vault records.
+     * @param records Records to process
+     * @returns An array of processed vault items (a.k.a. cards)
+     */
+    processVaultItems(records) {
+        const vault = [];
+        if (records) {
+            for (const record of records) {
+                const vault_item = new EsolveVaultItem(+record.id, record.last4, record.brand, record.expiry_timestamp);
+                vault.push(vault_item);
+            }
+        }
+        return vault;
+    }
+    generateExpiry(card_data) {
+        const month_string = card_data.expiry_month.padStart(2, '0');
+        const year_string = card_data.expiry_year.padStart(4, '0');
+        return `${month_string}${year_string}`;
+    }
+    /**
+     * Retrieves a list of payment methods.
+     * @param options Filter options
+     * @returns An `Observable` with an array of payment methods
+     */
+    getPaymentMethods(options) {
+        let params = new HttpParams();
+        params = params.set('ws_id', this.config.wsid);
+        if (options) {
+            if (typeof options.live !== 'undefined') {
+                params = params.set('live', options.live);
+            }
+            if (typeof options.location_id !== 'undefined') {
+                params = params.set('location_id', options.location_id);
+            }
+            if (typeof options.is_gateway !== 'undefined') {
+                params = params.set('is_gateway', options.is_gateway);
+            }
+        }
+        return this.http.get(`${this.config.api_url}/service/get-payment-methods.php`, { params }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processPaymentMethods(response.records);
+        }));
+    }
+    /**
+     * Retrieves a list of saved cards from the vault.
+     * @param payment_methods_id eSolve ID of a payment method
+     * @returns An `Observable` with an array of saved bank cards
+     */
+    getVault(payment_methods_id) {
+        let params = new HttpParams();
+        params = params.set('ws_id', this.config.wsid);
+        if (typeof payment_methods_id !== 'undefined') {
+            params = params.set('payment_methods_id', payment_methods_id);
+        }
+        return this.http.get(`${this.config.api_url}/service/get-vault.php`, { params }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processVaultItems(response.records);
+        }));
+    }
+    /**
+     * Sets a new card in the vault OR updates an existing one.
+     * @param payment_methods_id Selected payment method
+     * @param card_data Information of bank card
+     * @returns An `Observable` with the result of the vault set.
+     */
+    setVaultItem(payment_methods_id, card_data) {
+        const body = {
+            vault: {
+                payment_methods_id,
+                card_number: card_data.card_number,
+                card_name: card_data.name,
+                card_cvv: card_data.cvv,
+                card_expiry: this.generateExpiry(card_data)
+            }
+        };
+        return this.http.post(`${this.config.api_url}/service/set-vault.php`, body, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;'
+            },
+            params: {
+                ws_id: this.config.wsid
+            },
+            responseType: 'json',
+            observe: 'body'
+        }).pipe(map(http_response => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveVaultItemResult(response))), catchError((errorRes) => {
+            return this.errorHandler.handleHttpPostError('set-vault', errorRes);
+        }));
+    }
+    /**
+     * Sets the payment for the specified transaction using selected payment method.
+     * @param transaction_id eSolve ID to the transaction
+     * @param payment_methods_id eSolve ID to the selected payment method
+     * @param card ID of selected card from the vault or information to a brand new card
+     * @returns An `Observable` with the result of the payment
+     */
+    setPayment(transaction_id, payment_methods_id, card) {
+        const body = {
+            payment: {
+                cart_id: transaction_id,
+                payment_methods_id
+            }
+        };
+        if (typeof card === 'number') {
+            body.payment.user_vault_id = card;
+        }
+        else {
+            body.card = {
+                card_number: card.card_number,
+                card_name: card.name,
+                card_cvv: card.cvv,
+                card_expiry: this.generateExpiry(card)
+            };
+        }
+        return this.http.post(`${this.config.api_url}/service/set-payment.php`, body, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;'
+            },
+            params: {
+                ws_id: this.config.wsid
+            },
+            responseType: 'json',
+            observe: 'body'
+        }).pipe(map(http_response => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolvePaymentResult(response))), catchError((errorRes) => {
+            return this.errorHandler.handleHttpPostError('set-payment', errorRes);
+        }));
+    }
+}
+EsolvePaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", 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: "13.0.0", ngImport: i0, type: EsolvePaymentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolvePaymentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }, { type: EsolveErrorHandlerService }, { type: EsolveResponseHandlerService }];
+    } });
+
+class EsolveShippingMethod {
+    constructor(id, carrier_name, delivery_category, description, location, pricing, link_to_carrier_website, days_to_deliver, shipping_cost_calculation_method, insurance_cost_calculation_method, insurance_cost_percentage, metric_factor, allow_immediate_payment_processing, allow_postal_address, allow_physical_address, client_to_collect, is_default, location_id, use_zones, min_distance, max_distance, shipping_surge_condition, shipping_surge_percentage, sort_priority, shipping_group, shipping_slot_identifier, shipping_slot_delay_hours, image_url) {
+        this.id = id;
+        this.carrier_name = carrier_name;
+        this.delivery_category = delivery_category;
+        this.description = description;
+        this.location = location;
+        this.pricing = pricing;
+        this.link_to_carrier_website = link_to_carrier_website;
+        this.days_to_deliver = days_to_deliver;
+        this.shipping_cost_calculation_method = shipping_cost_calculation_method;
+        this.insurance_cost_calculation_method = insurance_cost_calculation_method;
+        this.insurance_cost_percentage = insurance_cost_percentage;
+        this.metric_factor = metric_factor;
+        this.allow_immediate_payment_processing = allow_immediate_payment_processing;
+        this.allow_postal_address = allow_postal_address;
+        this.allow_physical_address = allow_physical_address;
+        this.client_to_collect = client_to_collect;
+        this.is_default = is_default;
+        this.location_id = location_id;
+        this.use_zones = use_zones;
+        this.min_distance = min_distance;
+        this.max_distance = max_distance;
+        this.shipping_surge_condition = shipping_surge_condition;
+        this.shipping_surge_percentage = shipping_surge_percentage;
+        this.sort_priority = sort_priority;
+        this.shipping_group = shipping_group;
+        this.shipping_slot_identifier = shipping_slot_identifier;
+        this.shipping_slot_delay_hours = shipping_slot_delay_hours;
+        this.image_url = image_url;
+    }
+}
+
+class EsolveShippingCost {
+    constructor(
+    // Shipping
+    shipping_total = 0, shipping_vat = 0, shipping_total_savings = 0, 
+    // Insurance
+    insurance_total = 0, insurance_vat = 0, insurance_total_savings = 0) {
+        this.shipping = new EsolveShippingTotals(shipping_total, shipping_vat, shipping_total_savings);
+        this.insurance = new EsolveShippingTotals(insurance_total, insurance_vat, insurance_total_savings);
+    }
+}
+class EsolveShippingTotals {
+    constructor(total, vat, savings) {
+        this.total = total;
+        this.vat = vat;
+        this.savings = savings;
+    }
+}
+
+class EsolveShippingService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    /**
+     * Processes the eSolve shipping method records.
+     * @param records Records to process
+     * @returns An array of processed shipping methods
+     */
+    processShippingMethods(records) {
+        const shipping_methods = [];
+        if (records) {
+            for (const record of records) {
+                const shipping_method = new EsolveShippingMethod(+record.id, record.carrier_name, record.delivery_category, record.description, record.location, record.pricing, record.link_to_carrier_website, +record.days_to_deliver, record.shipping_cost_calculation_method, record.insurance_cost_calculation_method, +record.insurance_cost_percentage, +record.metric_factor, record.allow_immediate_payment_processing, record.allow_postal_address, record.allow_physical_address, record.client_to_collect, record.is_default_shipping_method, +record.location_id, record.use_zones, +record.min_distance, +record.max_distance, +record.shipping_surge_condition, +record.shipping_surge_percentage, +record.sort_priority, record.shipping_group, record.shipping_slot_identifier, +record.shipping_slot_delay_hours, record.image_url);
+                shipping_methods.push(shipping_method);
+            }
+        }
+        return shipping_methods;
+    }
+    /**
+     * Processes the eSolve shipping costs record.
+     * @param record Data to process
+     * @returns Processed shipping costs
+     */
+    processShippingCost(record) {
+        const shipping_cost = new EsolveShippingCost(+record.shipping_total, +record.vat_on_shipping, +record.total_saving_on_shipping, +record.insurance_total, +record.vat_on_insurance, +record.total_saving_on_insurance);
+        return shipping_cost;
+    }
+    /**
+     * Retrieves a list of shipping methods
+     * @returns An `Observable` with an array of shipping methods
+     */
+    getShippingMethods(options) {
+        let params = new HttpParams();
+        params = params.set('ws_id', this.config.wsid);
+        if (options) {
+            if (typeof options.addresses_id !== 'undefined') {
+                params = params.set('addresses_id', options.addresses_id);
+            }
+            if (typeof options.location_id !== 'undefined') {
+                params = params.set('location_id', options.location_id);
+            }
+        }
+        return this.http.get(`${this.config.api_url}/service/get-shipping-methods.php`, { params }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processShippingMethods(response.records);
+        }));
+    }
+    /**
+     * Retrieves the shipping costs
+     * @param options Shipping cost options
+     * @returns An `Observable` with the shipping costs
+     */
+    getShippingCost(shipping_id, addresses_id, location_id) {
+        try {
+            let params = new HttpParams();
+            params = params.set('ws_id', this.config.wsid);
+            if (typeof shipping_id !== 'undefined') {
+                params = params.set('shipping_id', shipping_id);
+            }
+            else {
+                throw new Error('Shipping ID is required');
+            }
+            if (typeof addresses_id !== 'undefined') {
+                params = params.set('addresses_id', addresses_id);
+            }
+            else {
+                throw new Error('Address ID is required');
+            }
+            if (typeof location_id !== 'undefined') {
+                params = params.set('location_id', location_id);
+            }
+            return this.http.get(`${this.config.api_url}/service/get-shipping-cost.php`, { params }).pipe(map(response => {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                return this.processShippingCost(response.records[0]);
+            }));
+        }
+        catch (err) {
+            return throwError(err);
+        }
+    }
+}
+EsolveShippingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", 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: "13.0.0", ngImport: i0, type: EsolveShippingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveShippingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }];
+    } });
+
+class EsolveStockLocation {
+    constructor(record) {
+        this.id = +record.id;
+        this.identifier = record.identifier;
+        this.description = record.description;
+        this.head_office = record.head_office;
+        this.erp_identifier = record.erp_identifier;
+        this.external_system_code = record.external_system_code;
+        this.default_location_for_payment_methods = record.default_location_for_payment_methods;
+        this.userid = +record.userid;
+        this.importance = +record.importance;
+        this.active = record.is_active;
+        this.website_url = record.website_url;
+        this.address = new EsolveStockLocationAddress(record.street, record.suburb, record.city, record.province, record.country, record.postal_code, +record.latitude, +record.longitude);
+        this.pobox_address = new EsolveStockLocationPOBoxAddress(record.pobox, record.pobox_city, record.pobox_postal_code);
+        const telnumbers = [];
+        if (record.branch_telnumber.length > 0) {
+            telnumbers.push(record.branch_telnumber);
+        }
+        if (record.branch_telnumber_2.length > 0) {
+            telnumbers.push(record.branch_telnumber_2);
+        }
+        if (record.branch_telnumber_3.length > 0) {
+            telnumbers.push(record.branch_telnumber_3);
+        }
+        this.contact_info = new EsolveStockLocationContactInfo(telnumbers, record.branch_cellnumber, record.branch_email, record.branch_fax);
+        this.trading_times = new EsolveStockLocationTradingTimes(record.monday_open_time, record.monday_close_time, record.tuesday_open_time, record.tuesday_close_time, record.wednesday_open_time, record.wednesday_close_time, record.thursday_open_time, record.thursday_close_time, record.friday_open_time, record.friday_close_time, record.saturday_open_time, record.saturday_close_time, record.sunday_open_time, record.sunday_close_time, record.public_holiday_open_time, record.public_holiday_close_time, record.trading_hours_additional_in);
+    }
+}
+class EsolveStockLocationAddress {
+    constructor(street, suburb, city, province, country, postal_code, latitude, longitude) {
+        this.street = street;
+        this.suburb = suburb;
+        this.city = city;
+        this.province = province;
+        this.country = country;
+        this.postal_code = postal_code;
+        this.latitude = latitude;
+        this.longitude = longitude;
+    }
+}
+class EsolveStockLocationPOBoxAddress {
+    constructor(pobox, city, postal_code) {
+        this.pobox = pobox;
+        this.city = city;
+        this.postal_code = postal_code;
+    }
+}
+class EsolveStockLocationContactInfo {
+    constructor(telnumber, cellnumber, email, fax) {
+        this.telnumber = telnumber;
+        this.cellnumber = cellnumber;
+        this.email = email;
+        this.fax = fax;
+    }
+}
+class EsolveStockLocationTradingTimes {
+    constructor(monday_open_time, monday_close_time, tuesday_open_time, tuesday_close_time, wednesday_open_time, wednesday_close_time, thursday_open_time, thursday_close_time, friday_open_time, friday_close_time, saturday_open_time, saturday_close_time, sunday_open_time, sunday_close_time, public_holiday_open_time, public_holiday_close_time, trading_hours_additional_info = '') {
+        this.trading_hours_additional_info = trading_hours_additional_info;
+        this.monday = new EsolveStockLocationTradingTimesDay(monday_open_time, monday_close_time);
+        this.tuesday = new EsolveStockLocationTradingTimesDay(tuesday_open_time, tuesday_close_time);
+        this.wednesday = new EsolveStockLocationTradingTimesDay(wednesday_open_time, wednesday_close_time);
+        this.thursday = new EsolveStockLocationTradingTimesDay(thursday_open_time, thursday_close_time);
+        this.friday = new EsolveStockLocationTradingTimesDay(friday_open_time, friday_close_time);
+        this.saturday = new EsolveStockLocationTradingTimesDay(saturday_open_time, saturday_close_time);
+        this.sunday = new EsolveStockLocationTradingTimesDay(sunday_open_time, sunday_close_time);
+        this.public_holiday = new EsolveStockLocationTradingTimesDay(public_holiday_open_time, public_holiday_close_time);
+    }
+}
+class EsolveStockLocationTradingTimesDay {
+    constructor(open, close) {
+        this.open = open;
+        this.close = close;
+    }
+}
+
+class EsolveLocationsService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    /**
+     * Processes the eSolve stock location records.
+     * @param records Records to process
+     * @returns An array of processed stock location records
+     */
+    processStockLocations(records) {
+        const stock_locations = [];
+        if (records) {
+            for (const record of records) {
+                stock_locations.push(new EsolveStockLocation(record));
+            }
+        }
+        return stock_locations;
+    }
+    /**
+     * Retrieves a list of stock locations
+     * @returns An `Observable` with an array of stock locations
+     */
+    getStockLocations() {
+        let params = new HttpParams();
+        params = params.set('ws_id', this.config.wsid);
+        return this.http.get(`${this.config.api_url}/service/get-locations.php`, { params }).pipe(map(response => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processStockLocations(response.records);
+        }));
+    }
+}
+EsolveLocationsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", 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: "13.0.0", ngImport: i0, type: EsolveLocationsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EsolveLocationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [ESOLVE_CONNECT_CONFIG]
+                    }] }, { type: i1$1.HttpClient }];
+    } });
+
+/*
+ * Public API Surface of ng-esolve-connect
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { EsolveAccountService, EsolveAddress, EsolveAddressResult, EsolveAuthService, EsolveBankingDetails, EsolveBanner, EsolveBannerImage, EsolveBannerImageHotspot, EsolveBannerService, EsolveCartItem, EsolveCartService, EsolveCartTotals, EsolveCategoryTreeItem, EsolveCategoryTreeService, EsolveCheckoutResult, EsolveErrorHandlerService, EsolveHttpError, EsolveLocationsService, EsolveMediaArticle, EsolveMediaService, EsolveMenuItem, EsolveMenuService, EsolveNewsArticle, EsolveNewsArticleAuthor, EsolveNewsArticleList, EsolveNewsGroup, EsolveNewsService, EsolvePaymentMethod, EsolvePaymentResult, EsolvePaymentService, EsolveRegistrationResult, EsolveResponseHandlerService, EsolveResponseResult, EsolveSEOInfo, EsolveSeoService, EsolveSession, EsolveSessionService, EsolveShippingCost, EsolveShippingMethod, EsolveShippingService, EsolveStockBadge, EsolveStockItem, EsolveStockItemList, EsolveStockLocation, EsolveStockPrice, EsolveStockService, EsolveTag, EsolveTopic, EsolveTopicService, EsolveUserAccount, EsolveUserAccountBusiness, EsolveUserAccountContact, EsolveUserAccountResult, EsolveVaultItem, EsolveVaultItemResult, NgEsolveConnectModule };