@esolve/ng-esolve-connect 0.5.1

package/bundles/esolve-ng-esolve-connect.umd.js

@@ -0,0 +1,3032 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('@angular/common/http'), require('rxjs'), require('rxjs/operators'), require('@angular/platform-browser')) :
+    typeof define === 'function' && define.amd ? define('@esolve/ng-esolve-connect', ['exports', '@angular/core', '@angular/common', '@angular/common/http', 'rxjs', 'rxjs/operators', '@angular/platform-browser'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.esolve = global.esolve || {}, global.esolve['ng-esolve-connect'] = {}), global.ng.core, global.ng.common, global.ng.common.http, global.rxjs, global.rxjs.operators, global.ng.platformBrowser));
+}(this, (function (exports, i0, common, i1, rxjs, operators, i1$1) { 'use strict';
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () {
+                            return e[k];
+                        }
+                    });
+                }
+            });
+        }
+        n['default'] = e;
+        return Object.freeze(n);
+    }
+
+    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
+    var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
+    var i1__namespace$1 = /*#__PURE__*/_interopNamespace(i1$1);
+
+    var ESOLVE_CONNECT_CONFIG = new i0.InjectionToken('esolve.connect.config');
+    var GLOBAL_CONFIG = {
+        images_url: '',
+        media_path: '/media',
+        stock_path: '/stock',
+        banner_path: '/banners'
+    };
+
+    var EsolveSession = /** @class */ (function () {
+        function EsolveSession(id, _key, _key_expiration_date) {
+            if (id === void 0) { id = -1; }
+            if (_key === void 0) { _key = ''; }
+            this.id = id;
+            this._key = _key;
+            this._key_expiration_date = _key_expiration_date;
+        }
+        Object.defineProperty(EsolveSession.prototype, "key", {
+            get: function () {
+                return this._key;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveSession.prototype, "expired", {
+            get: function () {
+                var current_date = new Date();
+                return ((this._key_expiration_date === undefined) ||
+                    (current_date >= this._key_expiration_date));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveSession.prototype, "authenticated", {
+            get: function () {
+                return (this.id > 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveSession.prototype, "valid", {
+            get: function () {
+                return ((this._key !== '') &&
+                    (this._key_expiration_date !== undefined) &&
+                    (this.id >= 0));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        EsolveSession.prototype.updateUser = function (user_id) {
+            this.id = user_id;
+        };
+        return EsolveSession;
+    }());
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (Object.prototype.hasOwnProperty.call(b, p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+                t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); };
+    }
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+            return Reflect.metadata(metadataKey, metadataValue);
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function () { if (t[0] & 1)
+                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f)
+                throw new TypeError("Generator is already executing.");
+            while (_)
+                try {
+                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                        return t;
+                    if (y = 0, t)
+                        op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2])
+                                _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                }
+                catch (e) {
+                    op = [6, e];
+                    y = 0;
+                }
+                finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5)
+                throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+    var __createBinding = Object.create ? (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
+    }) : (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        o[k2] = m[k];
+    });
+    function __exportStar(m, o) {
+        for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+                __createBinding(o, m, p);
+    }
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+            return m.call(o);
+        if (o && typeof o.length === "number")
+            return {
+                next: function () {
+                    if (o && i >= o.length)
+                        o = void 0;
+                    return { value: o && o[i++], done: !o };
+                }
+            };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+            return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+                ar.push(r.value);
+        }
+        catch (error) {
+            e = { error: error };
+        }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"]))
+                    m.call(i);
+            }
+            finally {
+                if (e)
+                    throw e.error;
+            }
+        }
+        return ar;
+    }
+    /** @deprecated */
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+    /** @deprecated */
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+            s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2)
+            for (var i = 0, l = from.length, ar; i < l; i++) {
+                if (ar || !(i in from)) {
+                    if (!ar)
+                        ar = Array.prototype.slice.call(from, 0, i);
+                    ar[i] = from[i];
+                }
+            }
+        return to.concat(ar || from);
+    }
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n])
+            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try {
+            step(g[n](v));
+        }
+        catch (e) {
+            settle(q[0][3], e);
+        } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length)
+            resume(q[0][0], q[0][1]); }
+    }
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
+    }
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) {
+            Object.defineProperty(cooked, "raw", { value: raw });
+        }
+        else {
+            cooked.raw = raw;
+        }
+        return cooked;
+    }
+    ;
+    var __setModuleDefault = Object.create ? (function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function (o, v) {
+        o["default"] = v;
+    };
+    function __importStar(mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k in mod)
+                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    }
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+    }
+
+    var EsolveAddress = /** @class */ (function () {
+        function EsolveAddress(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;
+        }
+        return EsolveAddress;
+    }());
+
+    var EsolveAccountService = /** @class */ (function () {
+        function EsolveAccountService(config, http) {
+            this.config = config;
+            this.http = http;
+            this._user_id = 0;
+        }
+        Object.defineProperty(EsolveAccountService.prototype, "user_id", {
+            get: function () {
+                return this._user_id;
+            },
+            set: function (value) {
+                value = ((value > 0) ? value : 0);
+                if (this._user_id !== value) {
+                    this._user_id = value;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        EsolveAccountService.prototype.processUserAddress = function (records) {
+            var e_1, _a;
+            var user_addesses = [];
+            if (records && (this._user_id > 0)) {
+                try {
+                    for (var records_1 = __values(records), records_1_1 = records_1.next(); !records_1_1.done; records_1_1 = records_1.next()) {
+                        var record = records_1_1.value;
+                        if (+record.userid === this._user_id) {
+                            user_addesses.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));
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (records_1_1 && !records_1_1.done && (_a = records_1.return)) _a.call(records_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            return user_addesses;
+        };
+        EsolveAccountService.prototype.getAddress = function () {
+            var _this = this;
+            var params = new i1.HttpParams();
+            params = params.set('ws_id', this.config.wsid);
+            params = params.set('user_id', this.user_id.toString());
+            return rxjs.iif(function () { return (_this.user_id > 0); }, this.http.get(this.config.api_url + "/service/get-addresses.php", { params: params }).pipe(operators.map(function (response) {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                return _this.processUserAddress(response.records);
+            }), operators.catchError(function (err) {
+                return rxjs.throwError(err);
+            })), rxjs.throwError('Log in is required'));
+        };
+        return EsolveAccountService;
+    }());
+    EsolveAccountService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveAccountService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveAccountService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveAccountService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveAccountService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }];
+        } });
+
+    var EsolveSessionService = /** @class */ (function () {
+        function EsolveSessionService(config, account) {
+            this.config = config;
+            this.storage_key = 'ngEslvUserSession';
+            this.setStorageKey();
+            this._session = new rxjs.BehaviorSubject(new EsolveSession(0, ''));
+            this.session = this._session.asObservable();
+            this._session.subscribe(function (session) {
+                if (session.key !== '') {
+                    account.user_id = session.id;
+                }
+            });
+        }
+        Object.defineProperty(EsolveSessionService.prototype, "currentSession", {
+            get: function () {
+                return this._session.value;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        EsolveSessionService.prototype.setStorageKey = function () {
+            if ((typeof this.config.user_session_storage_key === 'string') &&
+                (this.config.user_session_storage_key !== '')) {
+                this.storage_key = this.config.user_session_storage_key;
+            }
+        };
+        EsolveSessionService.prototype.startTimer = function (callback, duration) {
+            this.key_expiration_timer = setTimeout(callback, duration);
+        };
+        EsolveSessionService.prototype.clearTimer = function () {
+            if (this.key_expiration_timer) {
+                clearTimeout(this.key_expiration_timer);
+            }
+        };
+        EsolveSessionService.prototype.restore = function (expirationCallback, invalidSessionCallback) {
+            if (!this.currentSession.valid) {
+                var stored_session_json = localStorage.getItem(this.storage_key);
+                var stored_session = (stored_session_json ? JSON.parse(stored_session_json) : null);
+                if (!stored_session) {
+                    invalidSessionCallback();
+                    return;
+                }
+                var expiration_date = new Date(stored_session._key_expiration_date);
+                var loaded_session = new EsolveSession(stored_session.id, stored_session._key, expiration_date);
+                if (!loaded_session.expired) {
+                    this._session.next(loaded_session);
+                    var expiration_duration = expiration_date.getTime() - new Date().getTime();
+                    this.startTimer(expirationCallback, expiration_duration);
+                }
+                else {
+                    expirationCallback(loaded_session);
+                }
+            }
+        };
+        EsolveSessionService.prototype.handleSession = function (user_id, key, expiry_time, expires, expirationCallback) {
+            var expiration_date = new Date(expiry_time * 1000);
+            var 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);
+        };
+        EsolveSessionService.prototype.handleUpdateSession = function (user_id, callback) {
+            var 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();
+            }
+        };
+        return EsolveSessionService;
+    }());
+    EsolveSessionService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveSessionService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: EsolveAccountService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveSessionService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveSessionService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveSessionService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: EsolveAccountService }];
+        } });
+
+    var EsolveAuthInterceptorService = /** @class */ (function () {
+        function EsolveAuthInterceptorService(config, session) {
+            this.config = config;
+            this.session = session;
+        }
+        EsolveAuthInterceptorService.prototype.intercept = function (req, next) {
+            if (req.url.startsWith(this.config.api_url + "/service/")) {
+                var service_identifier = req.url.replace(this.config.api_url + "/service/", '');
+                var old_parms_keys = req.params.keys();
+                var modified_url = req.url;
+                var params_1 = new i1.HttpParams();
+                var session = this.session.currentSession;
+                if (session.valid) {
+                    if (service_identifier !== 'get-access-token.php') {
+                        params_1 = params_1.set('key', session.key);
+                    }
+                }
+                old_parms_keys.forEach(function (key) {
+                    params_1 = params_1.set(key, req.params.get(key) || '');
+                });
+                var modified_req = req.clone({
+                    url: modified_url,
+                    params: params_1
+                });
+                return next.handle(modified_req);
+            }
+            return next.handle(req);
+        };
+        return EsolveAuthInterceptorService;
+    }());
+    EsolveAuthInterceptorService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveAuthInterceptorService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: EsolveSessionService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveAuthInterceptorService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveAuthInterceptorService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveAuthInterceptorService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: EsolveSessionService }];
+        } });
+
+    var NgEsolveConnectModule = /** @class */ (function () {
+        function NgEsolveConnectModule() {
+        }
+        NgEsolveConnectModule.forRoot = function (config) {
+            return {
+                ngModule: NgEsolveConnectModule,
+                providers: [
+                    {
+                        provide: ESOLVE_CONNECT_CONFIG,
+                        useValue: config
+                    },
+                    {
+                        provide: i1.HTTP_INTERCEPTORS,
+                        useClass: EsolveAuthInterceptorService,
+                        multi: true
+                    }
+                ]
+            };
+        };
+        return NgEsolveConnectModule;
+    }());
+    NgEsolveConnectModule.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: NgEsolveConnectModule, deps: [], target: i0__namespace.ɵɵFactoryTarget.NgModule });
+    NgEsolveConnectModule.ɵmod = i0__namespace.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: NgEsolveConnectModule, imports: [common.CommonModule,
+            i1.HttpClientModule] });
+    NgEsolveConnectModule.ɵinj = i0__namespace.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: NgEsolveConnectModule, imports: [[
+                common.CommonModule,
+                i1.HttpClientModule
+            ]] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: NgEsolveConnectModule, decorators: [{
+                type: i0.NgModule,
+                args: [{
+                        declarations: [],
+                        imports: [
+                            common.CommonModule,
+                            i1.HttpClientModule
+                        ],
+                        exports: []
+                    }]
+            }] });
+
+    /**
+     * Search Engine Optimization information.
+     */
+    var EsolveSEOInfo = /** @class */ (function () {
+        function EsolveSEOInfo(title, description, keywords) {
+            if (title === void 0) { title = ''; }
+            if (description === void 0) { description = ''; }
+            if (keywords === void 0) { keywords = ''; }
+            this.title = title;
+            this.description = description;
+            this.keywords = keywords;
+        }
+        return EsolveSEOInfo;
+    }());
+
+    var EsolveSeoService = /** @class */ (function () {
+        function EsolveSeoService(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();
+        }
+        EsolveSeoService.prototype.init = function () {
+            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;
+            }
+        };
+        EsolveSeoService.prototype.setPageTitleTags = function (title) {
+            this.title.setTitle(title);
+            this.meta.updateTag({ property: 'og:title', content: title });
+        };
+        EsolveSeoService.prototype.setPageDescriptionTags = function (description) {
+            this.meta.updateTag({ name: 'description', content: description });
+            this.meta.updateTag({ property: 'og:description', content: description });
+        };
+        EsolveSeoService.prototype.setPageKeywordsTags = function (keywords) {
+            this.meta.updateTag({ name: 'keywords', content: keywords });
+        };
+        EsolveSeoService.prototype.validateAndSanitizeSeoInfo = function (seoInfo) {
+            var e_1, _a;
+            var 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() !== '') {
+                var 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() === '') {
+                    var clean_title = seoInfo.title.replace(/[^a-zA-Z0-9\. ]+/gi, '').trim();
+                    var keywords = clean_title.split(' ');
+                    var clean_keywords = [];
+                    try {
+                        for (var keywords_1 = __values(keywords), keywords_1_1 = keywords_1.next(); !keywords_1_1.done; keywords_1_1 = keywords_1.next()) {
+                            var keyword = keywords_1_1.value;
+                            keyword = keyword.trim();
+                            if (keyword.length > 2) {
+                                keyword = keyword.toLocaleLowerCase();
+                                if (!clean_keywords.includes(keyword)) {
+                                    clean_keywords.push(keyword);
+                                }
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (keywords_1_1 && !keywords_1_1.done && (_a = keywords_1.return)) _a.call(keywords_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    seoInfo.keywords = clean_keywords.join(',');
+                }
+            }
+            if (seoInfo.keywords.trim() !== '') {
+                pageSeo.keywords = seoInfo.keywords;
+            }
+            return pageSeo;
+        };
+        /**
+         * Sets SEO tags for page
+         * @param seoInfo SEO object
+         */
+        EsolveSeoService.prototype.setTags = function (seoInfo) {
+            seoInfo = this.validateAndSanitizeSeoInfo(seoInfo);
+            this.setPageTitleTags(seoInfo.title);
+            this.setPageDescriptionTags(seoInfo.description);
+            this.setPageKeywordsTags(seoInfo.keywords);
+        };
+        return EsolveSeoService;
+    }());
+    EsolveSeoService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveSeoService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace$1.Title }, { token: i1__namespace$1.Meta }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveSeoService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveSeoService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveSeoService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace$1.Title }, { type: i1__namespace$1.Meta }];
+        } });
+
+    var EsolveAuthService = /** @class */ (function () {
+        function EsolveAuthService(config, http, session) {
+            this.config = config;
+            this.http = http;
+            this.session = session;
+        }
+        EsolveAuthService.prototype.checkAccessToken = function (session) {
+            var _a;
+            session = session || this.session.currentSession;
+            var token = (_a = session === null || session === void 0 ? void 0 : session.key) !== null && _a !== void 0 ? _a : '';
+            var params = new i1.HttpParams({
+                fromObject: {
+                    key: token,
+                    ws_id: this.config.wsid
+                }
+            });
+            return this.http.get(this.config.api_url + "/service/get-access-token.php", {
+                params: params,
+                headers: new i1.HttpHeaders({
+                    'Accept-Language': '*'
+                })
+            }).pipe(operators.map(function (responseData) {
+                if ((responseData.type === 'error') || (responseData.type === 'exception') || (!responseData.additional_data.key_okay)) {
+                    throw responseData;
+                }
+                responseData.additional_data.key = token;
+                return responseData;
+            })).toPromise();
+        };
+        EsolveAuthService.prototype.getAccessToken = function (email, password, anonymous) {
+            var _this = this;
+            if (anonymous === void 0) { anonymous = false; }
+            var params = new i1.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: params,
+                headers: new i1.HttpHeaders({
+                    'Accept-Language': '*'
+                })
+            }).pipe(operators.tap(function (responseData) {
+                if ((responseData.type === 'error') || (responseData.type === 'exception')) {
+                    throw responseData;
+                }
+            }), operators.catchError(this.handleError), operators.tap(function (responseData) {
+                _this.handleAuthentication(responseData);
+            }));
+        };
+        EsolveAuthService.prototype.autoLogin = function () {
+            var _this = this;
+            this.session.restore(this.handleExpiration(), function () {
+                _this.getAccessToken('', '', true).toPromise().then(function (_) { }, function (error) {
+                    console.log(error);
+                });
+            });
+        };
+        EsolveAuthService.prototype.login = function (email, password) {
+            var _this = this;
+            var body = {
+                login: {
+                    email: email,
+                    password: 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(operators.map(function (response) {
+                var e_1, _b;
+                if ((response.responses === undefined) || (response.responses.length <= 0)) {
+                    throw response;
+                }
+                var login_response = response.responses[0];
+                if ((login_response.status.state !== 'success') && (login_response.status.state !== 'warning')) {
+                    throw login_response;
+                }
+                try {
+                    for (var _c = __values(login_response.log), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var response_log = _d.value;
+                        if ((response_log.type === 'success') && (response_log.message_code === 'login_success')) {
+                            _this.session.handleUpdateSession(login_response.esolve_id);
+                            return login_response.esolve_id;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                throw login_response;
+            }), operators.catchError(function (errorRes) {
+                var parseException = function (exception) {
+                    var exception_type = exception.additional_data.exception_type;
+                    var error = {
+                        type: 'exception',
+                        message: exception.message || '',
+                        error_code: exception_type || 'unknown'
+                    };
+                    return error;
+                };
+                var parseLoginErrors = function (login_response) {
+                    var error = {
+                        type: 'error',
+                        message: 'Unknown error has occured',
+                        error_code: 'unknown'
+                    };
+                    if ((login_response.status.state === 'none') && (login_response.log.length > 0)) {
+                        error.error_code = 'no_response';
+                        error.message = 'Response was provided';
+                    }
+                    else if (login_response.status.state === 'error') {
+                        var login_error_log = login_response.log[0];
+                        error.error_code = login_error_log.message_code;
+                        error.message = login_error_log.message;
+                    }
+                    return error;
+                };
+                if (errorRes instanceof i1.HttpErrorResponse) {
+                    if (errorRes.status === 500) {
+                        var server_error = errorRes.error;
+                        if ((server_error.service_type === 'set-login') ||
+                            (server_error.type !== undefined) ||
+                            (server_error.message !== undefined) ||
+                            (server_error.additional_data !== undefined)) {
+                            return rxjs.throwError(parseException(server_error));
+                        }
+                    }
+                }
+                else {
+                    if (errorRes.type !== undefined) {
+                        if (errorRes.type === 'exception') {
+                            return rxjs.throwError(parseException(errorRes));
+                        }
+                    }
+                    else if (errorRes.transaction_type === 'Login') {
+                        return rxjs.throwError(parseLoginErrors(errorRes));
+                    }
+                }
+                return rxjs.throwError(errorRes);
+            }));
+        };
+        EsolveAuthService.prototype.logout = function () {
+            this.session.clearTimer();
+            this.getAccessToken('', '', true).toPromise().then(function (_) { }, function (error) {
+                console.log(error);
+            });
+        };
+        EsolveAuthService.prototype.handleExpiration = function () {
+            var _this = this;
+            return function (session) {
+                _this.checkAccessToken(session).then(function (response) {
+                    _this.handleAuthentication(response);
+                }, function () {
+                    _this.logout();
+                });
+            };
+        };
+        EsolveAuthService.prototype.handleAuthentication = function (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());
+            }
+        };
+        EsolveAuthService.prototype.handleError = function (errorRes) {
+            var error = {
+                message: 'An unknown error occurred',
+                data: {}
+            };
+            if ((!errorRes.type) || (!errorRes.service_type) || (!errorRes.message)) {
+                return rxjs.throwError(error);
+            }
+            if (errorRes.message.trim() !== '') {
+                error.message = errorRes.message;
+            }
+            if (errorRes.additional_data) {
+                error.data = errorRes.additional_data;
+            }
+            return rxjs.throwError(error);
+        };
+        return EsolveAuthService;
+    }());
+    EsolveAuthService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveAuthService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }, { token: EsolveSessionService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveAuthService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveAuthService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveAuthService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }, { type: EsolveSessionService }];
+        } });
+
+    var EsolveMediaArticle = /** @class */ (function () {
+        function EsolveMediaArticle(identifier, title, article, image_url, tags, topics, seo_title, seo_keywords, seo_description) {
+            if (image_url === void 0) { image_url = ''; }
+            if (tags === void 0) { tags = []; }
+            if (topics === void 0) { topics = []; }
+            if (seo_title === void 0) { seo_title = ''; }
+            if (seo_keywords === void 0) { seo_keywords = ''; }
+            if (seo_description === void 0) { 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);
+        }
+        return EsolveMediaArticle;
+    }());
+
+    var EsolveTag = /** @class */ (function () {
+        function EsolveTag(id, tag_phrase, tag_weight, description) {
+            this.id = id;
+            this.tag_phrase = tag_phrase;
+            this.tag_weight = tag_weight;
+            this.description = description;
+        }
+        return EsolveTag;
+    }());
+
+    var EsolveTopic = /** @class */ (function () {
+        function EsolveTopic(id, name, short_description, sort_priority) {
+            this.id = id;
+            this.name = name;
+            this.short_description = short_description;
+            this.sort_priority = sort_priority;
+        }
+        return EsolveTopic;
+    }());
+
+    var EsolveMediaService = /** @class */ (function () {
+        function EsolveMediaService(config, http) {
+            this.config = config;
+            this.http = http;
+        }
+        EsolveMediaService.prototype.processMediaRecord = function (record) {
+            var e_1, _a, e_2, _b;
+            var tags = [];
+            var topics = [];
+            if ((record.tags) && (record.tags.length > 0)) {
+                try {
+                    for (var _c = __values(record.tags), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var tag = _d.value;
+                        tags.push(new EsolveTag(+tag.id, tag.tag_phrase, +tag.tag_weight, tag.description));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            if ((record.topics) && (record.topics.length > 0)) {
+                try {
+                    for (var _e = __values(record.topics), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var topic = _f.value;
+                        topics.push(new EsolveTopic(+topic.id, topic.name, topic.short_description, +topic.sort_priority));
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            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
+         */
+        EsolveMediaService.prototype.getMediaRecords = function (params) {
+            params = params.set('ws_id', this.config.wsid);
+            return this.http.get(this.config.api_url + "/service/get-media.php", { params: params });
+        };
+        /**
+         * Retrieves the media record from the eSolve instance using the identifier.
+         * @param identifier String representing the eSolve media indentifier
+         */
+        EsolveMediaService.prototype.getMediaArticle = function (identifier) {
+            var _this = this;
+            var params = new i1.HttpParams({
+                fromObject: {
+                    identifier: identifier
+                }
+            });
+            // TODO: Error Handling
+            return this.getMediaRecords(params).pipe(operators.map(function (response) {
+                if ((response.records === undefined) || (response.records.length <= 0)) {
+                    throw response;
+                }
+                var 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
+         */
+        EsolveMediaService.prototype.getGroupedMediaArticles = function (media_group) {
+            var _this = this;
+            var params = new i1.HttpParams({
+                fromObject: {
+                    media_group_sef: media_group
+                }
+            });
+            return this.getMediaRecords(params).pipe(operators.map(function (response) {
+                var e_3, _a;
+                var mediaArticles = [];
+                if ((response.records !== undefined) && (response.records.length > 0)) {
+                    try {
+                        for (var _b = __values(response.records), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            var mediaRecord = _c.value;
+                            if (mediaRecord.active) {
+                                mediaArticles.push(_this.processMediaRecord(mediaRecord));
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+                return mediaArticles;
+            }));
+        };
+        return EsolveMediaService;
+    }());
+    EsolveMediaService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveMediaService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveMediaService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveMediaService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveMediaService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }];
+        } });
+
+    var EsolveNewsArticle = /** @class */ (function () {
+        function EsolveNewsArticle(id, title, sef_title, article, short_description, txdate, active, image, featured, author, seo_title, seo_keywords) {
+            if (seo_title === void 0) { seo_title = ''; }
+            if (seo_keywords === void 0) { 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);
+        }
+        return EsolveNewsArticle;
+    }());
+
+    var EsolveNewsGroup = /** @class */ (function () {
+        function EsolveNewsGroup(id, name, description, sef_name) {
+            this.id = id;
+            this.name = name;
+            this.description = description;
+            this.sef_name = sef_name;
+        }
+        return EsolveNewsGroup;
+    }());
+
+    var EsolveNewsArticleList = /** @class */ (function () {
+        function EsolveNewsArticleList(newsArticles, total, page) {
+            this.newsArticles = newsArticles;
+            this.total = total;
+            this.page = page;
+        }
+        return EsolveNewsArticleList;
+    }());
+
+    var EsolveNewsArticleAuthor = /** @class */ (function () {
+        function EsolveNewsArticleAuthor(userid, email, firstname, surname) {
+            this.userid = userid;
+            this.email = email;
+            this.firstname = firstname;
+            this.surname = surname;
+        }
+        return EsolveNewsArticleAuthor;
+    }());
+
+    var EsolveNewsService = /** @class */ (function () {
+        function EsolveNewsService(config, http) {
+            this.config = config;
+            this.http = http;
+        }
+        EsolveNewsService.prototype.getNewsRecords = function (params) {
+            params = params.set('ws_id', this.config.wsid);
+            return this.http.get(this.config.api_url + "/service/get-news.php", { params: params });
+        };
+        EsolveNewsService.prototype.getNewsArticle = function (identifier) {
+            var _this = this;
+            var params = new i1.HttpParams({
+                fromObject: {
+                    sef_title: identifier
+                }
+            });
+            return this.getNewsRecords(params).pipe(operators.map(function (response) {
+                if ((response.records === undefined) || (response.records.length <= 0)) {
+                    throw response;
+                }
+                var newsRecord = response.records[0];
+                if (!newsRecord.active) {
+                    throw response;
+                }
+                return _this.processNewsArticle(newsRecord);
+            }));
+        };
+        EsolveNewsService.prototype.getNewsArticles = function (options) {
+            var _this = this;
+            var params = new i1.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(operators.map(function (response) {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                var newsArticles = [];
+                response.records.forEach(function (newsArticleRecord) {
+                    newsArticles.push(_this.processNewsArticle(newsArticleRecord));
+                });
+                return new EsolveNewsArticleList(newsArticles, response.additional_data.total_records, options.page || 0);
+            }));
+        };
+        EsolveNewsService.prototype.getNewsGroups = function () {
+            var params = new i1.HttpParams();
+            params = params.set('ws_id', this.config.wsid);
+            return this.http.get(this.config.api_url + "/service/get-news-groups.php", { params: params }).pipe(operators.map(function (response) {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                var newsGroups = [];
+                response.records.forEach(function (newsGroupRecord) {
+                    newsGroups.push(new EsolveNewsGroup(newsGroupRecord.id, newsGroupRecord.name, newsGroupRecord.description, newsGroupRecord.sef_name));
+                });
+                return newsGroups;
+            }));
+        };
+        EsolveNewsService.prototype.processNewsArticle = function (newsRecord) {
+            var 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);
+        };
+        return EsolveNewsService;
+    }());
+    EsolveNewsService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveNewsService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveNewsService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveNewsService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveNewsService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }];
+        } });
+
+    var EsolveBanner = /** @class */ (function () {
+        function EsolveBanner(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;
+            }
+        }
+        return EsolveBanner;
+    }());
+
+    var EsolveBannerImage = /** @class */ (function () {
+        function EsolveBannerImage(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;
+        }
+        Object.defineProperty(EsolveBannerImage.prototype, "src", {
+            get: function () {
+                return '/images/banners/' + this.filename;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return EsolveBannerImage;
+    }());
+
+    var EsolveBannerImageHotspot = /** @class */ (function () {
+        function EsolveBannerImageHotspot(url, target, coords, coords_string) {
+            this.url = url;
+            this.target = target;
+            this.coords = coords;
+            this.coords_string = coords_string;
+        }
+        return EsolveBannerImageHotspot;
+    }());
+
+    var EsolveBannerService = /** @class */ (function () {
+        function EsolveBannerService(config, http) {
+            this.config = config;
+            this.http = http;
+        }
+        EsolveBannerService.prototype.processBannerImageHotspots = function (hotspot_records) {
+            var e_1, _a;
+            var hotspots = [];
+            if (hotspot_records.length > 0) {
+                try {
+                    for (var hotspot_records_1 = __values(hotspot_records), hotspot_records_1_1 = hotspot_records_1.next(); !hotspot_records_1_1.done; hotspot_records_1_1 = hotspot_records_1.next()) {
+                        var hotspot_record = hotspot_records_1_1.value;
+                        var hotspot = new EsolveBannerImageHotspot(hotspot_record.url, hotspot_record.target, hotspot_record.coords, hotspot_record.coords_string);
+                        hotspots.push(hotspot);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (hotspot_records_1_1 && !hotspot_records_1_1.done && (_a = hotspot_records_1.return)) _a.call(hotspot_records_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            return hotspots;
+        };
+        EsolveBannerService.prototype.processBannerImages = function (image_records, banner_type) {
+            var e_2, _a;
+            var images = [];
+            if (image_records.length > 0) {
+                try {
+                    for (var image_records_1 = __values(image_records), image_records_1_1 = image_records_1.next(); !image_records_1_1.done; image_records_1_1 = image_records_1.next()) {
+                        var image_record = image_records_1_1.value;
+                        var 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)) {
+                            var hotspots = this.processBannerImageHotspots(image_record.hotspots);
+                            image.hotspots = hotspots;
+                        }
+                        images.push(image);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (image_records_1_1 && !image_records_1_1.done && (_a = image_records_1.return)) _a.call(image_records_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            return images;
+        };
+        /**
+         * Process banner records into banner objects
+         * @param records Array of records
+         * @returns List of banners
+         */
+        EsolveBannerService.prototype.processBanners = function (records) {
+            var e_3, _a;
+            var banners = [];
+            if ((records) && (records.length > 0)) {
+                try {
+                    for (var records_1 = __values(records), records_1_1 = records_1.next(); !records_1_1.done; records_1_1 = records_1.next()) {
+                        var record = records_1_1.value;
+                        var 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);
+                        }
+                        var 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);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (records_1_1 && !records_1_1.done && (_a = records_1.return)) _a.call(records_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+            return banners;
+        };
+        /**
+         * Retrieves banners records from eSolve instance
+         *
+         * @returns An observable of eSolve banners.
+         */
+        EsolveBannerService.prototype.getBanners = function (identifier, banner_display_container, enable_date_filter) {
+            var _this = this;
+            if (enable_date_filter === void 0) { enable_date_filter = false; }
+            var params = new i1.HttpParams({
+                fromObject: {
+                    ws_id: this.config.wsid,
+                    enable_date_filter: 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: params }).pipe(operators.map(function (response) {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                return _this.processBanners(response.records);
+            }));
+        };
+        return EsolveBannerService;
+    }());
+    EsolveBannerService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveBannerService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveBannerService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveBannerService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveBannerService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }];
+        } });
+
+    var EsolveMenuItem = /** @class */ (function () {
+        function EsolveMenuItem(url, name, target, children) {
+            if (children === void 0) { children = []; }
+            this.url = url;
+            this.name = name;
+            this.target = target;
+            this.children = children;
+        }
+        return EsolveMenuItem;
+    }());
+
+    var EsolveMenuService = /** @class */ (function () {
+        function EsolveMenuService(config, http) {
+            this.config = config;
+            this.http = http;
+        }
+        EsolveMenuService.prototype.getMenuTree = function (identifier) {
+            var _this = this;
+            var menuParams = new i1.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(operators.map(function (response) {
+                if ((!response) || (response.records === undefined)) {
+                    throw response;
+                }
+                else if (response.records.length === 0) {
+                    return [];
+                }
+                return _this.handleMenu(response.records);
+            }));
+        };
+        EsolveMenuService.prototype.handleMenu = function (records) {
+            var e_1, _a;
+            var menu = [];
+            if (typeof records !== 'undefined') {
+                try {
+                    for (var records_1 = __values(records), records_1_1 = records_1.next(); !records_1_1.done; records_1_1 = records_1.next()) {
+                        var menuTreeRecord = records_1_1.value;
+                        menu.push(new EsolveMenuItem(menuTreeRecord.sef_url, menuTreeRecord.name, menuTreeRecord.target, this.handleMenu(menuTreeRecord.children)));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (records_1_1 && !records_1_1.done && (_a = records_1.return)) _a.call(records_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            return menu;
+        };
+        return EsolveMenuService;
+    }());
+    EsolveMenuService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveMenuService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveMenuService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveMenuService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveMenuService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }];
+        } });
+
+    var EsolveTopicService = /** @class */ (function () {
+        function EsolveTopicService(config, http) {
+            this.config = config;
+            this.http = http;
+        }
+        EsolveTopicService.prototype.processTopics = function (records) {
+            var e_1, _a;
+            var topics = [];
+            if (records) {
+                try {
+                    for (var records_1 = __values(records), records_1_1 = records_1.next(); !records_1_1.done; records_1_1 = records_1.next()) {
+                        var record = records_1_1.value;
+                        var topic = new EsolveTopic(+record.id, record.name, record.short_description, +record.sort_priority);
+                        topics.push(topic);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (records_1_1 && !records_1_1.done && (_a = records_1.return)) _a.call(records_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            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
+         */
+        EsolveTopicService.prototype.getTopics = function (topic_id_list) {
+            var _this = this;
+            if (topic_id_list === void 0) { topic_id_list = []; }
+            var params = new i1.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: params }).pipe(operators.map(function (response) {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                return _this.processTopics(response.records);
+            }));
+        };
+        return EsolveTopicService;
+    }());
+    EsolveTopicService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveTopicService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveTopicService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveTopicService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveTopicService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }];
+        } });
+
+    var EsolveStockBadge = /** @class */ (function () {
+        function EsolveStockBadge(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;
+        }
+        return EsolveStockBadge;
+    }());
+
+    /**
+     * Price of eSolve stock item
+     */
+    var EsolveStockPrice = /** @class */ (function () {
+        /**
+         * 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
+         */
+        function EsolveStockPrice(
+        /**
+         * 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;
+            }
+        }
+        return EsolveStockPrice;
+    }());
+
+    /**
+     * Stock Item object. It can be a service or a product (physical and/or digital).
+     */
+    var EsolveStockItem = /** @class */ (function () {
+        /**
+         * 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
+         */
+        function EsolveStockItem(
+        /**
+         * 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) {
+            if (seo_title === void 0) { seo_title = ''; }
+            if (seo_keywords === void 0) { 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);
+        }
+        Object.defineProperty(EsolveStockItem.prototype, "tiny_image_src", {
+            /**
+             * Path to tiny stock image
+             */
+            get: function () {
+                return '/images/' + (this.image_name ? 'stock/tiny/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveStockItem.prototype, "thumbnail_image_src", {
+            /**
+             * Path to thumbnail stock image
+             */
+            get: function () {
+                return '/images/' + (this.image_name ? 'stock/thumb/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveStockItem.prototype, "small_image_src", {
+            /**
+             * Path to small stock image
+             */
+            get: function () {
+                return '/images/' + (this.image_name ? 'stock/small/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveStockItem.prototype, "big_image_src", {
+            /**
+             * Path to big stock image
+             */
+            get: function () {
+                return '/images/' + (this.image_name ? 'stock/big/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveStockItem.prototype, "original_image_src", {
+            /**
+             * Path to original stock image
+             */
+            get: function () {
+                return '/images/' + (this.image_name ? 'stock/original/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return EsolveStockItem;
+    }());
+
+    /**
+     * Stock item object list
+     */
+    var EsolveStockItemList = /** @class */ (function () {
+        function EsolveStockItemList(stock_items, total, page) {
+            this.stock_items = stock_items;
+            this.total = total;
+            this.page = page;
+        }
+        return EsolveStockItemList;
+    }());
+
+    var EsolveStockService = /** @class */ (function () {
+        function EsolveStockService(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
+         */
+        EsolveStockService.prototype.processStockItem = function (record) {
+            var e_1, _b, e_2, _c, e_3, _d;
+            var tags = [];
+            var topics = [];
+            var badges = [];
+            if ((record.tags) && (record.tags.length > 0)) {
+                try {
+                    for (var _e = __values(record.tags), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var tag = _f.value;
+                        tags.push(new EsolveTag(+tag.id, tag.tag_phrase, +tag.tag_weight, tag.description));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            if ((record.topics) && (record.topics.length > 0)) {
+                try {
+                    for (var _g = __values(record.topics), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var topic = _h.value;
+                        topics.push(new EsolveTopic(+topic.id, topic.name, topic.short_description, +topic.sort_priority));
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            if ((record.badges) && (record.badges.length > 0)) {
+                try {
+                    for (var _j = __values(record.badges), _k = _j.next(); !_k.done; _k = _j.next()) {
+                        var badge = _k.value;
+                        badges.push(new EsolveStockBadge(+badge.id, badge.text, badge.identifier, badge.font_colour, badge.badge_colour, +badge.sort_priority));
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_k && !_k.done && (_d = _j.return)) _d.call(_j);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+            var 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
+         */
+        EsolveStockService.prototype.getStockRecords = function (params) {
+            params = params.set('ws_id', this.config.wsid);
+            return this.http.get(this.config.api_url + "/service/get-items.php", { params: params });
+        };
+        /**
+         * Retrieves the stock record from the eSolve instance using the code.
+         * @param code eSolve stock code
+         */
+        EsolveStockService.prototype.getStockItem = function (code) {
+            var _this = this;
+            var params = new i1.HttpParams({
+                fromObject: {
+                    code: code
+                }
+            });
+            return this.getStockRecords(params).pipe(operators.map(function (response) {
+                if ((response.records === undefined) || (response.records.length <= 0)) {
+                    throw response;
+                }
+                var 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
+         */
+        EsolveStockService.prototype.getStockItemFromSEF = function (sef_name) {
+            var _this = this;
+            var params = new i1.HttpParams({
+                fromObject: {
+                    sef_name: sef_name
+                }
+            });
+            return this.getStockRecords(params).pipe(operators.map(function (response) {
+                if ((response.records === undefined) || (response.records.length <= 0)) {
+                    throw response;
+                }
+                var stockRecord = response.records[0];
+                return _this.processStockItem(stockRecord);
+            }));
+        };
+        /**
+         * Retrieves list of stock from the eSolve instance using info provided
+         * @param options Stock filter options
+         */
+        EsolveStockService.prototype.getStockItems = function (options) {
+            var _this = this;
+            var params = new i1.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(operators.map(function (response) {
+                var _a;
+                if ((response.records === undefined) || (response.records.length <= 0)) {
+                    throw response;
+                }
+                var stockItems = [];
+                response.records.forEach(function (stockRecord) {
+                    stockItems.push(_this.processStockItem(stockRecord));
+                });
+                return new EsolveStockItemList(stockItems, +response.additional_data.total_records, (_a = options.page) !== null && _a !== void 0 ? _a : 0);
+            }));
+        };
+        return EsolveStockService;
+    }());
+    EsolveStockService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveStockService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveStockService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveStockService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveStockService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }];
+        } });
+
+    var EsolveCategoryTreeItem = /** @class */ (function () {
+        function EsolveCategoryTreeItem(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);
+        }
+        EsolveCategoryTreeItem.prototype.generateImagePath = function (image_size) {
+            if (this.image_name !== '') {
+                return "" + this.image_path + image_size + "/" + this.image_name;
+            }
+            return '';
+        };
+        Object.defineProperty(EsolveCategoryTreeItem.prototype, "small_image_src", {
+            get: function () {
+                return this.generateImagePath('small');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveCategoryTreeItem.prototype, "thumbnail_image_src", {
+            get: function () {
+                return this.generateImagePath('thumb');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveCategoryTreeItem.prototype, "tiny_image_src", {
+            get: function () {
+                return this.generateImagePath('tiny');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return EsolveCategoryTreeItem;
+    }());
+
+    var EsolveCategoryTreeService = /** @class */ (function () {
+        function EsolveCategoryTreeService(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
+         */
+        EsolveCategoryTreeService.prototype.processTree = function (tree_records) {
+            var e_1, _a;
+            var tree_items = [];
+            if (tree_records) {
+                try {
+                    for (var tree_records_1 = __values(tree_records), tree_records_1_1 = tree_records_1.next(); !tree_records_1_1.done; tree_records_1_1 = tree_records_1.next()) {
+                        var tree_record = tree_records_1_1.value;
+                        var esolve_id = '';
+                        var parent_id = '';
+                        var 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));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (tree_records_1_1 && !tree_records_1_1.done && (_a = tree_records_1.return)) _a.call(tree_records_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            return tree_items;
+        };
+        EsolveCategoryTreeService.prototype.processTreeItem = function (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);
+        };
+        EsolveCategoryTreeService.prototype.processID = function (id) {
+            var type;
+            var esolve_id;
+            var type_code_regex = /^\<\<(CAT|SUB)\>\>/g;
+            var match_results = id.match(type_code_regex);
+            if (match_results) {
+                var type_code = match_results[0];
+                type = (type_code === '<<CAT>>' ? 'category' : 'subcategory');
+                esolve_id = id.replace(type_code_regex, '');
+                return {
+                    type: type,
+                    esolve_id: esolve_id
+                };
+            }
+            return null;
+        };
+        /**
+         * Retrieves the category tree from eSolve instance and coverts it to the correct format.
+         */
+        EsolveCategoryTreeService.prototype.getCategoryTree = function () {
+            var _this = this;
+            var params = new i1.HttpParams();
+            params = params.set('ws_id', this.config.wsid);
+            return this.http.get(this.config.api_url + "/service/get-tree.php", { params: params }).pipe(operators.map(function (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
+         */
+        EsolveCategoryTreeService.prototype.getCategoryTreeItem = function (options) {
+            var _this = this;
+            var type;
+            var esolve_id;
+            var sef_description;
+            if (options.id) {
+                var 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)) {
+                var params = new i1.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: params }).pipe(operators.map(function (response) {
+                    if ((response.records === undefined) || (response.records.length <= 0)) {
+                        throw response;
+                    }
+                    return _this.processTreeItem(response.records[0]);
+                }));
+            }
+            return rxjs.throwError('Invalid options');
+        };
+        return EsolveCategoryTreeService;
+    }());
+    EsolveCategoryTreeService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveCategoryTreeService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveCategoryTreeService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveCategoryTreeService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveCategoryTreeService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }];
+        } });
+
+    var EsolveStockLocation = /** @class */ (function () {
+        function EsolveStockLocation(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);
+            var 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);
+        }
+        return EsolveStockLocation;
+    }());
+    var EsolveStockLocationAddress = /** @class */ (function () {
+        function EsolveStockLocationAddress(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;
+        }
+        return EsolveStockLocationAddress;
+    }());
+    var EsolveStockLocationPOBoxAddress = /** @class */ (function () {
+        function EsolveStockLocationPOBoxAddress(pobox, city, postal_code) {
+            this.pobox = pobox;
+            this.city = city;
+            this.postal_code = postal_code;
+        }
+        return EsolveStockLocationPOBoxAddress;
+    }());
+    var EsolveStockLocationContactInfo = /** @class */ (function () {
+        function EsolveStockLocationContactInfo(telnumber, cellnumber, email, fax) {
+            this.telnumber = telnumber;
+            this.cellnumber = cellnumber;
+            this.email = email;
+            this.fax = fax;
+        }
+        return EsolveStockLocationContactInfo;
+    }());
+    var EsolveStockLocationTradingTimes = /** @class */ (function () {
+        function EsolveStockLocationTradingTimes(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) {
+            if (trading_hours_additional_info === void 0) { 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);
+        }
+        return EsolveStockLocationTradingTimes;
+    }());
+    var EsolveStockLocationTradingTimesDay = /** @class */ (function () {
+        function EsolveStockLocationTradingTimesDay(open, close) {
+            this.open = open;
+            this.close = close;
+        }
+        return EsolveStockLocationTradingTimesDay;
+    }());
+
+    var EsolveCartItem = /** @class */ (function () {
+        function EsolveCartItem(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;
+        }
+        return EsolveCartItem;
+    }());
+
+    var EsolveShippingMethod = /** @class */ (function () {
+        function EsolveShippingMethod(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;
+        }
+        return EsolveShippingMethod;
+    }());
+
+    var EsolvePaymentMethod = /** @class */ (function () {
+        function EsolvePaymentMethod(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 BankingDetails(record.bank_name, record.account_holder, record.account, record.account_type, record.swift_number, record.branch_code);
+        }
+        return EsolvePaymentMethod;
+    }());
+    var BankingDetails = /** @class */ (function () {
+        function BankingDetails(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;
+        }
+        return BankingDetails;
+    }());
+
+    var EsolveShippingCost = /** @class */ (function () {
+        function EsolveShippingCost(
+        // Shipping
+        shipping_total, shipping_vat, shipping_total_savings, 
+        // Insurance
+        insurance_total, insurance_vat, insurance_total_savings) {
+            if (shipping_total === void 0) { shipping_total = 0; }
+            if (shipping_vat === void 0) { shipping_vat = 0; }
+            if (shipping_total_savings === void 0) { shipping_total_savings = 0; }
+            if (insurance_total === void 0) { insurance_total = 0; }
+            if (insurance_vat === void 0) { insurance_vat = 0; }
+            if (insurance_total_savings === void 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);
+        }
+        return EsolveShippingCost;
+    }());
+    var EsolveShippingTotals = /** @class */ (function () {
+        function EsolveShippingTotals(total, vat, savings) {
+            this.total = total;
+            this.vat = vat;
+            this.savings = savings;
+        }
+        return EsolveShippingTotals;
+    }());
+
+    /**
+     * Totals in cart
+     */
+    var EsolveCartTotals = /** @class */ (function () {
+        function EsolveCartTotals(
+        /**
+         * Number of unique records in cart
+         */
+        records, 
+        /**
+         * Total quantity of all items in a cart
+         */
+        items, 
+        /**
+         * Total in cart before discount and VAT is added
+         */
+        sub_total, 
+        /**
+         * Total VAT of all the items in the cart
+         */
+        vat_total, 
+        /**
+         * Total discount of all the item in the cart
+         */
+        discount_total) {
+            if (records === void 0) { records = 0; }
+            if (items === void 0) { items = 0; }
+            if (sub_total === void 0) { sub_total = 0; }
+            if (vat_total === void 0) { vat_total = 0; }
+            if (discount_total === void 0) { discount_total = 0; }
+            this.records = records;
+            this.items = items;
+            this.sub_total = sub_total;
+            this.vat_total = vat_total;
+            this.discount_total = discount_total;
+        }
+        Object.defineProperty(EsolveCartTotals.prototype, "total", {
+            /**
+             * Grand total of cart which includes discount and VAT (NOTE: shipping and insurance is not included)
+             */
+            get: function () {
+                return this.sub_total + this.vat_total - this.discount_total;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return EsolveCartTotals;
+    }());
+
+    var EsolveCartStockItem = /** @class */ (function () {
+        function EsolveCartStockItem(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;
+        }
+        Object.defineProperty(EsolveCartStockItem.prototype, "tiny_image_src", {
+            /**
+             * Path to tiny stock image
+             */
+            get: function () {
+                return '/images/' + (this.image_name ? 'stock/tiny/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveCartStockItem.prototype, "thumbnail_image_src", {
+            /**
+             * Path to thumbnail stock image
+             */
+            get: function () {
+                return '/images/' + (this.image_name ? 'stock/thumb/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveCartStockItem.prototype, "small_image_src", {
+            /**
+             * Path to small stock image
+             */
+            get: function () {
+                return '/images/' + (this.image_name ? 'stock/small/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveCartStockItem.prototype, "big_image_src", {
+            /**
+             * Path to big stock image
+             */
+            get: function () {
+                return '/images/' + (this.image_name ? 'stock/big/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EsolveCartStockItem.prototype, "original_image_src", {
+            /**
+             * Path to original stock image
+             */
+            get: function () {
+                return 'images/' + (this.image_name ? 'stock/original/' + this.image_name : 'no_image.jpg');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return EsolveCartStockItem;
+    }());
+
+    var EsolveCartService = /** @class */ (function () {
+        function EsolveCartService(config, http) {
+            this.config = config;
+            this.http = http;
+            this._cached_tracking = 0;
+        }
+        /**
+         * Processes the eSolve tree records.
+         * @param cart_item_records Records to process
+         * @returns An array of processed cart items
+         */
+        EsolveCartService.prototype.processCart = function (cart_item_records) {
+            var e_1, _a;
+            var cart_items = [];
+            if (cart_item_records) {
+                try {
+                    for (var cart_item_records_1 = __values(cart_item_records), cart_item_records_1_1 = cart_item_records_1.next(); !cart_item_records_1_1.done; cart_item_records_1_1 = cart_item_records_1.next()) {
+                        var cart_item_record = cart_item_records_1_1.value;
+                        var 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));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (cart_item_records_1_1 && !cart_item_records_1_1.done && (_a = cart_item_records_1.return)) _a.call(cart_item_records_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            return cart_items;
+        };
+        /**
+         * Processes the eSolve stock location records.
+         * @param records Records to process
+         * @returns An array of processed stock location records
+         */
+        EsolveCartService.prototype.processStockLocations = function (records) {
+            var e_2, _a;
+            var stock_locations = [];
+            if (records) {
+                try {
+                    for (var records_1 = __values(records), records_1_1 = records_1.next(); !records_1_1.done; records_1_1 = records_1.next()) {
+                        var record = records_1_1.value;
+                        stock_locations.push(new EsolveStockLocation(record));
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (records_1_1 && !records_1_1.done && (_a = records_1.return)) _a.call(records_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            return stock_locations;
+        };
+        /**
+         * Processes the eSolve shipping method records.
+         * @param records Records to process
+         * @returns An array of processed shipping methods
+         */
+        EsolveCartService.prototype.processShippingMethods = function (records) {
+            var e_3, _a;
+            var shipping_methods = [];
+            if (records) {
+                try {
+                    for (var records_2 = __values(records), records_2_1 = records_2.next(); !records_2_1.done; records_2_1 = records_2.next()) {
+                        var record = records_2_1.value;
+                        var 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);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (records_2_1 && !records_2_1.done && (_a = records_2.return)) _a.call(records_2);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+            return shipping_methods;
+        };
+        /**
+         * Processes the eSolve payment method records.
+         * @param records Records to process
+         * @returns An array of processed payment methods.
+         */
+        EsolveCartService.prototype.processPaymentMethods = function (records) {
+            var e_4, _a;
+            var payment_methods = [];
+            if (records) {
+                try {
+                    for (var records_3 = __values(records), records_3_1 = records_3.next(); !records_3_1.done; records_3_1 = records_3.next()) {
+                        var record = records_3_1.value;
+                        var payment_method = new EsolvePaymentMethod(record);
+                        payment_methods.push(payment_method);
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (records_3_1 && !records_3_1.done && (_a = records_3.return)) _a.call(records_3);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            }
+            return payment_methods;
+        };
+        /**
+         * Processes the eSolve shipping costs record.
+         * @param record Data to process
+         * @returns Processed shipping costs
+         */
+        EsolveCartService.prototype.processShippingCost = function (record) {
+            var 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;
+        };
+        /**
+         * Processes the eSolve cart totals
+         * @param record Data to process
+         * @returns Processed cart totals
+         */
+        EsolveCartService.prototype.processCartTotals = function (record) {
+            var 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
+         */
+        EsolveCartService.prototype.getCart = function () {
+            var _this = this;
+            var params = new i1.HttpParams();
+            params = params.set('ws_id', this.config.wsid);
+            return this.http.get(this.config.api_url + "/service/get-cart.php", { params: params }).pipe(operators.map(function (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
+         */
+        EsolveCartService.prototype.setCart = function (items, action) {
+            if (action === void 0) { action = 'add'; }
+            var body = {
+                items: items,
+                action: 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(operators.map(function (response) {
+                if (response.responses === undefined) {
+                    throw response;
+                }
+                return response.responses;
+            }));
+        };
+        /**
+         * Retrieves a list of stock locations
+         * @returns An `Observable` with an array of stock locations
+         */
+        EsolveCartService.prototype.getStockLocations = function () {
+            var _this = this;
+            var params = new i1.HttpParams();
+            params = params.set('ws_id', this.config.wsid);
+            return this.http.get(this.config.api_url + "/service/get-locations.php", { params: params }).pipe(operators.map(function (response) {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                return _this.processStockLocations(response.records);
+            }));
+        };
+        /**
+         * Retrieves a list of shipping methods
+         * @returns An `Observable` with an array of shipping methods
+         */
+        EsolveCartService.prototype.getShippingMethods = function (options) {
+            var _this = this;
+            var params = new i1.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.toString());
+                }
+                if (typeof options.location_id !== 'undefined') {
+                    params = params.set('location_id', options.location_id.toString());
+                }
+            }
+            return this.http.get(this.config.api_url + "/service/get-shipping-methods.php", { params: params }).pipe(operators.map(function (response) {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                return _this.processShippingMethods(response.records);
+            }));
+        };
+        /**
+         * Retrieves a list of payment methods
+         * @returns  An `Observable` with an array of payment methods
+         */
+        EsolveCartService.prototype.getPaymentMethods = function (options) {
+            var _this = this;
+            var params = new i1.HttpParams();
+            params = params.set('ws_id', this.config.wsid);
+            if (options) {
+                if (typeof options.live !== 'undefined') {
+                    params = params.set('live', options.live.toString());
+                }
+                if (typeof options.location_id !== 'undefined') {
+                    params = params.set('location_id', options.location_id.toString());
+                }
+                if (typeof options.is_gateway !== 'undefined') {
+                    params = params.set('is_gateway', options.is_gateway.toString());
+                }
+            }
+            return this.http.get(this.config.api_url + "/service/get-payment-methods.php", { params: params }).pipe(operators.map(function (response) {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                return _this.processPaymentMethods(response.records);
+            }));
+        };
+        /**
+         * Retrieves the shipping costs
+         * @param options Shipping cost options
+         * @returns An `Observable` with the shipping costs
+         */
+        EsolveCartService.prototype.getShippingCost = function (options) {
+            var _this = this;
+            var params = new i1.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.toString());
+                }
+                else {
+                    return rxjs.throwError(new Error('Address ID is required'));
+                }
+                if (typeof options.shipping_id !== 'undefined') {
+                    params = params.set('shipping_id', options.shipping_id.toString());
+                }
+                else {
+                    return rxjs.throwError(new Error('Shipping ID is required'));
+                }
+                if (typeof options.location_id !== 'undefined') {
+                    params = params.set('location_id', options.location_id.toString());
+                }
+            }
+            else {
+                return rxjs.throwError(new Error('Options are invalid'));
+            }
+            return this.http.get(this.config.api_url + "/service/get-shipping-cost.php", { params: params }).pipe(operators.map(function (response) {
+                if (response.records === undefined) {
+                    throw response;
+                }
+                return _this.processShippingCost(response.records[0]);
+            }));
+        };
+        /**
+         * Retrieves the totals of the cart with all the totals calculated
+         * @returns An `Observable` with an object containing cart totals
+         */
+        EsolveCartService.prototype.getTotals = function () {
+            var _this = this;
+            var params = new i1.HttpParams();
+            params = params.set('ws_id', this.config.wsid);
+            return this.http.get(this.config.api_url + "/service/get-cart-totals.php", { params: params }).pipe(operators.map(function (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
+         */
+        EsolveCartService.prototype.getTrackingCode = function () {
+            var _this = this;
+            var params = new i1.HttpParams();
+            params = params.set('ws_id', this.config.wsid);
+            return rxjs.iif(function () { return _this._cached_tracking > 0; }, rxjs.of(this._cached_tracking), this.http.get(this.config.api_url + "/service/get-checkout-tracking.php", { params: params }).pipe(operators.map(function (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
+         */
+        EsolveCartService.prototype.checkout = function (type, addresses_id, shipping_id, payment_method_id, location_id, comments) {
+            var _this = this;
+            if (payment_method_id === void 0) { payment_method_id = 0; }
+            if (location_id === void 0) { location_id = 0; }
+            if (comments === void 0) { comments = ''; }
+            var body = {
+                type: type,
+                addresses_id: addresses_id,
+                shipping_id: shipping_id,
+                payment_method_id: payment_method_id,
+                location_id: location_id,
+                comments: comments,
+                tracking: 0
+            };
+            return this.getTrackingCode().pipe(operators.switchMap(function (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(operators.map(function (response) {
+                    if ((response.responses === undefined) || (response.responses.length <= 0)) {
+                        throw response;
+                    }
+                    var checkout_result = response.responses[0];
+                    if (checkout_result.status.state !== 'success') {
+                        throw checkout_result;
+                    }
+                    return checkout_result.esolve_id;
+                }), operators.catchError(function (errorRes) {
+                    var parseException = function (exception) {
+                        var exception_type = exception.additional_data.exception_type;
+                        var error = {
+                            type: 'exception',
+                            message: exception.message || '',
+                            error_code: exception_type || 'unknown'
+                        };
+                        return error;
+                    };
+                    var parseCheckoutErrors = function (response) {
+                        var error = {
+                            type: 'error',
+                            message: 'Unknown error has occured',
+                            error_code: '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') {
+                            var error_log = response.log[0];
+                            error.error_code = error_log.message_code;
+                            error.message = error_log.message;
+                        }
+                        return error;
+                    };
+                    if (errorRes instanceof i1.HttpErrorResponse) {
+                        if (errorRes.status === 500) {
+                            var server_error = errorRes.error;
+                            if ((server_error.service_type === 'set-checkout') ||
+                                (server_error.type !== undefined) ||
+                                (server_error.message !== undefined) ||
+                                (server_error.additional_data !== undefined)) {
+                                return rxjs.throwError(parseException(server_error));
+                            }
+                        }
+                    }
+                    else {
+                        if (errorRes.type !== undefined) {
+                            if (errorRes.type === 'exception') {
+                                return rxjs.throwError(parseException(errorRes));
+                            }
+                        }
+                        else if (errorRes.transaction_type !== undefined) {
+                            return rxjs.throwError(parseCheckoutErrors(errorRes));
+                        }
+                    }
+                    return rxjs.throwError(errorRes);
+                }));
+            }));
+        };
+        return EsolveCartService;
+    }());
+    EsolveCartService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveCartService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EsolveCartService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveCartService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0__namespace, type: EsolveCartService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [ESOLVE_CONNECT_CONFIG]
+                        }] }, { type: i1__namespace.HttpClient }];
+        } });
+
+    /*
+     * Public API Surface of ng-esolve-connect
+     */
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    exports.BankingDetails = BankingDetails;
+    exports.EsolveAccountService = EsolveAccountService;
+    exports.EsolveAddress = EsolveAddress;
+    exports.EsolveAuthService = EsolveAuthService;
+    exports.EsolveBanner = EsolveBanner;
+    exports.EsolveBannerImage = EsolveBannerImage;
+    exports.EsolveBannerImageHotspot = EsolveBannerImageHotspot;
+    exports.EsolveBannerService = EsolveBannerService;
+    exports.EsolveCartItem = EsolveCartItem;
+    exports.EsolveCartService = EsolveCartService;
+    exports.EsolveCartTotals = EsolveCartTotals;
+    exports.EsolveCategoryTreeItem = EsolveCategoryTreeItem;
+    exports.EsolveCategoryTreeService = EsolveCategoryTreeService;
+    exports.EsolveMediaArticle = EsolveMediaArticle;
+    exports.EsolveMediaService = EsolveMediaService;
+    exports.EsolveMenuItem = EsolveMenuItem;
+    exports.EsolveMenuService = EsolveMenuService;
+    exports.EsolveNewsArticle = EsolveNewsArticle;
+    exports.EsolveNewsArticleAuthor = EsolveNewsArticleAuthor;
+    exports.EsolveNewsArticleList = EsolveNewsArticleList;
+    exports.EsolveNewsGroup = EsolveNewsGroup;
+    exports.EsolveNewsService = EsolveNewsService;
+    exports.EsolvePaymentMethod = EsolvePaymentMethod;
+    exports.EsolveSEOInfo = EsolveSEOInfo;
+    exports.EsolveSeoService = EsolveSeoService;
+    exports.EsolveSession = EsolveSession;
+    exports.EsolveSessionService = EsolveSessionService;
+    exports.EsolveShippingCost = EsolveShippingCost;
+    exports.EsolveShippingMethod = EsolveShippingMethod;
+    exports.EsolveStockBadge = EsolveStockBadge;
+    exports.EsolveStockItem = EsolveStockItem;
+    exports.EsolveStockItemList = EsolveStockItemList;
+    exports.EsolveStockLocation = EsolveStockLocation;
+    exports.EsolveStockPrice = EsolveStockPrice;
+    exports.EsolveStockService = EsolveStockService;
+    exports.EsolveTag = EsolveTag;
+    exports.EsolveTopic = EsolveTopic;
+    exports.EsolveTopicService = EsolveTopicService;
+    exports.NgEsolveConnectModule = NgEsolveConnectModule;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=esolve-ng-esolve-connect.umd.js.map