bruce-models 0.0.1 → 0.0.3

package/dist/bruce-models.es5.js

@@ -0,0 +1,4784 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+/* 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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    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 __awaiter(thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(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 Api;
+(function (Api) {
+    var ECacheKey;
+    (function (ECacheKey) {
+        ECacheKey["Id"] = ":";
+        ECacheKey["Entity"] = "entity";
+        ECacheKey["EntityType"] = "entitytype";
+        ECacheKey["ProjectView"] = "projectview";
+        ECacheKey["ProjectViewBookmark"] = "pvbookmark";
+        ECacheKey["Tileset"] = "tileset";
+        ECacheKey["ClientFile"] = "clientfile";
+        ECacheKey["Session"] = "session";
+        ECacheKey["PendingAction"] = "pendingaction";
+        ECacheKey["EntitySource"] = "entitysource";
+        ECacheKey["ProgramKey"] = "programkey";
+        ECacheKey["Ucs"] = "ucs";
+        ECacheKey["Tag"] = "tag";
+        ECacheKey["Attachment"] = "attachment";
+        ECacheKey["Comment"] = "comment";
+        ECacheKey["Link"] = "link";
+        ECacheKey["AnnDocument"] = "anndocument";
+        ECacheKey["AttachmentType"] = "attachmenttype";
+        ECacheKey["Relation"] = "relation";
+        ECacheKey["RelationType"] = "relationtype";
+        ECacheKey["Lod"] = "lod";
+        ECacheKey["Style"] = "style";
+        ECacheKey["PublishTileset"] = "publishtileset";
+        ECacheKey["User"] = "user";
+        ECacheKey["AccessToken"] = "accesstoken";
+        ECacheKey["UserGroup"] = "usergroup";
+        ECacheKey["Account"] = "account";
+    })(ECacheKey = Api.ECacheKey || (Api.ECacheKey = {}));
+    Api.DEFAULT_CACHE_DURATION = 60 * 5; // 5 minutes.
+    Api.TEMPLATE_ACCOUNT_ID = "template";
+    Api.ACCESS_TOKEN_HEADER = "X-Access-Token";
+    function Encode(str) {
+        return encodeURIComponent(str.replace(/\+/g, "%2B").replace(/\./g, "%2E"));
+    }
+    Api.Encode = Encode;
+    var ESortOrder;
+    (function (ESortOrder) {
+        ESortOrder[ESortOrder["None"] = 0] = "None";
+        ESortOrder[ESortOrder["Asc"] = 1] = "Asc";
+        ESortOrder[ESortOrder["Desc"] = -1] = "Desc";
+    })(ESortOrder = Api.ESortOrder || (Api.ESortOrder = {}));
+    var EEncoding;
+    (function (EEncoding) {
+        EEncoding["UTF8"] = "UTF-8";
+        EEncoding["UTF16"] = "UTF-16BE";
+    })(EEncoding = Api.EEncoding || (Api.EEncoding = {}));
+    var EEnv;
+    (function (EEnv) {
+        EEnv["DEV"] = "DEV";
+        EEnv["STG"] = "STG";
+        EEnv["UAT"] = "UAT";
+        EEnv["PROD"] = "PROD";
+    })(EEnv = Api.EEnv || (Api.EEnv = {}));
+    function PrepReqParams() {
+        return { response: { encoding: Api.EEncoding.UTF16 } };
+    }
+    Api.PrepReqParams = PrepReqParams;
+})(Api || (Api = {}));
+
+var AnnDocument;
+(function (AnnDocument) {
+    function GetCacheKey(id) {
+        return "" + Api.ECacheKey.AnnDocument + Api.ECacheKey.Id + id;
+    }
+    AnnDocument.GetCacheKey = GetCacheKey;
+    function GetListCacheKey(type) {
+        return Api.ECacheKey.AnnDocument + type;
+    }
+    AnnDocument.GetListCacheKey = GetListCacheKey;
+    var EType;
+    (function (EType) {
+        EType["SVG"] = "SVG";
+    })(EType = AnnDocument.EType || (AnnDocument.EType = {}));
+    function Get(api, docId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!docId) {
+                    throw ("Doc ID is required.");
+                }
+                key = GetCacheKey(docId);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("documentView/" + docId, Api.PrepReqParams());
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    AnnDocument.Get = Get;
+    function GetList(api, type) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!type) {
+                    type = "";
+                }
+                cacheData = api.Cache.Get(GetListCacheKey(type));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var url, data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                url = "documentViews" + (type ? "?type=" + type : "");
+                                return [4 /*yield*/, api.GET(url, Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(type), req);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    AnnDocument.GetList = GetList;
+})(AnnDocument || (AnnDocument = {}));
+
+var CacheItem = /** @class */ (function () {
+    function CacheItem(id, data, duration) {
+        this.Id = id;
+        this.Data = data;
+        this.Duration = duration;
+        this._created = duration > -1 ? new Date() : null;
+    }
+    CacheItem.prototype.IsExpired = function () {
+        if (this._created == null) {
+            return false;
+        }
+        return (new Date().getTime() - this._created.getTime()) / 1000 > this.Duration;
+    };
+    return CacheItem;
+}());
+var CacheControl = /** @class */ (function () {
+    function CacheControl() {
+        this.data = {};
+    }
+    CacheControl.prototype.Set = function (id, data, duration) {
+        if (duration === void 0) { duration = -1; }
+        this.data[id + ""] = new CacheItem(id + "", data, duration);
+    };
+    CacheControl.prototype.Get = function (id) {
+        var item = this.data[id + ""];
+        if (item == null) {
+            return null;
+        }
+        if (item.IsExpired()) {
+            delete this.data[id + ""];
+            return null;
+        }
+        return item.Data;
+    };
+    CacheControl.prototype.Clear = function () {
+        this.data = {};
+    };
+    CacheControl.prototype.Remove = function (id) {
+        delete this.data[id + ""];
+    };
+    CacheControl.prototype.RemoveByStartsWith = function (text) {
+        for (var key in this.data) {
+            if (key.startsWith(text)) {
+                delete this.data[key];
+            }
+        }
+    };
+    CacheControl.prototype.RemoveByContains = function (text) {
+        for (var key in this.data) {
+            if (key.includes(text)) {
+                delete this.data[key];
+            }
+        }
+    };
+    CacheControl.prototype.GetKeys = function () {
+        return Object.keys(this.data);
+    };
+    CacheControl.prototype.GetValues = function () {
+        var values = [];
+        for (var key in this.data) {
+            var data = this.Get(key);
+            if (data != null) {
+                values.push(data);
+            }
+        }
+        return values;
+    };
+    return CacheControl;
+}());
+
+function parseResult(data, encoding) {
+    return __awaiter(this, void 0, void 0, function () {
+        var buffer, error;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(data.status == 200)) return [3 /*break*/, 4];
+                    if (!encoding) return [3 /*break*/, 2];
+                    return [4 /*yield*/, data.arrayBuffer()];
+                case 1:
+                    buffer = _a.sent();
+                    return [2 /*return*/, JSON.parse(new TextDecoder(encoding).decode(buffer))];
+                case 2: return [2 /*return*/, data.json()];
+                case 3: return [3 /*break*/, 6];
+                case 4: return [4 /*yield*/, data.json()];
+                case 5:
+                    error = _a.sent();
+                    throw (error);
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+}
+var AbstractApi = /** @class */ (function () {
+    function AbstractApi(ssidHeader) {
+        this.ssid = "";
+        this.Cache = new CacheControl();
+        this.ssidHeader = ssidHeader;
+    }
+    AbstractApi.prototype.GetSessionId = function () {
+        return this.ssid;
+    };
+    AbstractApi.prototype.SetSessionId = function (value) {
+        this.ssid = value;
+    };
+    AbstractApi.prototype.GetSessionHeader = function () {
+        return this.ssidHeader;
+    };
+    AbstractApi.prototype.SetSessionHeader = function (value) {
+        this.ssidHeader = value;
+    };
+    AbstractApi.prototype.get = function (url, params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!params) {
+                            params = {};
+                        }
+                        params.headers = params.headers || {};
+                        params.headers = __assign((_b = { "Content-Type": "application/json;" }, _b[this.ssidHeader] = this.ssid, _b), params.headers);
+                        return [4 /*yield*/, fetch(url, {
+                                headers: params.headers
+                            })];
+                    case 1:
+                        res = _c.sent();
+                        return [2 /*return*/, parseResult(res, (_a = params.response) === null || _a === void 0 ? void 0 : _a.encoding)];
+                }
+            });
+        });
+    };
+    AbstractApi.prototype.delete = function (url, params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!params) {
+                            params = {};
+                        }
+                        params.headers = params.headers || {};
+                        params.headers = __assign((_b = { "Content-Type": "application/json;" }, _b[this.ssidHeader] = this.ssid, _b), params.headers);
+                        return [4 /*yield*/, fetch(url, {
+                                headers: params.headers,
+                                method: "DELETE"
+                            })];
+                    case 1:
+                        res = _c.sent();
+                        return [2 /*return*/, parseResult(res, (_a = params.response) === null || _a === void 0 ? void 0 : _a.encoding)];
+                }
+            });
+        });
+    };
+    AbstractApi.prototype.post = function (url, data, params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!params) {
+                            params = {};
+                        }
+                        params.headers = params.headers || {};
+                        params.headers = __assign((_b = { "Content-Type": "application/json;" }, _b[this.ssidHeader] = this.ssid, _b), params.headers);
+                        if (!data) {
+                            data = {};
+                        }
+                        if (typeof data != "string") {
+                            data = JSON.stringify(data);
+                        }
+                        return [4 /*yield*/, fetch(url, {
+                                headers: params.headers,
+                                method: "POST",
+                                body: data
+                            })];
+                    case 1:
+                        res = _c.sent();
+                        return [2 /*return*/, parseResult(res, (_a = params.response) === null || _a === void 0 ? void 0 : _a.encoding)];
+                }
+            });
+        });
+    };
+    AbstractApi.prototype.upload = function (url, blob, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (res, rej) {
+                        try {
+                            var xhr_1 = new XMLHttpRequest();
+                            var headers = params === null || params === void 0 ? void 0 : params.headers;
+                            if (headers) {
+                                var headerKeys = Object.keys(headers);
+                                for (var i = 0; i < headerKeys.length; i++) {
+                                    var key = headerKeys[i];
+                                    var value = headers[key];
+                                    xhr_1.setRequestHeader(key, value);
+                                }
+                            }
+                            if (params === null || params === void 0 ? void 0 : params.onProgress) {
+                                if (xhr_1.upload) {
+                                    xhr_1.upload.onprogress = params === null || params === void 0 ? void 0 : params.onProgress;
+                                }
+                                else {
+                                    xhr_1.addEventListener("progress", params === null || params === void 0 ? void 0 : params.onProgress);
+                                }
+                            }
+                            xhr_1.onreadystatechange = function (e) {
+                                if (xhr_1.readyState == 4) {
+                                    if (xhr_1.status >= 400) {
+                                        rej(e);
+                                    }
+                                    else {
+                                        try {
+                                            res(JSON.parse(xhr_1.responseText));
+                                        }
+                                        catch (e) {
+                                            console.error(e, xhr_1.responseText);
+                                            res(xhr_1.responseText);
+                                        }
+                                    }
+                                }
+                            };
+                            xhr_1.open("POST", url, true);
+                            if (_this.ssid) {
+                                xhr_1.setRequestHeader(_this.ssidHeader, _this.ssid);
+                            }
+                            var formData = new FormData();
+                            formData.append("file", blob);
+                            xhr_1.send(formData);
+                        }
+                        catch (e) {
+                            rej(e);
+                        }
+                    })];
+            });
+        });
+    };
+    return AbstractApi;
+}());
+
+var BruceApi = /** @class */ (function (_super) {
+    __extends(BruceApi, _super);
+    function BruceApi(accountId, env) {
+        var _this = _super.call(this, "x-sessionid") || this;
+        _this.baseUrl = "";
+        _this.accountId = accountId;
+        _this.env = env !== null && env !== void 0 ? env : Api.EEnv.PROD;
+        _this.setBaseUrl();
+        return _this;
+    }
+    BruceApi.prototype.setBaseUrl = function () {
+        var prefix = "https://" + this.accountId + ".api.nextspace";
+        var url;
+        var env = this.env.toUpperCase();
+        switch (env) {
+            case Api.EEnv.DEV:
+                url = prefix + "-dev.net/";
+                break;
+            case Api.EEnv.STG:
+                url = prefix + "-stg.net/";
+                break;
+            case Api.EEnv.UAT:
+                url = prefix + "-uat.net/";
+                break;
+            case Api.EEnv.PROD:
+                url = prefix + ".host/";
+                break;
+            default:
+                throw ("Specified Environment is not valid. SuppliedEnv=" + env);
+        }
+        this.baseUrl = url;
+    };
+    BruceApi.prototype.GetBaseUrl = function () {
+        return this.baseUrl;
+    };
+    BruceApi.prototype.GET = function (url, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.get(this.baseUrl + url, params)];
+            });
+        });
+    };
+    BruceApi.prototype.DELETE = function (url, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.delete(this.baseUrl + url, params)];
+            });
+        });
+    };
+    BruceApi.prototype.POST = function (url, data, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.post(this.baseUrl + url, data, params)];
+            });
+        });
+    };
+    BruceApi.prototype.UPLOAD = function (url, blob, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.upload(this.baseUrl + url, blob, params)];
+            });
+        });
+    };
+    return BruceApi;
+}(AbstractApi));
+
+var CamApi = /** @class */ (function (_super) {
+    __extends(CamApi, _super);
+    function CamApi(env) {
+        var _this = _super.call(this, "SSID") || this;
+        _this.baseUrl = "";
+        _this.env = env !== null && env !== void 0 ? env : Api.EEnv.PROD;
+        _this.setBaseUrl();
+        return _this;
+    }
+    CamApi.prototype.setBaseUrl = function () {
+        var prefix = "https://cam.nextspace";
+        var url;
+        var env = this.env.toUpperCase();
+        switch (env) {
+            case Api.EEnv.DEV:
+                url = prefix + "-dev.net/";
+                break;
+            case Api.EEnv.STG:
+                url = prefix + "-stg.net/";
+                break;
+            case Api.EEnv.UAT:
+                url = prefix + "-uat.net/";
+                break;
+            case Api.EEnv.PROD:
+                url = prefix + ".host/";
+                break;
+            default:
+                throw ("Specified Environment is not valid. SuppliedEnv=" + env);
+        }
+        this.baseUrl = url;
+    };
+    CamApi.prototype.GetBaseUrl = function () {
+        return this.baseUrl;
+    };
+    CamApi.prototype.GET = function (url, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.get(this.baseUrl + url, params)];
+            });
+        });
+    };
+    CamApi.prototype.DELETE = function (url, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.delete(this.baseUrl + url, params)];
+            });
+        });
+    };
+    CamApi.prototype.POST = function (url, data, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.post(this.baseUrl + url, data, params)];
+            });
+        });
+    };
+    CamApi.prototype.UPLOAD = function (url, blob, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.upload(this.baseUrl + url, blob, params)];
+            });
+        });
+    };
+    return CamApi;
+}(AbstractApi));
+
+var IdmApi = /** @class */ (function (_super) {
+    __extends(IdmApi, _super);
+    function IdmApi(env) {
+        var _this = _super.call(this, "SSID") || this;
+        _this.baseUrl = "";
+        _this.env = env !== null && env !== void 0 ? env : Api.EEnv.PROD;
+        _this.setBaseUrl();
+        return _this;
+    }
+    IdmApi.prototype.setBaseUrl = function () {
+        var prefix = "https://idm.nextspace";
+        var url;
+        var env = this.env.toUpperCase();
+        switch (env) {
+            case Api.EEnv.DEV:
+                url = prefix + "-dev.net/";
+                break;
+            case Api.EEnv.STG:
+                url = prefix + "-stg.net/";
+                break;
+            case Api.EEnv.UAT:
+                url = prefix + "-uat.net/";
+                break;
+            case Api.EEnv.PROD:
+                url = prefix + ".host/";
+                break;
+            default:
+                throw ("Specified Environment is not valid. SuppliedEnv1=" + env);
+        }
+        this.baseUrl = url;
+    };
+    IdmApi.prototype.GetBaseUrl = function () {
+        return this.baseUrl;
+    };
+    IdmApi.prototype.GET = function (url, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.get(this.baseUrl + url, params)];
+            });
+        });
+    };
+    IdmApi.prototype.DELETE = function (url, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.delete(this.baseUrl + url, params)];
+            });
+        });
+    };
+    IdmApi.prototype.POST = function (url, data, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.post(this.baseUrl + url, data, params)];
+            });
+        });
+    };
+    IdmApi.prototype.UPLOAD = function (url, blob, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.upload(this.baseUrl + url, blob, params)];
+            });
+        });
+    };
+    return IdmApi;
+}(AbstractApi));
+
+var Color;
+(function (Color) {
+    var EBlendMode;
+    (function (EBlendMode) {
+        EBlendMode[EBlendMode["HIGHLIGHT"] = 0] = "HIGHLIGHT";
+        EBlendMode[EBlendMode["REPLACE"] = 1] = "REPLACE";
+        EBlendMode[EBlendMode["MIX"] = 2] = "MIX";
+    })(EBlendMode = Color.EBlendMode || (Color.EBlendMode = {}));
+    function RandomColor() {
+        // https://stackoverflow.com/a/7352887
+        var brightness = 4;
+        var rgb = [Math.random() * 256, Math.random() * 256, Math.random() * 256];
+        var mix = [brightness * 51, brightness * 51, brightness * 51];
+        var mixedrgb = [rgb[0] + mix[0], rgb[1] + mix[1], rgb[2] + mix[2]].map(function (x) {
+            return Math.round(x / 2.0);
+        });
+        var str = "rgba(" + mixedrgb.join(",") + ",0.9" + ")";
+        return ColorFromStr(str);
+    }
+    Color.RandomColor = RandomColor;
+    function ColorFromStr(str) {
+        var r, g, b, a;
+        var rgba = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([^\)]+)\s*)?\)$/.exec(str);
+        if (rgba) {
+            r = parseInt(rgba[1]);
+            g = parseInt(rgba[2]);
+            b = parseInt(rgba[3]);
+            a = rgba[4] != null ? parseFloat(rgba[4]) : 1;
+            return {
+                red: r,
+                green: g,
+                blue: b,
+                alpha: a
+            };
+        }
+        if (str.charAt(0) == "#") {
+            str = str.substring(1);
+        }
+        if (str.length == 6) {
+            // rgb.
+            var parsed = /^(.{2})(.{2})(.{2})/.exec(str);
+            if (!parsed) {
+                return null;
+            }
+            r = parseInt(parsed[1], 16);
+            g = parseInt(parsed[2], 16);
+            b = parseInt(parsed[3], 16);
+            a = 1;
+        }
+        else if (str.length == 8) {
+            // rgba.
+            var parsed = /^(.{2})(.{2})(.{2})(.{2})/.exec(str);
+            if (!parsed) {
+                return null;
+            }
+            r = parseInt(parsed[1], 16);
+            g = parseInt(parsed[2], 16);
+            b = parseInt(parsed[3], 16);
+            a = parseInt(parsed[4], 16);
+            if (a != 0) {
+                a = a / 255;
+            }
+        }
+        else {
+            return null;
+        }
+        if (a == null) {
+            a = 1;
+        }
+        return {
+            red: r,
+            blue: b,
+            green: g,
+            alpha: a
+        };
+    }
+    Color.ColorFromStr = ColorFromStr;
+})(Color || (Color = {}));
+
+var ObjectUtils;
+(function (ObjectUtils) {
+    function UId() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            var r = Math.random() * 16 | 0, v = c == "x" ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    ObjectUtils.UId = UId;
+})(ObjectUtils || (ObjectUtils = {}));
+
+var Entity;
+(function (Entity) {
+    function GetCacheKey(entityId) {
+        return "" + Api.ECacheKey.Entity + Api.ECacheKey.Id + entityId;
+    }
+    Entity.GetCacheKey = GetCacheKey;
+    function Get(api, entityId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!entityId) {
+                    throw ("Entity ID is required.");
+                }
+                key = GetCacheKey(entityId);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("entity/" + entityId, Api.PrepReqParams());
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    Entity.Get = Get;
+    function GetListByIds(api, entityIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reqs, reqIds, i, entityId, key, cacheData, reqData, req, _loop_1, i;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!entityIds.length) {
+                            throw ("Entity IDs are required.");
+                        }
+                        reqs = [];
+                        reqIds = [];
+                        for (i = 0; i < entityIds.length; i++) {
+                            entityId = entityIds[i];
+                            key = GetCacheKey(entityId);
+                            cacheData = api.Cache.Get(key);
+                            if (cacheData) {
+                                reqs.push(cacheData);
+                            }
+                            else {
+                                reqIds.push(entityId);
+                            }
+                        }
+                        reqData = {
+                            Filter: {
+                                ID: {
+                                    in: reqIds
+                                }
+                            },
+                            PageSize: reqIds.length
+                        };
+                        req = api.POST("entities", reqData, Api.PrepReqParams());
+                        _loop_1 = function (i) {
+                            var entityId = reqIds[i];
+                            var key = GetCacheKey(entityId);
+                            var prom = new Promise(function (res) { return __awaiter(_this, void 0, void 0, function () {
+                                var data, item, e_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, req];
+                                        case 1:
+                                            data = _a.sent();
+                                            item = data.Items.find(function (x) { return x.Bruce.ID == entityId; });
+                                            res(item);
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_1 = _a.sent();
+                                            return [3 /*break*/, 3];
+                                        case 3:
+                                            res(null);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                            api.Cache.Set(key, prom, Api.DEFAULT_CACHE_DURATION);
+                            reqs.push(prom);
+                        };
+                        for (i = 0; i < reqIds.length; i++) {
+                            _loop_1(i);
+                        }
+                        return [4 /*yield*/, Promise.all(reqs)];
+                    case 1: return [2 /*return*/, (_a.sent()).filter(function (x) { return !!x; })];
+                }
+            });
+        });
+    }
+    Entity.GetListByIds = GetListByIds;
+    function Delete(api, entityId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!entityId) {
+                            throw ("Entity ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("entity/" + entityId, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(entityId));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    Entity.Delete = Delete;
+    function Update(api, data, override) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var reqUrl;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!((_a = data === null || data === void 0 ? void 0 : data.Bruce) === null || _a === void 0 ? void 0 : _a["EntityType.ID"])) {
+                            throw ("Entity Type ID is required.");
+                        }
+                        if (!((_b = data === null || data === void 0 ? void 0 : data.Bruce) === null || _b === void 0 ? void 0 : _b.ID)) {
+                            data.Bruce = __assign(__assign({}, data.Bruce), { ID: ObjectUtils.UId() });
+                        }
+                        reqUrl = "entity/" + data.Bruce.ID + "/?dataoverride=" + override + "&BruceEntityType=" + data.Bruce["EntityType.ID"];
+                        return [4 /*yield*/, api.POST(reqUrl, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _c.sent();
+                        api.Cache.Remove(GetCacheKey(data.Bruce.ID));
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    Entity.Update = Update;
+    function RemoveTag(data, tagId) {
+        var _a;
+        var tags = (_a = data.Bruce["Layer.ID"]) !== null && _a !== void 0 ? _a : [];
+        var index = tags.indexOf(tagId);
+        if (index >= 0) {
+            tags.splice(index, 1);
+            data.Bruce["Layer.ID"] = tags;
+        }
+    }
+    Entity.RemoveTag = RemoveTag;
+    function AddTag(data, tagId) {
+        var _a;
+        var tags = (_a = data.Bruce["Layer.ID"]) !== null && _a !== void 0 ? _a : [];
+        if (!tags.includes(tagId)) {
+            tags.push(tagId);
+            data.Bruce["Layer.ID"] = tags;
+        }
+    }
+    Entity.AddTag = AddTag;
+    function SetValue(data, path, value) {
+        var curData = data;
+        for (var i = 0; i < path.length; i++) {
+            var step = path[i];
+            if (!curData[step] || typeof curData[step] != "object") {
+                curData[step] = {};
+            }
+            if (i >= path.length - 1) {
+                curData[step] = value;
+                break;
+            }
+            curData = curData[step];
+        }
+    }
+    Entity.SetValue = SetValue;
+    function GetValue(data, path) {
+        var curData = data;
+        for (var i = 0; i < path.length; i++) {
+            var step = path[i];
+            if (!curData[step]) {
+                return null;
+            }
+            if (i >= path.length - 1) {
+                return curData[step];
+            }
+            curData = curData[step];
+        }
+        return null;
+    }
+    Entity.GetValue = GetValue;
+    var Filter;
+    (function (Filter) {
+        var V1;
+        (function (V1) {
+            function GetList(api, filter) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var requestFilter, url, data, entities, i, entity, id;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!(filter === null || filter === void 0 ? void 0 : filter.entityTypeId)) {
+                                    throw ("Entity Type ID is required.");
+                                }
+                                requestFilter = {};
+                                if (filter.entityTypeConditions) {
+                                    requestFilter = __assign({}, filter.entityTypeConditions);
+                                }
+                                if (filter.layerIds != null && filter.layerIds.length > 0) {
+                                    requestFilter["Bruce.Layer.ID"] = {
+                                        equals: filter.layerIds
+                                    };
+                                }
+                                if (filter.bounds) {
+                                    requestFilter["geometry"] = {
+                                        "intersects": [
+                                            filter.bounds.south,
+                                            filter.bounds.north,
+                                            filter.bounds.west,
+                                            filter.bounds.east
+                                        ]
+                                    };
+                                }
+                                url = "entities" +
+                                    (
+                                    // Page size and index.
+                                    "?PageSize=" + filter.pageSize + "&PageIndex=" + filter.pageIndex) +
+                                    // Entity type id.
+                                    (filter.entityTypeId ? "&BruceEntityType=" + filter.entityTypeId : "") +
+                                    // Lod.
+                                    (filter.lodCategoryId ? "&LODType=" + filter.lodCategoryId : "") +
+                                    // Attribute filter.
+                                    (!requestFilter ? "" : "&Filter=" + Api.Encode(JSON.stringify(requestFilter))) +
+                                    // Order by attribute + sort order.
+                                    (!filter.orderBy ? "" : "&OrderBy=" + Api.Encode(JSON.stringify(filter.orderBy))) +
+                                    (filter.sortOrder ? "&SortOrder=" + (filter.sortOrder == Api.ESortOrder.Asc ? "ASC" : "DESC") : "");
+                                return [4 /*yield*/, api.GET(url, Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                entities = data.Items;
+                                for (i = 0; i < entities.length; i++) {
+                                    entity = entities[i];
+                                    id = entity.Bruce.ID;
+                                    api.Cache.Set(GetCacheKey(id), entity, Api.DEFAULT_CACHE_DURATION);
+                                }
+                                return [2 /*return*/, entities];
+                        }
+                    });
+                });
+            }
+            V1.GetList = GetList;
+        })(V1 = Filter.V1 || (Filter.V1 = {}));
+        // TODO: Helpers for constructing the filter.
+    })(Filter = Entity.Filter || (Entity.Filter = {}));
+})(Entity || (Entity = {}));
+
+var PathUtils;
+(function (PathUtils) {
+    function Parse(str) {
+        if (!str) {
+            return [];
+        }
+        var broken = str.split("\"/\"");
+        if (broken.length > 0) {
+            var top_1 = broken[0];
+            if (top_1.length > 0) {
+                if (top_1.charAt(0) == "\"") {
+                    top_1 = top_1.substring(1);
+                }
+                broken[0] = top_1;
+            }
+            var endIndex = broken.length - 1;
+            var bot = broken[endIndex];
+            if (bot.length > 0) {
+                if (bot.charAt(bot.length - 1) == "\"") {
+                    bot = bot.substring(0, bot.length - 1);
+                }
+                broken[endIndex] = bot;
+            }
+        }
+        return broken;
+    }
+    PathUtils.Parse = Parse;
+    function Wrap(path) {
+        var tmp = "\"";
+        for (var i = 0; i < path.length; i++) {
+            var section = path[i];
+            tmp += section;
+            if (i < path.length - 1) {
+                tmp += "\"/\"";
+            }
+        }
+        tmp += "\"";
+        return tmp;
+    }
+    PathUtils.Wrap = Wrap;
+    function ParseLegacy(str) {
+        var broken = str.split(".");
+        for (var i = 0; i < broken.length; i++) {
+            var piece = broken[0];
+            if (piece.charAt(0) == "\"") {
+                piece = broken[0] = piece.substring(1);
+            }
+            if (piece.charAt(piece.length - 1) == "\"") {
+                broken[0] = piece.substring(0, piece.length - 1);
+            }
+        }
+        return broken;
+    }
+    PathUtils.ParseLegacy = ParseLegacy;
+})(PathUtils || (PathUtils = {}));
+
+function getVariable(str) {
+    var start = str.indexOf("${");
+    if (start > -1) {
+        var end = str.indexOf("}");
+        if (end > -1) {
+            if (start < end) {
+                return { path: str.substring(start + 2, end), text: str.substring(start, end) };
+            }
+        }
+    }
+    return null;
+}
+var BruceVariable;
+(function (BruceVariable) {
+    function SwapValues(str, data, legacyParse) {
+        if (!legacyParse) {
+            legacyParse = false;
+        }
+        while (true) {
+            var variable = getVariable(str);
+            if (variable) {
+                var path = legacyParse ? PathUtils.ParseLegacy(variable.path) : PathUtils.Parse(variable.path);
+                var value = "";
+                if (path.length > 0) {
+                    value = Entity.GetValue(data, path);
+                }
+                str = str.replace(variable.text, value);
+            }
+            else {
+                break;
+            }
+        }
+        return str;
+    }
+    BruceVariable.SwapValues = SwapValues;
+})(BruceVariable || (BruceVariable = {}));
+
+var Calculator;
+(function (Calculator) {
+    var EValueType;
+    (function (EValueType) {
+        EValueType[EValueType["Color"] = 0] = "Color";
+        EValueType[EValueType["Input"] = 1] = "Input";
+        EValueType[EValueType["Gradient"] = 2] = "Gradient";
+        EValueType[EValueType["Mapping"] = 3] = "Mapping";
+        EValueType[EValueType["TagColor"] = 4] = "TagColor";
+        EValueType[EValueType["RandomColor"] = 5] = "RandomColor";
+    })(EValueType = Calculator.EValueType || (Calculator.EValueType = {}));
+    function GetValue(fields, entity, tags) {
+        if (!tags) {
+            tags = [];
+        }
+        if (!entity) {
+            entity = {};
+        }
+        for (var i = 0; i < fields.length; i++) {
+            var field = fields[i];
+            var value = void 0;
+            switch (field.type) {
+                case EValueType.Color:
+                    value = field.value;
+                    break;
+                case EValueType.Gradient:
+                    value = GetGradientValue(field.value, entity);
+                    break;
+                case EValueType.Input:
+                    value = GetInputValue(field.value, entity);
+                    break;
+                case EValueType.Mapping:
+                    value = GetMappingValue(field.value, entity);
+                    break;
+                case EValueType.RandomColor:
+                    value = Color.RandomColor();
+                    break;
+                case EValueType.TagColor:
+                    for (var i_1 = 0; i_1 < tags.length; i_1++) {
+                        var tag = tags[i_1];
+                        if (tag.Color) {
+                            value = Color.ColorFromStr(tag.Color);
+                            break;
+                        }
+                    }
+                    break;
+            }
+            if (!value || value == 0) {
+                return value;
+            }
+        }
+        return null;
+    }
+    Calculator.GetValue = GetValue;
+    function GetMappingValue(value, entity) {
+        var attrPath = PathUtils.Parse(value.field);
+        var eValue = +Entity.GetValue(entity, attrPath);
+        for (var i = 0; i < value.values.length; i++) {
+            var option = value.values[i];
+            var mapValue = option.fieldValue;
+            if (+mapValue == eValue) {
+                return option.appliedValue;
+            }
+            var mapSplit = mapValue.split("-");
+            if (mapSplit.length == 2) {
+                var min = mapSplit[0];
+                var max = mapSplit[1];
+                if (min != "") {
+                    if (eValue < +min) {
+                        continue;
+                    }
+                }
+                if (max != "") {
+                    if (eValue > +max) {
+                        continue;
+                    }
+                }
+                if (min == "" && max == "") {
+                    continue;
+                }
+                return option.appliedValue;
+            }
+        }
+        return null;
+    }
+    Calculator.GetMappingValue = GetMappingValue;
+    function GetGradientValue(value, entity) {
+        var attrPath = PathUtils.Parse(value.field);
+        var eValue = Entity.GetValue(entity, attrPath);
+        eValue = Math.min(Math.max(eValue, value.min), value.max);
+        if (eValue < value.points[0].position) {
+            return Color.ColorFromStr(value.points[0].color);
+        }
+        for (var i = 0; i < value.points.length - 1; i++) {
+            var pointA = value.points[i];
+            var pointB = value.points[i + 1];
+            if (eValue >= pointA.position && eValue <= pointB.position) {
+                if (pointA.position == pointB.position) {
+                    return Color.ColorFromStr(pointA.color);
+                }
+                var distance = (eValue - pointA.position) / (pointB.position - pointA.position);
+                var colorA = Color.ColorFromStr(pointA.color);
+                var colorB = Color.ColorFromStr(pointB.color);
+                return {
+                    red: colorA.red + (colorB.red - colorA.red) * distance,
+                    green: colorA.green + (colorB.green - colorA.green) * distance,
+                    blue: colorA.blue + (colorB.blue - colorA.blue) * distance,
+                    alpha: colorA.alpha + (colorB.alpha - colorA.alpha) * distance
+                };
+            }
+        }
+        return Color.ColorFromStr(value.points[value.points.length - 1].color);
+    }
+    Calculator.GetGradientValue = GetGradientValue;
+    function GetInputValue(value, entity) {
+        if (typeof value == "string") {
+            try {
+                value = BruceVariable.SwapValues(value, entity);
+                return eval(value);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        return value;
+    }
+    Calculator.GetInputValue = GetInputValue;
+})(Calculator || (Calculator = {}));
+
+var BruceEvent = /** @class */ (function () {
+    function BruceEvent() {
+        // Counter to help differentiate subscriptions.
+        this._counter = 0;
+        // Record of all callback subscriptions for this event.
+        this.callbacks = [];
+    }
+    BruceEvent.prototype.Subscribe = function (callback) {
+        var _this = this;
+        var id = this._counter++;
+        var newBruceEventCallback = {
+            _id: id,
+            removeCallback: function () {
+                _this.Unsubscribe(id);
+            },
+            callback: callback
+        };
+        this.callbacks.push(newBruceEventCallback);
+        return newBruceEventCallback.removeCallback;
+    };
+    BruceEvent.prototype.Unsubscribe = function (id) {
+        var index = this.callbacks.findIndex(function (x) { return x._id == id; });
+        if (index > -1) {
+            this.callbacks.splice(index, 1);
+        }
+    };
+    BruceEvent.prototype.Trigger = function (data) {
+        var callbacks = this.callbacks;
+        for (var i = 0; i < callbacks.length; i++) {
+            var callback = callbacks[i];
+            if (callback.callback) {
+                callback.callback(data);
+            }
+        }
+    };
+    BruceEvent.prototype.Clear = function () {
+        this.callbacks = [];
+    };
+    return BruceEvent;
+}());
+
+var Camera;
+(function (Camera) {
+    var EFrustum;
+    (function (EFrustum) {
+        EFrustum[EFrustum["Perspective"] = 0] = "Perspective";
+        EFrustum[EFrustum["Orthographic"] = 1] = "Orthographic";
+    })(EFrustum = Camera.EFrustum || (Camera.EFrustum = {}));
+})(Camera || (Camera = {}));
+
+var Cartes;
+(function (Cartes) {
+    function ValidateCartes2(cartes) {
+        if (!cartes) {
+            return false;
+        }
+        else if (!cartes.x && cartes.x != 0) {
+            return false;
+        }
+        else if (!cartes.y && cartes.y != 0) {
+            return false;
+        }
+        return true;
+    }
+    Cartes.ValidateCartes2 = ValidateCartes2;
+    function ValidateCartes3(cartes) {
+        if (!ValidateCartes2(cartes)) {
+            return false;
+        }
+        else if (!cartes.z && cartes.z != 0) {
+            return false;
+        }
+        return true;
+    }
+    Cartes.ValidateCartes3 = ValidateCartes3;
+    function IsEqualCartes2(a, b) {
+        if (a.x != b.x) {
+            return false;
+        }
+        else if (a.y != b.y) {
+            return false;
+        }
+        return true;
+    }
+    Cartes.IsEqualCartes2 = IsEqualCartes2;
+    function IsEqualCartes3(a, b) {
+        if (!IsEqualCartes2(a, b)) {
+            return false;
+        }
+        else if (a.z != b.z) {
+            return false;
+        }
+        return true;
+    }
+    Cartes.IsEqualCartes3 = IsEqualCartes3;
+})(Cartes || (Cartes = {}));
+
+var Carto;
+(function (Carto) {
+    function ValidateCarto(carto) {
+        if (!carto) {
+            return false;
+        }
+        else if (!carto.longitude && carto.longitude != 0) {
+            return false;
+        }
+        else if (!carto.latitude && carto.latitude != 0) {
+            return false;
+        }
+        return true;
+    }
+    Carto.ValidateCarto = ValidateCarto;
+    function IsEqual(a, b) {
+        if (a.longitude != b.longitude) {
+            return false;
+        }
+        else if (a.latitude != b.latitude) {
+            return false;
+        }
+        return true;
+    }
+    Carto.IsEqual = IsEqual;
+})(Carto || (Carto = {}));
+
+var DelayQueue = /** @class */ (function () {
+    function DelayQueue(callback, delay) {
+        if (delay === void 0) { delay = 200; }
+        // Millisecond delay.
+        this.delay = 200;
+        // Date-time stamp for the last callback call.
+        this.lastCallTime = null;
+        this.callback = callback;
+        this.delay = delay;
+    }
+    DelayQueue.prototype.Call = function (force) {
+        var _this = this;
+        if (force === void 0) { force = false; }
+        if (this.lastCallTime == null) {
+            force = true;
+        }
+        if (force) {
+            var endDate = new Date().getTime();
+            this.doCall(endDate);
+        }
+        else {
+            var endDate = new Date().getTime();
+            var seconds = (endDate - this.lastCallTime) / 1000;
+            var delay = this.delay / 1000;
+            if (seconds > delay) {
+                this.doCall(endDate);
+            }
+            else if (this.delayTimeout == null) {
+                var diff = (delay - seconds) * 1000;
+                this.delayTimeout = setTimeout(function () {
+                    _this.delayTimeout = null;
+                    _this.Call();
+                }, diff + 0.02);
+            }
+        }
+    };
+    DelayQueue.prototype.doCall = function (endDate) {
+        if (this.delayTimeout != null) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
+        }
+        this.lastCallTime = endDate;
+        this.callback();
+    };
+    DelayQueue.prototype.Dispose = function () {
+        if (this.delayTimeout != null) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
+        }
+    };
+    return DelayQueue;
+}());
+
+var Geometry;
+(function (Geometry) {
+    function LineStrFromPoints(points) {
+        if (!points.length) {
+            throw ("points is empty.");
+        }
+        var carto = points[0];
+        var lineString = carto.longitude + "," + carto.latitude + (carto.altitude != null ? "," + carto.altitude : "");
+        for (var i = 1; i < points.length; i++) {
+            carto = points[i];
+            lineString += " " + carto.longitude + "," + carto.latitude + (carto.altitude != null ? "," + carto.altitude : "");
+        }
+        return lineString;
+    }
+    Geometry.LineStrFromPoints = LineStrFromPoints;
+    function RemoveRepeatPoints(positions) {
+        var filteredList = [];
+        for (var i = 0; i < positions.length; i++) {
+            var pos = positions[i];
+            var lastPos = filteredList.length > 0 ? filteredList[filteredList.length - 1] : null;
+            if (!lastPos || (pos.latitude != lastPos.latitude || pos.longitude != lastPos.longitude || pos.altitude != lastPos.altitude)) {
+                filteredList.push(pos);
+            }
+        }
+        return filteredList;
+    }
+    Geometry.RemoveRepeatPoints = RemoveRepeatPoints;
+    function ParsePoints(data) {
+        data = data.replace(/[^\d.,-\s]/g, "");
+        var splitterCoordinates = " ";
+        var splitterAxis = ",";
+        var commaIndex = data.indexOf(",");
+        var spaceIndex = data.indexOf(" ");
+        if ((spaceIndex > -1 && commaIndex > spaceIndex) || commaIndex <= -1) {
+            splitterCoordinates = ",";
+            splitterAxis = " ";
+        }
+        var points = data.trim().split(splitterCoordinates);
+        points = points.filter(function (a) { return a != ""; });
+        var result = [];
+        for (var i = 0; i < points.length; i++) {
+            var pointData = points[i];
+            var coords = pointData.trim().split(splitterAxis);
+            if (coords.length == 2 || coords.length == 3) {
+                var longitude = +coords[0];
+                var latitude = +coords[1];
+                var altitude = coords.length >= 3 ? +coords[2] : 0;
+                if (longitude != null && latitude != null) {
+                    result.push({
+                        altitude: altitude,
+                        latitude: latitude,
+                        longitude: longitude
+                    });
+                }
+                else {
+                    console.warn("Invalid point data detected.", pointData);
+                }
+            }
+        }
+        return result;
+    }
+    Geometry.ParsePoints = ParsePoints;
+    function ParseGeometry(geometry) {
+        if (typeof geometry == "string") {
+            var positions = [];
+            var geometryParsed = (geometry || "").split(";");
+            for (var i = 0; i < geometryParsed.length; i++) {
+                var data = geometryParsed[i];
+                var points = ParsePoints(data);
+                if (points && points.length > 0) {
+                    positions = positions.concat(points);
+                }
+            }
+            positions = RemoveRepeatPoints(positions);
+            var newGeometry = {};
+            if (positions.length > 0) {
+                var topPoint = positions[0];
+                newGeometry.Point = topPoint.latitude + "," + topPoint.longitude + (topPoint.altitude != null ? "," + topPoint.altitude : "");
+                if (positions.length > 1) {
+                    newGeometry.Polygon = [{ Facing: "out", LinearRing: LineStrFromPoints(positions) }];
+                }
+                if (positions.length > 2) {
+                    newGeometry.LineString = LineStrFromPoints(positions);
+                }
+            }
+            return newGeometry;
+        }
+        return geometry;
+    }
+    Geometry.ParseGeometry = ParseGeometry;
+})(Geometry || (Geometry = {}));
+
+var UTC;
+(function (UTC) {
+    var EMonth;
+    (function (EMonth) {
+        EMonth[EMonth["January"] = 1] = "January";
+        EMonth[EMonth["February"] = 2] = "February";
+        EMonth[EMonth["March"] = 3] = "March";
+        EMonth[EMonth["April"] = 4] = "April";
+        EMonth[EMonth["May"] = 5] = "May";
+        EMonth[EMonth["June"] = 6] = "June";
+        EMonth[EMonth["July"] = 7] = "July";
+        EMonth[EMonth["August"] = 8] = "August";
+        EMonth[EMonth["September"] = 9] = "September";
+        EMonth[EMonth["October"] = 10] = "October";
+        EMonth[EMonth["November"] = 11] = "November";
+        EMonth[EMonth["December"] = 12] = "December";
+    })(EMonth = UTC.EMonth || (UTC.EMonth = {}));
+    function ToDate(utc) {
+        return new Date(utc.y, utc.m - 1, utc.d, utc.hh, utc.mm, utc.ss, 0);
+    }
+    UTC.ToDate = ToDate;
+    function FromDate(date) {
+        return {
+            y: date.getUTCFullYear(),
+            m: date.getUTCMonth() + 1,
+            d: date.getUTCDate(),
+            hh: date.getUTCHours(),
+            mm: date.getUTCMinutes(),
+            ss: date.getUTCSeconds()
+        };
+    }
+    UTC.FromDate = FromDate;
+})(UTC || (UTC = {}));
+
+var EntityAttachmentType;
+(function (EntityAttachmentType) {
+    function GetCacheKey(id) {
+        return Api.ECacheKey.AttachmentType + Api.ECacheKey.Id + id;
+    }
+    EntityAttachmentType.GetCacheKey = GetCacheKey;
+    function GetListCacheKey() {
+        return Api.ECacheKey.AttachmentType;
+    }
+    EntityAttachmentType.GetListCacheKey = GetListCacheKey;
+    var EType;
+    (function (EType) {
+        EType["Photo"] = "photo";
+        EType["Document"] = "document";
+        EType["Video"] = "video";
+        EType["Drawing"] = "drawing";
+        EType["Model"] = "model";
+    })(EType = EntityAttachmentType.EType || (EntityAttachmentType.EType = {}));
+    function Delete(api, id) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!id) {
+                            throw ("Type ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("entityAttachmentType/" + id, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(id));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    EntityAttachmentType.Delete = Delete;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.ID)) {
+                            throw ("Type ID is required.");
+                        }
+                        return [4 /*yield*/, api.post("entityAttachmentType/" + data.ID, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data.ID));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    EntityAttachmentType.Update = Update;
+    function GetList(api) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                cacheData = api.Cache.Get(GetListCacheKey());
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("entityAttachmentTypes", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(), req);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityAttachmentType.GetList = GetList;
+})(EntityAttachmentType || (EntityAttachmentType = {}));
+
+var EntityAttachment;
+(function (EntityAttachment) {
+    function GetCacheKey(entityId, typeId, fileId) {
+        return Api.ECacheKey.Attachment + Api.ECacheKey.Id + entityId + Api.ECacheKey.Id + typeId + Api.ECacheKey.Id + fileId;
+    }
+    EntityAttachment.GetCacheKey = GetCacheKey;
+    function GetListCacheKey(entityId) {
+        return Api.ECacheKey.Attachment + Api.ECacheKey.Entity + Api.ECacheKey.Id + entityId;
+    }
+    EntityAttachment.GetListCacheKey = GetListCacheKey;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data["Entity.ID"]) || !(data === null || data === void 0 ? void 0 : data["EntityAttachmentType.ID"]) || !(data === null || data === void 0 ? void 0 : data["ClientFile.ID"])) {
+                            throw ("Entity ID, Type ID, and File ID are required.");
+                        }
+                        url = "entity/" + data["Entity.ID"] + "/attachment/" + data["EntityAttachmentType.ID"] + "/" + data["ClientFile.ID"];
+                        return [4 /*yield*/, api.POST(url, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data["Entity.ID"], data["EntityAttachmentType.ID"], data["ClientFile.ID"]));
+                        api.Cache.RemoveByStartsWith(GetListCacheKey(data["Entity.ID"]));
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    EntityAttachment.Update = Update;
+    function UpdateOrder(api, entityId, typeId, fileIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reqData, i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!entityId || !typeId || !(fileIds === null || fileIds === void 0 ? void 0 : fileIds.length)) {
+                            throw ("Entity ID, Type ID, and File IDs are required.");
+                        }
+                        reqData = {
+                            "DisplayOrder.Start": 0,
+                            "ClientFile.ID": fileIds
+                        };
+                        return [4 /*yield*/, api.POST("entity/" + entityId + "/attachments/" + typeId + "/setOrder", reqData, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        for (i = 0; i < fileIds.length; i++) {
+                            api.Cache.Remove(GetCacheKey(entityId, typeId, fileIds[i]));
+                        }
+                        api.Cache.RemoveByStartsWith(GetListCacheKey(entityId));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    EntityAttachment.UpdateOrder = UpdateOrder;
+    function Delete(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reqData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data["Entity.ID"]) || !(data === null || data === void 0 ? void 0 : data["EntityAttachmentType.ID"]) || !(data === null || data === void 0 ? void 0 : data["ClientFile.ID"])) {
+                            throw ("Entity ID, Type ID, and File ID are required.");
+                        }
+                        reqData = {
+                            "ClientFile.ID": [data["ClientFile.ID"]]
+                        };
+                        return [4 /*yield*/, api.POST("entity/" + data["Entity.ID"] + "/attachments/" + data["EntityAttachmentType.ID"] + "/delete", reqData, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(data["Entity.ID"], data["EntityAttachmentType.ID"], data["ClientFile.ID"]));
+                        api.Cache.RemoveByStartsWith(GetListCacheKey(data["Entity.ID"]));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    EntityAttachment.Delete = Delete;
+    function DeleteByFileIds(api, entityId, typeId, fileIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reqData, i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!entityId || !typeId || !(fileIds === null || fileIds === void 0 ? void 0 : fileIds.length)) {
+                            throw ("Entity ID, Type ID, and File IDs are required.");
+                        }
+                        reqData = {
+                            "ClientFile.ID": fileIds
+                        };
+                        return [4 /*yield*/, api.POST("entity/" + entityId + "/attachments/" + typeId + "/delete", reqData, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        for (i = 0; i < fileIds.length; i++) {
+                            api.Cache.Remove(GetCacheKey(entityId, typeId, fileIds[i]));
+                        }
+                        api.Cache.RemoveByStartsWith(GetListCacheKey(entityId));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    EntityAttachment.DeleteByFileIds = DeleteByFileIds;
+    function GetListByEntityId(api, entityId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!entityId) {
+                    throw ("Entity ID is required.");
+                }
+                cacheData = api.Cache.Get(GetListCacheKey(entityId));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("entity/" + entityId + "/attachments", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(entityId), req);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityAttachment.GetListByEntityId = GetListByEntityId;
+    function Upload(api, file, entityId, typeId, onProgress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, req;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!entityId || !typeId || !file) {
+                            throw ("Entity ID, Type ID, and File are required.");
+                        }
+                        url = "entity/" + entityId + "/attachment/" + typeId;
+                        return [4 /*yield*/, api.UPLOAD(url, file, { onProgress: onProgress })];
+                    case 1:
+                        req = _a.sent();
+                        api.Cache.RemoveByStartsWith(GetListCacheKey(entityId));
+                        return [2 /*return*/, req];
+                }
+            });
+        });
+    }
+    EntityAttachment.Upload = Upload;
+})(EntityAttachment || (EntityAttachment = {}));
+
+var EntityComment;
+(function (EntityComment) {
+    function GetCacheKey(id) {
+        return Api.ECacheKey.Comment + Api.ECacheKey.Id + id;
+    }
+    EntityComment.GetCacheKey = GetCacheKey;
+    function GetListCacheKey(entityId) {
+        return Api.ECacheKey.Comment + Api.ECacheKey.Entity + Api.ECacheKey.Id + entityId;
+    }
+    EntityComment.GetListCacheKey = GetListCacheKey;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data["TargetObject.ID"])) {
+                            throw ("TargetObject.ID (entity id) is required.");
+                        }
+                        url = "entity/" + data["TargetObject.ID"] + "/comment" + (data.ID == null ? "" : "/" + data.ID);
+                        return [4 /*yield*/, api.POST(url, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data.ID));
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Comment + Api.ECacheKey.Entity);
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    EntityComment.Update = Update;
+    function Delete(api, entityId, commentId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!commentId) {
+                            throw ("Comment ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("entity/" + entityId + "/comment/" + commentId, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(commentId));
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Comment + Api.ECacheKey.Entity);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    EntityComment.Delete = Delete;
+    function GetListByEntityId(api, entityId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!entityId) {
+                    throw ("Entity ID is required.");
+                }
+                cacheData = api.Cache.Get(GetListCacheKey(entityId));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("entity/" + entityId + "/comments", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(entityId), req);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityComment.GetListByEntityId = GetListByEntityId;
+})(EntityComment || (EntityComment = {}));
+
+var EntityLink;
+(function (EntityLink) {
+    function GetCacheKey(id) {
+        return Api.ECacheKey.Link + Api.ECacheKey.Id + id;
+    }
+    EntityLink.GetCacheKey = GetCacheKey;
+    function GetListCacheKey(entityId) {
+        return Api.ECacheKey.Link + Api.ECacheKey.Entity + Api.ECacheKey.Id + entityId;
+    }
+    EntityLink.GetListCacheKey = GetListCacheKey;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data["Entity.ID"])) {
+                            throw ("Entity ID is required.");
+                        }
+                        url = "entity/" + data["Entity.ID"] + "/link" + (data.ID == null ? "" : "/" + data.ID);
+                        return [4 /*yield*/, api.POST(url, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data.ID));
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Link + Api.ECacheKey.Entity);
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    EntityLink.Update = Update;
+    function Delete(api, entityId, linkId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!linkId) {
+                            throw ("Link ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("entity/" + entityId + "/link/" + linkId, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(linkId));
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Link + Api.ECacheKey.Entity);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    EntityLink.Delete = Delete;
+    function GetListByEntityId(api, entityId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!entityId) {
+                    throw ("Entity ID is required.");
+                }
+                cacheData = api.Cache.Get(GetListCacheKey(entityId));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("entity/" + entityId + "/links", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(entityId), req);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityLink.GetListByEntityId = GetListByEntityId;
+})(EntityLink || (EntityLink = {}));
+
+var EntityLod;
+(function (EntityLod) {
+    function GetCacheKey(url) {
+        return Api.ECacheKey.Lod + Api.ECacheKey.Id + url;
+    }
+    EntityLod.GetCacheKey = GetCacheKey;
+    function GetUrl(api, entityId, categoryId, level, strict) {
+        if (!entityId) {
+            throw ("Entity ID is required.");
+        }
+        if (!categoryId) {
+            categoryId = "GLB";
+        }
+        if (!level) {
+            level = 0;
+        }
+        var url = api.GetBaseUrl() + ("entity/" + entityId + "/lod/" + categoryId + "/" + level);
+        if (strict) {
+            url = url + "?strict=true";
+        }
+        return url;
+    }
+    EntityLod.GetUrl = GetUrl;
+    function GetUrlFileId(api, url) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!url) {
+                    throw ("Url is required.");
+                }
+                cacheData = api.Cache.Get(GetCacheKey(url));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var record, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.get(url, Api.PrepReqParams())];
+                            case 1:
+                                record = _a.sent();
+                                res(record["ClientFile.ID"]);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetCacheKey(url), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityLod.GetUrlFileId = GetUrlFileId;
+    function GetLods(api, params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!((_a = params === null || params === void 0 ? void 0 : params.Items) === null || _a === void 0 ? void 0 : _a.length)) {
+                            throw ("Items are required.");
+                        }
+                        return [4 /*yield*/, api.POST("entity/getlods", params)];
+                    case 1:
+                        data = _b.sent();
+                        return [2 /*return*/, data.Items];
+                }
+            });
+        });
+    }
+    EntityLod.GetLods = GetLods;
+})(EntityLod || (EntityLod = {}));
+
+var EntityRelationType;
+(function (EntityRelationType) {
+    function GetCacheKey(id) {
+        return Api.ECacheKey.RelationType + Api.ECacheKey.Id + id;
+    }
+    EntityRelationType.GetCacheKey = GetCacheKey;
+    function GetListCacheKey() {
+        return Api.ECacheKey.RelationType;
+    }
+    EntityRelationType.GetListCacheKey = GetListCacheKey;
+    function Get(api, typeId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!typeId) {
+                    throw ("Type ID is required.");
+                }
+                key = GetCacheKey(typeId);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("entityRelationType/" + typeId, Api.PrepReqParams());
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityRelationType.Get = Get;
+    function Delete(api, typeId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!typeId) {
+                            throw ("Type ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("entityRelationType/" + typeId, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(typeId));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    EntityRelationType.Delete = Delete;
+    function GetList(api) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                cacheData = api.Cache.Get(GetListCacheKey());
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("entityRelationTypes", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(), req);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityRelationType.GetList = GetList;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.ForwardName) || !(data === null || data === void 0 ? void 0 : data.ReverseName)) {
+                            throw ("Forward and reverse names are required.");
+                        }
+                        if (!data.ID) {
+                            data.ID = ObjectUtils.UId();
+                        }
+                        return [4 /*yield*/, api.post("entityRelationType/" + data.ID, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data.ID));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    EntityRelationType.Update = Update;
+})(EntityRelationType || (EntityRelationType = {}));
+
+var EntityRelation;
+(function (EntityRelation) {
+    function GetCacheKey(entityA, entityB, typeId) {
+        return "" + Api.ECacheKey.Relation + Api.ECacheKey.Id + entityA + Api.ECacheKey.Id + entityB + Api.ECacheKey.Id + typeId;
+    }
+    EntityRelation.GetCacheKey = GetCacheKey;
+    function GetEntityCacheKey(entityId) {
+        return Api.ECacheKey.Relation + Api.ECacheKey.Entity + Api.ECacheKey.Id + entityId;
+    }
+    EntityRelation.GetEntityCacheKey = GetEntityCacheKey;
+    function GetListCacheKey(params) {
+        return Api.ECacheKey.Relation + Api.ECacheKey.RelationType + Api.ECacheKey.Id + params.typeId + Api.ECacheKey.Id + params.oneWayOnly + Api.ECacheKey.Id + params.loadEntityData;
+    }
+    EntityRelation.GetListCacheKey = GetListCacheKey;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!data["Principal.Entity.ID"] || !data["Related.Entity.ID"] || !data["Relation.Type.ID"]) {
+                            throw ("Principal Entity ID, Related Entity ID, and Relation Type ID are required.");
+                        }
+                        url = "entity/" + data["Principal.Entity.ID"] + "/otherEntityID/" + data["Related.Entity.ID"] + "/relation/" + data["Relation.Type.ID"] + "/update";
+                        return [4 /*yield*/, api.post(url, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Relation + Api.ECacheKey.Id + data["Principal.Entity.ID"]);
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Relation + Api.ECacheKey.Id + data["Related.Entity.ID"]);
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Relation + Api.ECacheKey.RelationType + Api.ECacheKey.Id + data["Relation.Type.ID"]);
+                        if (data["Data.Entity.ID"]) {
+                            api.Cache.RemoveByStartsWith(Api.ECacheKey.Relation + Api.ECacheKey.Entity + Api.ECacheKey.Id + data["Data.Entity.ID"]);
+                        }
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    EntityRelation.Update = Update;
+    function GetList(api, entityId, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!entityId) {
+                    throw ("Entity ID is required.");
+                }
+                params = __assign({ typeId: "", oneWayOnly: false, loadEntityData: false }, params);
+                cacheData = api.Cache.Get(GetListCacheKey(params));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var url, data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                url = "entity/" + entityId + "/relations";
+                                if (params.typeId) {
+                                    url += "/" + params.typeId;
+                                }
+                                url += "?Oneway=" + params.oneWayOnly + "&LoadInfo=" + params.loadEntityData;
+                                return [4 /*yield*/, api.GET(url, Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(params), req);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityRelation.GetList = GetList;
+    function GetByDataEntityId(api, entityId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            return __generator(this, function (_a) {
+                if (!entityId) {
+                    throw ("Entity ID is required.");
+                }
+                cacheData = api.Cache.Get(GetEntityCacheKey(entityId));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("entity/relation/" + entityId + "/dataentity", Api.PrepReqParams());
+                api.Cache.Set(GetEntityCacheKey(entityId), req);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityRelation.GetByDataEntityId = GetByDataEntityId;
+})(EntityRelation || (EntityRelation = {}));
+
+var EntitySource;
+(function (EntitySource) {
+    function GetCacheKey(sourceId, sourceKey) {
+        return "" + Api.ECacheKey.EntitySource + Api.ECacheKey.Id + sourceId + Api.ECacheKey.Id + sourceKey;
+    }
+    EntitySource.GetCacheKey = GetCacheKey;
+    function Get(api, sourceId, sourceKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!sourceId || !sourceKey) {
+                    throw ("Source ID and Source Key are required.");
+                }
+                key = GetCacheKey(sourceId, sourceKey);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("entitysource/" + sourceId + "/" + sourceKey, Api.PrepReqParams());
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntitySource.Get = Get;
+    function GetListByKeys(api, sourceId, sourceKeys) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reqKeys, reqs, i, sourceKey, cacheData, prom_1, _loop_1, i;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!sourceId || !sourceKeys.length) {
+                            throw ("Source ID and Source Keys are required.");
+                        }
+                        reqKeys = [];
+                        reqs = [];
+                        for (i = 0; i < sourceKeys.length; i++) {
+                            sourceKey = sourceKeys[i];
+                            cacheData = api.Cache.Get(GetCacheKey(sourceId, sourceKey));
+                            if (cacheData) {
+                                reqs.push(cacheData);
+                            }
+                            else {
+                                reqKeys.push(sourceKey);
+                            }
+                        }
+                        if (reqKeys.length) {
+                            prom_1 = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                                var data, e_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, api.POST("entitysource/" + sourceId, { SourceRecordKeys: reqKeys }, Api.PrepReqParams())];
+                                        case 1:
+                                            data = _a.sent();
+                                            res(data);
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_1 = _a.sent();
+                                            rej(e_1);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                            _loop_1 = function (i) {
+                                var req = new Promise(function (rej, res) { return __awaiter(_this, void 0, void 0, function () {
+                                    var sources, e_2;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                _a.trys.push([0, 2, , 3]);
+                                                return [4 /*yield*/, prom_1];
+                                            case 1:
+                                                sources = _a.sent();
+                                                res(sources.find(function (s) { return s["SourceRecord.Key"] === reqKeys[i]; }));
+                                                return [3 /*break*/, 3];
+                                            case 2:
+                                                e_2 = _a.sent();
+                                                rej(e_2);
+                                                return [3 /*break*/, 3];
+                                            case 3: return [2 /*return*/];
+                                        }
+                                    });
+                                }); });
+                                reqs.push(req);
+                            };
+                            for (i = 0; i < reqKeys.length; i++) {
+                                _loop_1(i);
+                            }
+                        }
+                        return [4 /*yield*/, Promise.all(reqs)];
+                    case 1: return [2 /*return*/, (_a.sent()).filter(function (x) { return !!x; })];
+                }
+            });
+        });
+    }
+    EntitySource.GetListByKeys = GetListByKeys;
+    function GetEntityIdsBySourceKeys(api, sourceId, sourceKeys) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, sources, i, source, i_1, key;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!sourceId || !sourceKeys.length) {
+                            throw ("Source ID and Source Keys are required.");
+                        }
+                        result = {};
+                        if (!(sourceKeys.length > 0)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, GetListByKeys(api, sourceId, sourceKeys)];
+                    case 1:
+                        sources = _a.sent();
+                        for (i = 0; i < sources.length; i++) {
+                            source = sources[i];
+                            for (i_1 = 0; i_1 < sourceKeys.length; i_1++) {
+                                key = sourceKeys[i_1];
+                                if (key == source["SourceRecord.Key"]) {
+                                    result[key] = source["Entity.ID"];
+                                }
+                            }
+                        }
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, result];
+                }
+            });
+        });
+    }
+    EntitySource.GetEntityIdsBySourceKeys = GetEntityIdsBySourceKeys;
+})(EntitySource || (EntitySource = {}));
+
+var EntityTag;
+(function (EntityTag) {
+    function GetCacheKey(tagId) {
+        return "" + Api.ECacheKey.Tag + Api.ECacheKey.Id + tagId;
+    }
+    EntityTag.GetCacheKey = GetCacheKey;
+    function GetListCacheKey(entityTypeId) {
+        if (entityTypeId) {
+            return Api.ECacheKey.Tag + Api.ECacheKey.EntityType + Api.ECacheKey.Id + entityTypeId;
+        }
+        return Api.ECacheKey.Tag;
+    }
+    EntityTag.GetListCacheKey = GetListCacheKey;
+    function Get(api, tagId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!tagId) {
+                            throw ("Tag ID is required.");
+                        }
+                        return [4 /*yield*/, GetListByIds(api, [tagId])];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, data.length ? data[0] : null];
+                }
+            });
+        });
+    }
+    EntityTag.Get = Get;
+    function GetListByIds(api, tagIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reqIds, reqs, i, tagId, cacheData, prom_1, _loop_1, i;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!tagIds.length) {
+                            throw ("Tag Ids are empty.");
+                        }
+                        reqIds = [];
+                        reqs = [];
+                        for (i = 0; i < tagIds.length; i++) {
+                            tagId = tagIds[i];
+                            cacheData = api.Cache.Get(GetCacheKey(tagId));
+                            if (cacheData) {
+                                reqs.push(cacheData);
+                            }
+                            else {
+                                reqIds.push(tagId);
+                            }
+                        }
+                        if (reqIds.length) {
+                            prom_1 = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                                var data, e_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, api.POST("layers/get", { layerIds: reqIds }, Api.PrepReqParams())];
+                                        case 1:
+                                            data = _a.sent();
+                                            res(data);
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_1 = _a.sent();
+                                            rej(e_1);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                            _loop_1 = function (i) {
+                                var req = new Promise(function (rej, res) { return __awaiter(_this, void 0, void 0, function () {
+                                    var tags, tag, e_2;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                _a.trys.push([0, 2, , 3]);
+                                                return [4 /*yield*/, prom_1];
+                                            case 1:
+                                                tags = _a.sent();
+                                                tag = tags.find(function (t) { return t.ID === reqIds[i]; });
+                                                res(tag);
+                                                return [3 /*break*/, 3];
+                                            case 2:
+                                                e_2 = _a.sent();
+                                                rej(e_2);
+                                                return [3 /*break*/, 3];
+                                            case 3: return [2 /*return*/];
+                                        }
+                                    });
+                                }); });
+                                reqs.push(req);
+                            };
+                            for (i = 0; i < reqIds.length; i++) {
+                                _loop_1(i);
+                            }
+                        }
+                        return [4 /*yield*/, Promise.all(reqs)];
+                    case 1: return [2 /*return*/, (_a.sent()).filter(function (x) { return !!x; })];
+                }
+            });
+        });
+    }
+    EntityTag.GetListByIds = GetListByIds;
+    function GetList(api, entityTypeId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                cacheData = api.Cache.Get(GetListCacheKey(entityTypeId));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_3;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET(entityTypeId ? "entityType/" + entityTypeId + "/layers" : "layers", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_3 = _a.sent();
+                                rej(e_3);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(entityTypeId), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityTag.GetList = GetList;
+    function Delete(api, tagId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!tagId) {
+                            throw ("Tag ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("layer/" + tagId, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(tagId));
+                        api.Cache.RemoveByStartsWith(GetListCacheKey());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    EntityTag.Delete = Delete;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.ID)) {
+                            throw ("Tag ID is required.");
+                        }
+                        url = data.ID ? "layer/" + data.ID : "layer";
+                        return [4 /*yield*/, api.post(url, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data.ID));
+                        api.Cache.RemoveByStartsWith(GetListCacheKey());
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    EntityTag.Update = Update;
+})(EntityTag || (EntityTag = {}));
+
+var EntityType;
+(function (EntityType) {
+    function GetCacheKey(typeId) {
+        return "" + Api.ECacheKey.EntityType + Api.ECacheKey.Id + typeId;
+    }
+    EntityType.GetCacheKey = GetCacheKey;
+    function GetListCacheKey() {
+        return Api.ECacheKey.EntityType;
+    }
+    EntityType.GetListCacheKey = GetListCacheKey;
+    var EAttributeType;
+    (function (EAttributeType) {
+        EAttributeType["String"] = "String";
+        EAttributeType["Double"] = "Double";
+        EAttributeType["Integer"] = "Integer";
+        EAttributeType["Datetime"] = "Datetime";
+        EAttributeType["Structure"] = "Structure";
+        EAttributeType["Geometry"] = "Geometry";
+    })(EAttributeType = EntityType.EAttributeType || (EntityType.EAttributeType = {}));
+    function Get(api, typeId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!typeId) {
+                    throw ("Type ID is required.");
+                }
+                key = GetCacheKey(typeId);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("entitytype/" + typeId, Api.PrepReqParams());
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityType.Get = Get;
+    function Delete(api, typeId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!typeId) {
+                            throw ("Type ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("entitytype/" + typeId, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(typeId));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    EntityType.Delete = Delete;
+    function GetList(api) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                cacheData = api.Cache.Get(GetListCacheKey());
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("entitytypes", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    EntityType.GetList = GetList;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!data) {
+                            data = {};
+                        }
+                        if (!data.ID) {
+                            data.ID = ObjectUtils.UId();
+                        }
+                        if (!data.Name) {
+                            data.Name = data.ID;
+                        }
+                        return [4 /*yield*/, api.POST("entitytype", data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data.ID));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    EntityType.Update = Update;
+})(EntityType || (EntityType = {}));
+
+var Cell = /** @class */ (function () {
+    function Cell() {
+        this.Fetched = false;
+        this.IsFetched = null;
+        this.FetchPageIndex = 0;
+        this.Boundaries = null;
+    }
+    Cell.prototype.GetBounds = function () {
+        // Entity data works in -180 to 180 range.
+        function prepareRangeForBounds(range) {
+            if (range > 180) {
+                return range - 360;
+            }
+            return range;
+        }
+        // Add minor decimal as API crashes when giving it whole numbers.
+        var maxLon = prepareRangeForBounds(this.Boundaries.maxLongitude) + 0.00001;
+        var minLon = prepareRangeForBounds(this.Boundaries.minLongitude) - 0.00001;
+        var maxLat = prepareRangeForBounds(this.Boundaries.maxLatitude) + 0.00001;
+        var minLat = prepareRangeForBounds(this.Boundaries.minLatitude) - 0.00001;
+        return {
+            east: maxLon,
+            north: maxLat,
+            south: minLat,
+            west: minLon
+        };
+    };
+    return Cell;
+}());
+function floorValueToCellSize(size, value) {
+    return Math.floor(value / size) * size;
+}
+function getCellSizeFromHeight(height) {
+    if (height < 1000) {
+        return 0.01;
+    }
+    if (height < 5000) {
+        return 0.025;
+    }
+    else if (height < 10000) {
+        return 0.05;
+    }
+    else if (height < 30000) {
+        return 0.1;
+    }
+    else if (height < 70000) {
+        return 0.2;
+    }
+    else if (height < 100000) {
+        return 0.3;
+    }
+    else if (height < 150000) {
+        return 0.4;
+    }
+    else if (height < 200000) {
+        return 0.5;
+    }
+    else if (height < 300000) {
+        return 0.6;
+    }
+    else if (height < 500000) {
+        return 1;
+    }
+    return 1.5;
+}
+function getCell(cells, cellSize, lon, maxLon, lat, maxLat) {
+    var id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
+    return cells[id];
+}
+function isCellFetched(cell) {
+    if (cell.Fetched) {
+        return true;
+    }
+    // TODO: If all cells of the size smaller are fetched then this is fetched.
+    // TODO: If this is a cell within a larger cell that is fetched then this is fetched.
+    return false;
+}
+function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
+    var id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
+    var cell = getCell(cells, cellSize, lon, maxLon, lat, maxLat);
+    if (!cell) {
+        cell = cells[id] = new Cell();
+        cell.Boundaries = {
+            minLatitude: lat,
+            maxLatitude: maxLat,
+            minLongitude: lon,
+            maxLongitude: maxLon
+        };
+        cell.IsFetched = function () { return isCellFetched(cell); };
+    }
+    return cell;
+}
+var EntityGlobe;
+(function (EntityGlobe) {
+    var Grid = /** @class */ (function () {
+        function Grid() {
+            this.cells = {};
+        }
+        Grid.prototype.GetCellsForView = function (viewRect) {
+            var cells = [];
+            var minLat = viewRect.south;
+            var minLon = viewRect.west;
+            var maxLat = viewRect.north;
+            var maxLon = viewRect.east;
+            var MAX_CELLS = 150;
+            var cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
+            var curMinLon = floorValueToCellSize(cellDegreeSize, minLon);
+            var curMinLat = floorValueToCellSize(cellDegreeSize, minLat);
+            var width = (maxLon - curMinLon) / cellDegreeSize;
+            var height = (maxLat - curMinLat) / cellDegreeSize;
+            for (var x = 0; x < width; x++) {
+                for (var y = 0; y < height; y++) {
+                    var lon = x * cellDegreeSize + curMinLon;
+                    var lat = y * cellDegreeSize + curMinLat;
+                    var cell = getOrCreateCell(this.cells, cellDegreeSize, lon, lon + cellDegreeSize, lat, lat + cellDegreeSize);
+                    cells.push(cell);
+                    if (cells.length > MAX_CELLS) {
+                        break;
+                    }
+                }
+            }
+            return cells;
+        };
+        return Grid;
+    }());
+    EntityGlobe.Grid = Grid;
+})(EntityGlobe || (EntityGlobe = {}));
+
+var MAX_AREA_IN_DEGREES = 90;
+var MAX_RETRY_ATTEMPTS = 1;
+var RETRY_DELAY_INCREMENT = 500;
+var REQUEST_PAGE_DELAY = 50;
+var regMenuItemGetter = /** @class */ (function () {
+    function regMenuItemGetter(tagIds, minHeight, maxHeight) {
+        this.TagIds = tagIds;
+        this.MinHeight = minHeight;
+        this.MaxHeight = maxHeight;
+    }
+    return regMenuItemGetter;
+}());
+function delay(milliseconds) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (res) {
+                    setTimeout(function () {
+                        res();
+                    }, milliseconds);
+                })];
+        });
+    });
+}
+var EntityFilterGetter;
+(function (EntityFilterGetter) {
+    var EStatus;
+    (function (EStatus) {
+        EStatus["Scanning"] = "SCANNING";
+        EStatus["Loading"] = "LOADING";
+    })(EStatus = EntityFilterGetter.EStatus || (EntityFilterGetter.EStatus = {}));
+    var Getter = /** @class */ (function () {
+        function Getter(api, viewPort, typeId, batchSize, attrFilter) {
+            this.onUpdate = null;
+            this.LastStateUpdates = {};
+            this.onStateUpdate = null;
+            this.viewPortChangeRemoval = null;
+            this.cells = null;
+            this.registeredItems = {};
+            this.getterLoopId = 0;
+            this.tagIds = null;
+            this.minHeight = 0;
+            this.maxHeight = 100000;
+            this.viewRect = null;
+            this.viewCenter = null;
+            this.api = api;
+            this.typeId = typeId;
+            this.batchSize = batchSize;
+            this.viewPort = viewPort;
+            this.attrFilter = attrFilter;
+        }
+        Object.defineProperty(Getter.prototype, "OnUpdate", {
+            get: function () {
+                if (!this.onUpdate) {
+                    this.onUpdate = new BruceEvent();
+                }
+                return this.onUpdate;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Getter.prototype, "OnStateUpdate", {
+            get: function () {
+                if (!this.onStateUpdate) {
+                    this.onStateUpdate = new BruceEvent();
+                }
+                return this.onStateUpdate;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Getter.prototype.viewAreaSub = function () {
+            var _this = this;
+            this.viewAreaDispose();
+            this.viewPortChangeRemoval = this.viewPort.Updated().Subscribe(function () {
+                _this.updateBounds();
+                _this.startGetterLoop();
+            });
+        };
+        Getter.prototype.viewAreaDispose = function () {
+            var _a;
+            (_a = this.viewPortChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+        };
+        Getter.prototype.GetMenuItems = function () {
+            return Object.keys(this.registeredItems);
+        };
+        Getter.prototype.IncludeMenuItem = function (menuItemId, layerIds, minHeight, maxHeight) {
+            this.registeredItems[menuItemId] = new regMenuItemGetter(layerIds, minHeight, maxHeight);
+            this.updateState();
+        };
+        Getter.prototype.ExcludeMenuItem = function (menuItemId) {
+            this.registeredItems[menuItemId] = null;
+            delete this.registeredItems[menuItemId];
+            this.updateState();
+        };
+        Getter.prototype.updateBounds = function () {
+            var viewRect = this.viewPort.GetBounds();
+            var poi = this.viewPort.GetTarget();
+            if (viewRect && poi) {
+                if (Math.abs(viewRect.west - viewRect.east) > MAX_AREA_IN_DEGREES) {
+                    return;
+                }
+                if (Math.abs(viewRect.south - viewRect.north) > MAX_AREA_IN_DEGREES) {
+                    return;
+                }
+                this.viewRect = viewRect;
+                this.viewCenter = poi;
+            }
+        };
+        Getter.prototype.updateState = function () {
+            var tagIds = [];
+            var menuItemIds = this.GetMenuItems();
+            var minHeight = null;
+            var maxHeight = null;
+            for (var i = 0; i < menuItemIds.length; i++) {
+                var menuItem = this.registeredItems[menuItemIds[i]];
+                if (menuItem) {
+                    if (maxHeight == null || maxHeight < menuItem.MaxHeight) {
+                        maxHeight = menuItem.MaxHeight;
+                    }
+                    if (minHeight == null || minHeight > menuItem.MinHeight) {
+                        minHeight = menuItem.MinHeight;
+                    }
+                    var itemLayerIds = menuItem.TagIds;
+                    if (itemLayerIds) {
+                        for (var j = 0; j < itemLayerIds.length; j++) {
+                            var itemLayerId = itemLayerIds[j];
+                            if (!tagIds.includes(itemLayerId)) {
+                                tagIds.push(itemLayerId);
+                            }
+                        }
+                    }
+                }
+            }
+            if (menuItemIds.length > 0) {
+                // Reset cells so none are marked as fetched.
+                this.cells = new EntityGlobe.Grid();
+                this.tagIds = tagIds;
+                this.minHeight = minHeight;
+                this.maxHeight = maxHeight;
+                this.updateBounds();
+                this.startGetterLoop();
+                this.viewAreaSub();
+            }
+            else {
+                this.getterLoopId = -1;
+                this.viewAreaDispose();
+            }
+        };
+        Getter.prototype.postStatus = function (status) {
+            var _a;
+            this.LastStateUpdates[status.msg] = status;
+            (_a = this.onStateUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(status);
+        };
+        Getter.prototype.startGetterLoop = function () {
+            var _this = this;
+            // Increase id so that existing loops stop.
+            this.getterLoopId += 1;
+            var loopId = this.getterLoopId;
+            new Promise(function () { return __awaiter(_this, void 0, void 0, function () {
+                var MIN_HEIGHT, MAX_HEIGHT, PAGE_SIZE, retryAttempts, retryDelay, prevFirstId, prevLastId, alt, cells, curCellIndex, postedScanning, postedLoading, curCell, page, first, last, e_1;
+                var _a, _b, _c, _d, _e;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0: 
+                        // Minor delay to stop 50 menu items enabling doing their first request all together.
+                        // This gives it time to recognize only 1 request is needed.
+                        // Would be better to not use this delay but we're on a clock.
+                        return [4 /*yield*/, delay(100)];
+                        case 1:
+                            // Minor delay to stop 50 menu items enabling doing their first request all together.
+                            // This gives it time to recognize only 1 request is needed.
+                            // Would be better to not use this delay but we're on a clock.
+                            _f.sent();
+                            MIN_HEIGHT = this.minHeight;
+                            MAX_HEIGHT = this.maxHeight;
+                            PAGE_SIZE = this.batchSize;
+                            retryAttempts = MAX_RETRY_ATTEMPTS;
+                            retryDelay = 0;
+                            prevFirstId = "";
+                            prevLastId = "";
+                            _f.label = 2;
+                        case 2:
+                            if (!((!this.viewCenter || !this.viewRect) && this.getterLoopId == loopId)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, delay(RETRY_DELAY_INCREMENT)];
+                        case 3:
+                            _f.sent();
+                            return [3 /*break*/, 2];
+                        case 4:
+                            if (this.getterLoopId != loopId) {
+                                return [2 /*return*/];
+                            }
+                            alt = this.viewRect.alt;
+                            if (alt > MAX_HEIGHT || (alt < MIN_HEIGHT && MIN_HEIGHT > 0)) {
+                                return [2 /*return*/];
+                            }
+                            cells = this.cells.GetCellsForView(this.viewRect);
+                            curCellIndex = cells.length > 0 ? 0 : null;
+                            postedScanning = false;
+                            postedLoading = false;
+                            _f.label = 5;
+                        case 5:
+                            if (!(retryAttempts > 0 && curCellIndex != null)) return [3 /*break*/, 13];
+                            if (this.getterLoopId != loopId) {
+                                return [3 /*break*/, 13];
+                            }
+                            if (!(retryDelay > 0)) return [3 /*break*/, 7];
+                            return [4 /*yield*/, delay(retryDelay)];
+                        case 6:
+                            _f.sent();
+                            _f.label = 7;
+                        case 7:
+                            if (!postedScanning) {
+                                this.postStatus({ msg: EStatus.Scanning, revoking: false });
+                                postedScanning = true;
+                            }
+                            curCell = cells[curCellIndex];
+                            if (curCell.IsFetched()) {
+                                curCellIndex += 1;
+                                if (!cells[curCellIndex]) {
+                                    curCellIndex = null;
+                                }
+                                return [3 /*break*/, 5];
+                            }
+                            _f.label = 8;
+                        case 8:
+                            _f.trys.push([8, 10, , 11]);
+                            return [4 /*yield*/, Entity.Filter.V1.GetList(this.api, {
+                                    pageSize: PAGE_SIZE,
+                                    pageIndex: curCell.FetchPageIndex,
+                                    entityTypeId: this.typeId,
+                                    layerIds: this.tagIds,
+                                    bounds: curCell.GetBounds(),
+                                    sortOrder: Api.ESortOrder.Asc,
+                                    entityTypeConditions: this.attrFilter
+                                })];
+                        case 9:
+                            page = _f.sent();
+                            if (this.getterLoopId != loopId) {
+                                return [3 /*break*/, 13];
+                            }
+                            if (page) {
+                                (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(page);
+                            }
+                            if (!postedLoading) {
+                                this.postStatus({ msg: EStatus.Loading, revoking: false });
+                                postedLoading = true;
+                            }
+                            if (page.length <= 0) {
+                                curCell.Fetched = true; // Only mark as fetched when ALL pages are done.
+                                return [3 /*break*/, 5];
+                            }
+                            // Checking to make sure it's not just the same batch over and over again.
+                            if (page.length > 0) {
+                                first = (_c = (_b = page[0]) === null || _b === void 0 ? void 0 : _b.Bruce) === null || _c === void 0 ? void 0 : _c.ID;
+                                last = (_e = (_d = page[page.length - 1]) === null || _d === void 0 ? void 0 : _d.Bruce) === null || _e === void 0 ? void 0 : _e.ID;
+                                if (prevFirstId == first && prevLastId == last) {
+                                    return [3 /*break*/, 13];
+                                }
+                                else {
+                                    prevFirstId = first;
+                                    prevLastId = last;
+                                }
+                            }
+                            curCell.FetchPageIndex++;
+                            // Request passed so let's assume it was server hiccup and refresh counts.
+                            retryAttempts = MAX_RETRY_ATTEMPTS;
+                            retryDelay = 0;
+                            return [3 /*break*/, 11];
+                        case 10:
+                            e_1 = _f.sent();
+                            console.log(e_1);
+                            // Request failed so let's add a delay and try again soon.
+                            retryDelay += RETRY_DELAY_INCREMENT;
+                            retryAttempts -= 1;
+                            return [3 /*break*/, 11];
+                        case 11: return [4 /*yield*/, delay(REQUEST_PAGE_DELAY)];
+                        case 12:
+                            _f.sent();
+                            return [3 /*break*/, 5];
+                        case 13:
+                            if (postedLoading) {
+                                this.postStatus({ msg: EStatus.Loading, revoking: true });
+                            }
+                            if (postedScanning) {
+                                this.postStatus({ msg: EStatus.Scanning, revoking: true });
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
+        return Getter;
+    }());
+    EntityFilterGetter.Getter = Getter;
+})(EntityFilterGetter || (EntityFilterGetter = {}));
+
+var MAX_AREA_IN_DEGREES$1 = 90;
+var GETTER_DELAY = 50;
+var EntityLoadedGetter = /** @class */ (function () {
+    function EntityLoadedGetter(entities, viewPort, batchSize) {
+        var _this = this;
+        this.viewPortRemoval = null;
+        this.viewRect = null;
+        this.viewCenter = null;
+        this.onUpdate = null;
+        this.entities = entities;
+        this.viewPort = viewPort;
+        this.batchSize = batchSize;
+        this.viewPortRemoval = this.viewPort.Updated().Subscribe(function () {
+            _this.updateBounds();
+            _this.startGetterLoop();
+        });
+    }
+    Object.defineProperty(EntityLoadedGetter.prototype, "OnUpdate", {
+        get: function () {
+            if (!this.onUpdate) {
+                this.onUpdate = new BruceEvent();
+            }
+            return this.onUpdate;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EntityLoadedGetter.prototype.Dispose = function () {
+        var _a;
+        (_a = this.viewPortRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+    };
+    EntityLoadedGetter.prototype.updateBounds = function () {
+        var viewRect = this.viewPort.GetBounds();
+        var poi = this.viewPort.GetTarget();
+        if (viewRect && poi) {
+            if (Math.abs(viewRect.west - viewRect.east) > MAX_AREA_IN_DEGREES$1) {
+                return;
+            }
+            if (Math.abs(viewRect.south - viewRect.north) > MAX_AREA_IN_DEGREES$1) {
+                return;
+            }
+            this.viewRect = viewRect;
+            this.viewCenter = poi;
+        }
+    };
+    EntityLoadedGetter.prototype.startGetterLoop = function () {
+        var _this = this;
+        clearInterval(this.getterInterval);
+        if (!this.viewRect || !this.viewCenter) {
+            return;
+        }
+        var index = 0;
+        this.getterInterval = setInterval(function () {
+            _this.processBatch(_this.entities.slice(index, index + _this.batchSize));
+            index += _this.batchSize;
+            if (index >= _this.entities.length) {
+                clearInterval(_this.getterInterval);
+            }
+        }, GETTER_DELAY);
+    };
+    EntityLoadedGetter.prototype.processBatch = function (batch) {
+        var _a;
+        if (batch.length > 0) {
+            (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(batch);
+        }
+    };
+    return EntityLoadedGetter;
+}());
+
+var ClientFile;
+(function (ClientFile) {
+    function GetCacheKey(fileId) {
+        return "" + Api.ECacheKey.ClientFile + Api.ECacheKey.Id + fileId;
+    }
+    ClientFile.GetCacheKey = GetCacheKey;
+    function Get(api, fileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!fileId) {
+                    throw ("File ID is required.");
+                }
+                key = GetCacheKey(fileId);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("file/" + fileId + "/details", Api.PrepReqParams());
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    ClientFile.Get = Get;
+    function Delete(api, fileIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, i, key;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!fileIds.length) {
+                            throw ("File IDs are required.");
+                        }
+                        data = {
+                            Items: fileIds
+                        };
+                        return [4 /*yield*/, api.POST("deleteFiles", data, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        for (i = 0; i < fileIds.length; i++) {
+                            key = GetCacheKey(fileIds[i]);
+                            api.Cache.Remove(key);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    ClientFile.Delete = Delete;
+    function Upload(api, file, onProgress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!file) {
+                    throw ("File is required.");
+                }
+                return [2 /*return*/, api.UPLOAD("file/uploadNew", file, { onProgress: onProgress })];
+            });
+        });
+    }
+    ClientFile.Upload = Upload;
+    var Filter;
+    (function (Filter) {
+        var V1;
+        (function (V1) {
+            var EColumn;
+            (function (EColumn) {
+                EColumn["ID"] = "id";
+                EColumn["Name"] = "name";
+                EColumn["DateTime"] = "datetime";
+                EColumn["MIMEType"] = "mimeType";
+                EColumn["Size"] = "size";
+                EColumn["User"] = "user";
+                EColumn["Extension"] = "extension";
+            })(EColumn = V1.EColumn || (V1.EColumn = {}));
+            var ESortOrder;
+            (function (ESortOrder) {
+                ESortOrder["ASC"] = "asc";
+                ESortOrder["DEC"] = "desc";
+            })(ESortOrder = V1.ESortOrder || (V1.ESortOrder = {}));
+            var ERowOperator;
+            (function (ERowOperator) {
+                ERowOperator["AND"] = "AND";
+                ERowOperator["OR"] = "OR";
+            })(ERowOperator = V1.ERowOperator || (V1.ERowOperator = {}));
+            function GetList(api, filter) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var data;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, api.POST("files/filtered", filter, Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                return [2 /*return*/, data.Items];
+                        }
+                    });
+                });
+            }
+            V1.GetList = GetList;
+        })(V1 = Filter.V1 || (Filter.V1 = {}));
+        // TODO: Helpers for constructing the filter.
+    })(Filter = ClientFile.Filter || (ClientFile.Filter = {}));
+})(ClientFile || (ClientFile = {}));
+
+var ProgramKey;
+(function (ProgramKey) {
+    function GetCacheKey(programId) {
+        return Api.ECacheKey.ProgramKey + Api.ECacheKey.Id + programId;
+    }
+    ProgramKey.GetCacheKey = GetCacheKey;
+    function GetListCacheKey() {
+        return Api.ECacheKey.ProgramKey;
+    }
+    ProgramKey.GetListCacheKey = GetListCacheKey;
+    var EProgramId;
+    (function (EProgramId) {
+        EProgramId["CesiumIon"] = "CesiumIon";
+        EProgramId["BingMaps"] = "BingMaps";
+        EProgramId["Mapbox"] = "Mapbox";
+    })(EProgramId = ProgramKey.EProgramId || (ProgramKey.EProgramId = {}));
+    function Get(api, programId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!programId) {
+                    throw ("Program ID is required.");
+                }
+                key = GetCacheKey(programId);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("programkey/" + programId, Api.PrepReqParams());
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    ProgramKey.Get = Get;
+    function GetList(api) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                cacheData = api.Cache.Get(GetListCacheKey());
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("programkeys", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    ProgramKey.GetList = GetList;
+    function Delete(api, programId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!programId) {
+                            throw ("Program ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("programkey/" + programId, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(programId));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    ProgramKey.Delete = Delete;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.ProgramId)) {
+                            throw ("Program ID is required.");
+                        }
+                        return [4 /*yield*/, api.post("programkey", data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data.ProgramId));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    ProgramKey.Update = Update;
+})(ProgramKey || (ProgramKey = {}));
+
+var MenuItemZoomControl;
+(function (MenuItemZoomControl) {
+    var EDisplayType;
+    (function (EDisplayType) {
+        EDisplayType["Hidden"] = "hidden";
+        EDisplayType["Point"] = "point";
+        EDisplayType["Geometry"] = "geometry";
+        EDisplayType["Model3D"] = "3d";
+    })(EDisplayType = MenuItemZoomControl.EDisplayType || (MenuItemZoomControl.EDisplayType = {}));
+})(MenuItemZoomControl || (MenuItemZoomControl = {}));
+
+var Tileset;
+(function (Tileset) {
+    function GetCacheKey(tilesetId, loadFiles) {
+        return "" + Api.ECacheKey.Tileset + Api.ECacheKey.Id + tilesetId + Api.ECacheKey.Id + loadFiles;
+    }
+    Tileset.GetCacheKey = GetCacheKey;
+    function GetListCacheKey() {
+        return Api.ECacheKey.Tileset;
+    }
+    Tileset.GetListCacheKey = GetListCacheKey;
+    var EType;
+    (function (EType) {
+        EType["PointCloud"] = "POINT_CLOUD";
+        EType["GeoMap"] = "GEO_MAP";
+        EType["EntitiesMap"] = "ENTITIES_MAP";
+        EType["EntitiesSet"] = "ENTITIES_SET";
+        EType["Cad"] = "MODEL";
+        EType["Terrain"] = "GEO_TERR";
+        EType["ExternalTerrain"] = "EXTERNAL_TERR";
+        EType["ExternalGeoMap"] = "EXTERNAL_MAP";
+    })(EType = Tileset.EType || (Tileset.EType = {}));
+    var EPivot;
+    (function (EPivot) {
+        EPivot["None"] = "none";
+        EPivot["Box"] = "box";
+        EPivot["Weight"] = "weight";
+        EPivot["UCS"] = "ucs";
+    })(EPivot = Tileset.EPivot || (Tileset.EPivot = {}));
+    function Get(api, tilesetId, loadFiles) {
+        if (loadFiles === void 0) { loadFiles = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            return __generator(this, function (_a) {
+                if (!tilesetId) {
+                    throw ("Tileset ID is required.");
+                }
+                cacheData = api.Cache.Get(GetCacheKey(tilesetId, loadFiles));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("tileset/get/" + tilesetId + "?noFiles=" + (loadFiles ? 0 : 1));
+                api.Cache.Set(GetCacheKey(tilesetId, loadFiles), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    Tileset.Get = Get;
+    function GetList(api) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                cacheData = api.Cache.Get(GetListCacheKey());
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("tileset/getList")];
+                            case 1:
+                                data = _a.sent();
+                                res(data);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    Tileset.GetList = GetList;
+    function Delete(api, tilesetId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!tilesetId) {
+                            throw ("Tileset ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("tileset/delete/" + tilesetId)];
+                    case 1:
+                        _a.sent();
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Tileset + Api.ECacheKey.Id + tilesetId);
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Tileset);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    Tileset.Delete = Delete;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isNew, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.name) || !(data === null || data === void 0 ? void 0 : data.type)) {
+                            throw ("Tileset name and type are required.");
+                        }
+                        isNew = !data.id;
+                        if (!isNew) return [3 /*break*/, 2];
+                        return [4 /*yield*/, api.GET("tileset/new?type=" + data.type + "&name=" + Api.Encode(data.name))];
+                    case 1:
+                        res = _a.sent();
+                        data = __assign(__assign({}, data), res);
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, api.post("tileset", data)];
+                    case 3:
+                        data = _a.sent();
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Tileset + Api.ECacheKey.Id + data.id);
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Tileset);
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    Tileset.Update = Update;
+    function UploadFile(api, tilesetId, file, onProgress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!tilesetId || !file) {
+                    throw ("Tileset ID and file are required.");
+                }
+                return [2 /*return*/, api.UPLOAD("tileset/uploadFile/" + tilesetId + "/files", file, { onProgress: onProgress })];
+            });
+        });
+    }
+    Tileset.UploadFile = UploadFile;
+    function DeleteFile(api, tilesetId, file) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!tilesetId || !file) {
+                            throw ("Tileset ID and file are required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("tileset/deleteFile/" + tilesetId + "/files/" + file)];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(tilesetId, true));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    Tileset.DeleteFile = DeleteFile;
+    function UploadSrcFile(api, tilesetId, file, onProgress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!tilesetId || !file) {
+                            throw ("Tileset ID and file are required.");
+                        }
+                        return [4 /*yield*/, api.UPLOAD("tileset/uploadFile/" + tilesetId + "/src", file, { onProgress: onProgress })];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(tilesetId, true));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    Tileset.UploadSrcFile = UploadSrcFile;
+    function DeleteSrcFile(api, tilesetId, file) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!tilesetId || !file) {
+                            throw ("Tileset ID and file are required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("tileset/deleteFile/" + tilesetId + "/src/" + file)];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(tilesetId, true));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    Tileset.DeleteSrcFile = DeleteSrcFile;
+    function GetFileUrl(api, tilesetId, file) {
+        if (!tilesetId) {
+            throw ("Tileset ID is required.");
+        }
+        if (!file) {
+            file = "";
+        }
+        return api.GetBaseUrl() + ("tileset/getFile/" + tilesetId + "/files/" + file);
+    }
+    Tileset.GetFileUrl = GetFileUrl;
+    function GetSrcFileUrl(api, tilesetId, file) {
+        if (!tilesetId) {
+            throw ("Tileset ID is required.");
+        }
+        if (!file) {
+            file = "";
+        }
+        return api.GetBaseUrl() + ("tileset/getFile/" + tilesetId + "/src/" + file);
+    }
+    Tileset.GetSrcFileUrl = GetSrcFileUrl;
+    function GetPublicFileUrl(api, tilesetId, file) {
+        if (!tilesetId) {
+            throw ("Tileset ID is required.");
+        }
+        if (!file) {
+            file = "";
+        }
+        return api.GetBaseUrl() + ("tileset/file/" + tilesetId + "/" + file);
+    }
+    Tileset.GetPublicFileUrl = GetPublicFileUrl;
+    function Generate(api, tilesetId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!tilesetId) {
+                            throw ("Tileset ID is required.");
+                        }
+                        return [4 /*yield*/, api.GET("tileset/generate/" + tilesetId)];
+                    case 1:
+                        res = _a.sent();
+                        return [2 /*return*/, res.ID];
+                }
+            });
+        });
+    }
+    Tileset.Generate = Generate;
+    var Publish;
+    (function (Publish) {
+        function GetCacheKey(accountId, tilesetId) {
+            if (!tilesetId) {
+                tilesetId = "";
+            }
+            return Api.ECacheKey.PublishTileset + Api.ECacheKey.Id + accountId + Api.ECacheKey.Id + tilesetId;
+        }
+        Publish.GetCacheKey = GetCacheKey;
+        function Update(api, data) {
+            return __awaiter(this, void 0, void 0, function () {
+                var res, req;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!(data === null || data === void 0 ? void 0 : data["Tileset.ID"]) || !(data === null || data === void 0 ? void 0 : data["PublishedBy.ClientAccount.ID"]) || !(data === null || data === void 0 ? void 0 : data["PublishedBy.User.ID"])) {
+                                throw ("Tileset ID, client account ID, and user ID are required.");
+                            }
+                            if (!data.ID) {
+                                data.ID = 0;
+                            }
+                            return [4 /*yield*/, api.POST("tileset/" + data.ID, data)];
+                        case 1:
+                            res = _a.sent();
+                            req = {
+                                "ClientAccount.ID": data["EnabledFor.ClientAccount.ID"]
+                            };
+                            data.ID = res.ID;
+                            return [4 /*yield*/, api.POST("tileset/" + data.ID + "/enableForAccounts", req)];
+                        case 2:
+                            _a.sent();
+                            api.Cache.Remove(GetCacheKey(data["PublishedBy.ClientAccount.ID"], data["Tileset.ID"]));
+                            api.Cache.Remove(GetCacheKey(data["PublishedBy.ClientAccount.ID"]));
+                            return [2 /*return*/, data];
+                    }
+                });
+            });
+        }
+        Publish.Update = Update;
+        function Get(api, accountId, tilesetId) {
+            return __awaiter(this, void 0, void 0, function () {
+                var cacheData, req;
+                return __generator(this, function (_a) {
+                    if (!accountId || !tilesetId) {
+                        throw ("Client account ID and tileset ID are required.");
+                    }
+                    cacheData = api.Cache.Get(GetCacheKey(accountId, tilesetId));
+                    if (cacheData) {
+                        return [2 /*return*/, cacheData];
+                    }
+                    req = api.GET("tilesetByPublisher/" + accountId + "/" + tilesetId);
+                    api.Cache.Set(GetCacheKey(accountId, tilesetId), req);
+                    return [2 /*return*/, req];
+                });
+            });
+        }
+        Publish.Get = Get;
+        function GetList(api, accountId) {
+            return __awaiter(this, void 0, void 0, function () {
+                var cacheData, req;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (!accountId) {
+                        throw ("Client account ID is required.");
+                    }
+                    cacheData = api.Cache.Get(GetCacheKey(accountId));
+                    if (cacheData) {
+                        return [2 /*return*/, cacheData];
+                    }
+                    req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                        var data, e_2;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    _a.trys.push([0, 2, , 3]);
+                                    return [4 /*yield*/, api.GET("tilesets/enabledForAccount/" + accountId)];
+                                case 1:
+                                    data = _a.sent();
+                                    res(data.Items);
+                                    return [3 /*break*/, 3];
+                                case 2:
+                                    e_2 = _a.sent();
+                                    rej(e_2);
+                                    return [3 /*break*/, 3];
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                    api.Cache.Set(GetCacheKey(accountId), req);
+                    return [2 /*return*/, req];
+                });
+            });
+        }
+        Publish.GetList = GetList;
+    })(Publish = Tileset.Publish || (Tileset.Publish = {}));
+})(Tileset || (Tileset = {}));
+
+var MenuItem;
+(function (MenuItem) {
+    var EType;
+    (function (EType) {
+        EType["None"] = "NONE";
+        EType["BruceEntities"] = "BruceEntity";
+        EType["BruceEntity"] = "SingleEntity";
+        EType["Osm"] = "OSMBuildingsTileset";
+        EType["CadTileset"] = "ModelTileset";
+        EType["ArbTileset"] = "Cesium3DTileset";
+        EType["Kml"] = "StaticKML";
+        EType["EntitiesTileset"] = "EntitiesTileset";
+        EType["EntitiesRaster"] = "RasterEntitiesTileset";
+        EType["PointCloud"] = "PointCloudTileset";
+    })(EType = MenuItem.EType || (MenuItem.EType = {}));
+    function CreateFromEntityId(entityId, typeId, styleId) {
+        return {
+            id: ObjectUtils.UId(),
+            Type: EType.BruceEntity,
+            Caption: "Generated Entity Menu Item",
+            BruceEntity: {
+                "EntityType.ID": typeId,
+                EntityId: entityId
+            },
+            CameraZoomSettings: [
+                {
+                    DisplayType: MenuItemZoomControl.EDisplayType.Model3D,
+                    MaxZoom: 8000,
+                    MinZoom: 0,
+                    StyleID: styleId
+                }
+            ]
+        };
+    }
+    MenuItem.CreateFromEntityId = CreateFromEntityId;
+    function CreateFromTypeId(typeId, styleId) {
+        return {
+            id: ObjectUtils.UId(),
+            Type: EType.BruceEntities,
+            Caption: "Generated Entity Type Menu Item",
+            BruceEntity: {
+                "EntityType.ID": typeId
+            },
+            CameraZoomSettings: [
+                {
+                    DisplayType: MenuItemZoomControl.EDisplayType.Model3D,
+                    MaxZoom: 8000,
+                    MinZoom: 0,
+                    StyleID: styleId
+                }
+            ]
+        };
+    }
+    MenuItem.CreateFromTypeId = CreateFromTypeId;
+    function CreateFromTilesetId(tilesetId, type) {
+        if (type === Tileset.EType.Cad) {
+            return {
+                id: ObjectUtils.UId(),
+                Type: EType.CadTileset,
+                Caption: "Generated CAD Menu Item",
+                FlyTo: false,
+                tileset: {
+                    TilesetID: tilesetId
+                }
+            };
+        }
+        else if (type == Tileset.EType.EntitiesSet) {
+            return {
+                id: ObjectUtils.UId(),
+                Type: EType.EntitiesTileset,
+                Caption: "Generated Entities Menu Item",
+                FlyTo: false,
+                tileset: {
+                    TilesetID: tilesetId
+                }
+            };
+        }
+        else if (type == Tileset.EType.PointCloud) {
+            return {
+                id: ObjectUtils.UId(),
+                Type: EType.PointCloud,
+                Caption: "Generated Point Cloud Menu Item",
+                FlyTo: false,
+                tileset: {
+                    TilesetID: tilesetId
+                }
+            };
+        }
+        else if (type == Tileset.EType.EntitiesMap) {
+            return {
+                id: ObjectUtils.UId(),
+                Type: EType.EntitiesRaster,
+                Caption: "Generated Entities Menu Item",
+                tileset: {
+                    TilesetID: tilesetId
+                }
+            };
+        }
+        throw ("Tileset type not supported.");
+    }
+    MenuItem.CreateFromTilesetId = CreateFromTilesetId;
+})(MenuItem || (MenuItem = {}));
+
+var ProjectViewBookmark;
+(function (ProjectViewBookmark) {
+    function GetCacheKey(viewId, bookmarkId) {
+        return "" + Api.ECacheKey.ProjectViewBookmark + Api.ECacheKey.Id + viewId + Api.ECacheKey.Id + bookmarkId;
+    }
+    ProjectViewBookmark.GetCacheKey = GetCacheKey;
+    function GetListCacheKey() {
+        return Api.ECacheKey.ProjectViewBookmark;
+    }
+    ProjectViewBookmark.GetListCacheKey = GetListCacheKey;
+    function Get(api, viewId, bookmarkId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!viewId || !bookmarkId) {
+                    throw ("View ID and Bookmark ID are required.");
+                }
+                key = GetCacheKey(viewId, bookmarkId);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("ui.view/" + viewId + "/slide/" + bookmarkId, Api.PrepReqParams());
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    ProjectViewBookmark.Get = Get;
+    function Delete(api, viewId, bookmarkId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!viewId || !bookmarkId) {
+                            throw ("View ID and Bookmark ID are required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("ui.view/" + viewId + "/slide/" + bookmarkId, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(viewId, bookmarkId));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    ProjectViewBookmark.Delete = Delete;
+    function GetList(api, viewId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!viewId) {
+                    throw ("View ID is required.");
+                }
+                cacheData = api.Cache.Get(GetListCacheKey());
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("ui.view/" + viewId + "/slides", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    ProjectViewBookmark.GetList = GetList;
+    function Update(api, viewId, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.ID)) {
+                            data.ID = ObjectUtils.UId();
+                        }
+                        if (!(data === null || data === void 0 ? void 0 : data.Title)) {
+                            data.Title = data.ID;
+                        }
+                        return [4 /*yield*/, api.post("ui.view/" + viewId + "/slide/" + data.ID, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(viewId, data.ID));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    ProjectViewBookmark.Update = Update;
+})(ProjectViewBookmark || (ProjectViewBookmark = {}));
+
+var ProjectView;
+(function (ProjectView) {
+    function GetCacheKey(viewId) {
+        return "" + Api.ECacheKey.ProjectView + Api.ECacheKey.Id + viewId;
+    }
+    ProjectView.GetCacheKey = GetCacheKey;
+    function GetListCacheKey() {
+        return Api.ECacheKey.ProjectView;
+    }
+    ProjectView.GetListCacheKey = GetListCacheKey;
+    function Get(api, viewId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!viewId) {
+                    throw ("View ID is required.");
+                }
+                key = GetCacheKey(viewId);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("ui.view/" + viewId, Api.PrepReqParams());
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    ProjectView.Get = Get;
+    function GetList(api) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            var _this = this;
+            return __generator(this, function (_a) {
+                cacheData = api.Cache.Get(GetListCacheKey());
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                    var data, e_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, api.GET("ui.view/list", Api.PrepReqParams())];
+                            case 1:
+                                data = _a.sent();
+                                res(data.Items);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _a.sent();
+                                rej(e_1);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                api.Cache.Set(GetListCacheKey(), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    ProjectView.GetList = GetList;
+    function Delete(api, viewId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!viewId) {
+                            throw ("View ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("ui.view/" + viewId, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(viewId));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    ProjectView.Delete = Delete;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.ID)) {
+                            data.ID = ObjectUtils.UId();
+                        }
+                        if (!(data === null || data === void 0 ? void 0 : data.Name)) {
+                            data.Name = data.ID;
+                        }
+                        return [4 /*yield*/, api.post("ui.view", data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data.ID));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    ProjectView.Update = Update;
+})(ProjectView || (ProjectView = {}));
+
+var PendingAction;
+(function (PendingAction) {
+    var EStatus;
+    (function (EStatus) {
+        EStatus["InProgress"] = "IN_PROGRESS";
+        EStatus["Cancelled"] = "CANCELLED";
+        EStatus["Complete"] = "COMPLETE";
+        EStatus["Failed"] = "FAILED";
+    })(EStatus = PendingAction.EStatus || (PendingAction.EStatus = {}));
+    function Get(api, actionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!actionId) {
+                    throw ("Action ID is required.");
+                }
+                return [2 /*return*/, api.GET("pendingAction/" + actionId, Api.PrepReqParams())];
+            });
+        });
+    }
+    PendingAction.Get = Get;
+    function GetRelevantList(api, stricter) {
+        if (stricter === void 0) { stricter = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, api.GET("pendingActions/important?Update=" + stricter, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, data.Items];
+                }
+            });
+        });
+    }
+    PendingAction.GetRelevantList = GetRelevantList;
+    function GetMessages(api, actionId, order, startIndex, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var args, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (amount == null) {
+                            amount = 500;
+                        }
+                        if (startIndex == null) {
+                            startIndex = 0;
+                        }
+                        if (order == null) {
+                            order = Api.ESortOrder.Asc;
+                        }
+                        args = "?SortOrder=" + (order == Api.ESortOrder.Desc ? "DESC" : "ASC") + "&PageSize=" + amount + "&PageIndex=" + startIndex;
+                        return [4 /*yield*/, api.GET("pendingAction/" + actionId + "/progressMessages" + args, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, data.Items];
+                }
+            });
+        });
+    }
+    PendingAction.GetMessages = GetMessages;
+})(PendingAction || (PendingAction = {}));
+
+var Style;
+(function (Style) {
+    function GetCacheKey(id) {
+        return Api.ECacheKey.Style + Api.ECacheKey.Id + id;
+    }
+    Style.GetCacheKey = GetCacheKey;
+    function GetListCacheKey() {
+        return Api.ECacheKey.Style;
+    }
+    Style.GetListCacheKey = GetListCacheKey;
+    var EType;
+    (function (EType) {
+        EType["Entity"] = "ENTITY";
+        EType["EntityRelationship"] = "ENTITY_RELATIONSHIP";
+    })(EType = Style.EType || (Style.EType = {}));
+    function GetList(api) {
+        var _this = this;
+        var cacheData = api.Cache.Get(GetListCacheKey());
+        if (cacheData) {
+            return cacheData;
+        }
+        var req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+            var data, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, api.GET("ui.entityDisplaySettings", Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        res(data.Items);
+                        return [3 /*break*/, 3];
+                    case 2:
+                        e_1 = _a.sent();
+                        rej(e_1);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); });
+        api.Cache.Set(GetListCacheKey(), req, Api.DEFAULT_CACHE_DURATION);
+        return req;
+    }
+    Style.GetList = GetList;
+    function Get(api, id) {
+        if (!id) {
+            throw ("Style ID is required.");
+        }
+        var cacheData = api.Cache.Get(GetCacheKey(id));
+        if (cacheData) {
+            return cacheData;
+        }
+        var req = api.GET("ui.entityDisplaySetting/" + id, Api.PrepReqParams());
+        api.Cache.Set(GetCacheKey(id), req, Api.DEFAULT_CACHE_DURATION);
+        return req;
+    }
+    Style.Get = Get;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.Name)) {
+                            throw ("Style name is required.");
+                        }
+                        if (!data.ID) {
+                            data.ID = 0;
+                        }
+                        return [4 /*yield*/, api.POST("ui.entityDisplaySetting/" + data.ID, data, Api.PrepReqParams())];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.Remove(GetCacheKey(data.ID));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    Style.Update = Update;
+    function Delete(api, id) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!id) {
+                            throw ("Style ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("ui.entityDisplaySetting/" + id, Api.PrepReqParams())];
+                    case 1:
+                        _a.sent();
+                        api.Cache.Remove(GetCacheKey(id));
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    Style.Delete = Delete;
+})(Style || (Style = {}));
+
+var TilesetEntitiesMapTiles;
+(function (TilesetEntitiesMapTiles) {
+    var ETileSize;
+    (function (ETileSize) {
+        ETileSize[ETileSize["IMG_256"] = 256] = "IMG_256";
+        ETileSize[ETileSize["IMG_512"] = 512] = "IMG_512";
+        ETileSize[ETileSize["IMG_1024"] = 1024] = "IMG_1024";
+        ETileSize[ETileSize["IMG_2048"] = 2048] = "IMG_2048";
+    })(ETileSize = TilesetEntitiesMapTiles.ETileSize || (TilesetEntitiesMapTiles.ETileSize = {}));
+})(TilesetEntitiesMapTiles || (TilesetEntitiesMapTiles = {}));
+
+var TilesetExtMapTiles;
+(function (TilesetExtMapTiles) {
+    var EType;
+    (function (EType) {
+        EType["TileMapImagery"] = "TileMapImagery";
+        EType["OpenStreetMapImagery"] = "OpenStreetMapImagery";
+        EType["MapBoxImagery"] = "MapBoxImagery";
+        EType["CesiumIon"] = "CesiumIon";
+    })(EType = TilesetExtMapTiles.EType || (TilesetExtMapTiles.EType = {}));
+})(TilesetExtMapTiles || (TilesetExtMapTiles = {}));
+
+var Ucs;
+(function (Ucs) {
+    function GetCacheKey(id, expandUsage) {
+        return Api.ECacheKey.Ucs + Api.ECacheKey.Id + id + Api.ECacheKey + expandUsage;
+    }
+    Ucs.GetCacheKey = GetCacheKey;
+    function GetListCacheKey() {
+        return Api.ECacheKey.Ucs;
+    }
+    Ucs.GetListCacheKey = GetListCacheKey;
+    var EState;
+    (function (EState) {
+        EState["Undefined"] = "undef";
+        EState["Prepared"] = "ready";
+    })(EState = Ucs.EState || (Ucs.EState = {}));
+    function Get(api, ucsId, expandUsage) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            return __generator(this, function (_a) {
+                if (!ucsId) {
+                    throw ("UCS ID is required.");
+                }
+                if (!expandUsage) {
+                    expandUsage = false;
+                }
+                cacheData = api.Cache.Get(GetCacheKey(ucsId, expandUsage));
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("ucs/" + ucsId);
+                api.Cache.Set(GetCacheKey(ucsId, expandUsage), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    Ucs.Get = Get;
+    function Delete(api, ucsId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!ucsId) {
+                            throw ("UCS ID is required.");
+                        }
+                        return [4 /*yield*/, api.DELETE("ucs/" + ucsId)];
+                    case 1:
+                        _a.sent();
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Ucs + Api.ECacheKey.Id + ucsId);
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    Ucs.Delete = Delete;
+    function GetList(api) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            return __generator(this, function (_a) {
+                cacheData = api.Cache.Get(GetListCacheKey());
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("ucs");
+                api.Cache.Set(GetListCacheKey(), req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    Ucs.GetList = GetList;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.name)) {
+                            throw ("UCS name is required.");
+                        }
+                        return [4 /*yield*/, api.post("ucs" + (!data.id ? "" : "/" + data.id), data)];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.RemoveByStartsWith(Api.ECacheKey.Ucs + Api.ECacheKey.Id + data.id);
+                        api.Cache.Remove(GetListCacheKey());
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    Ucs.Update = Update;
+})(Ucs || (Ucs = {}));
+
+var Permission;
+(function (Permission) {
+    var EPerm;
+    (function (EPerm) {
+        EPerm["ADMIN"] = "ADMIN";
+        EPerm["LOGIN"] = "LOGIN";
+        EPerm["DELETE_ENTITY_TYPE"] = "DELETE_ENTITY_TYPE";
+        EPerm["CREATE_ENTITY_TYPE"] = "CREATE_ENTITY_TYPE";
+        EPerm["UPDATE_ENTITY_TYPE"] = "UPDATE_ENTITY_TYPE";
+    })(EPerm = Permission.EPerm || (Permission.EPerm = {}));
+    var EPermPrefix;
+    (function (EPermPrefix) {
+        EPermPrefix["ACCESS_PROJECT_VIEW"] = "UIVIEW_";
+        EPermPrefix["MANAGE_PROJECT_VIEW_BOOKMARKS"] = "UIVIEW_MANAGE_BOOKMARKS_";
+        EPermPrefix["ACCESS_TILESET"] = "TILESET_";
+    })(EPermPrefix = Permission.EPermPrefix || (Permission.EPermPrefix = {}));
+})(Permission || (Permission = {}));
+
+var Session;
+(function (Session) {
+    function GetCacheKey(sessionId) {
+        return "" + Api.ECacheKey.Session + Api.ECacheKey.Id + sessionId;
+    }
+    function Get(api, sessionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var key, cacheData, req;
+            return __generator(this, function (_a) {
+                if (!sessionId) {
+                    throw ("Session ID is required.");
+                }
+                key = GetCacheKey(sessionId);
+                cacheData = api.Cache.Get(key);
+                if (cacheData) {
+                    return [2 /*return*/, cacheData];
+                }
+                req = api.GET("session/" + sessionId);
+                api.Cache.Set(key, req, Api.DEFAULT_CACHE_DURATION);
+                return [2 /*return*/, req];
+            });
+        });
+    }
+    Session.Get = Get;
+    function Login(api, username, password, accountId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, ssid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!username || !password) {
+                            throw ("Username and password are required.");
+                        }
+                        return [4 /*yield*/, api.POST("login", {
+                                account: accountId ? accountId : "",
+                                login: username,
+                                password: password
+                            })];
+                    case 1:
+                        data = _a.sent();
+                        ssid = data === null || data === void 0 ? void 0 : data.ID;
+                        api.SetSessionId(ssid);
+                        api.Cache.Remove(GetCacheKey(ssid));
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    Session.Login = Login;
+    function Logout(api) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ssid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ssid = api.GetSessionId();
+                        if (!ssid) return [3 /*break*/, 2];
+                        return [4 /*yield*/, api.POST("logout", null)];
+                    case 1:
+                        _a.sent();
+                        api.SetSessionId(null);
+                        api.Cache.Remove(GetCacheKey(ssid));
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    Session.Logout = Logout;
+    function IsPermEnabled(session, perm) {
+        var _a, _b;
+        if (!perm) {
+            throw ("Perm is required.");
+        }
+        perm = perm.toLocaleUpperCase();
+        var accessPerms = (_b = (_a = session.AccessPermissions) === null || _a === void 0 ? void 0 : _a.EnabledFeatures) !== null && _b !== void 0 ? _b : [];
+        return accessPerms.findIndex(function (x) { return x.toLocaleUpperCase() == perm; }) > -1;
+    }
+    Session.IsPermEnabled = IsPermEnabled;
+    function IsSuperPermEnabled(session, perm) {
+        var _a, _b;
+        if (!perm) {
+            throw ("Perm is required.");
+        }
+        perm = perm.toLocaleUpperCase();
+        var accessPerms = (_b = (_a = session.HypeportalAccessPermisssions) === null || _a === void 0 ? void 0 : _a.EnabledFeatures) !== null && _b !== void 0 ? _b : [];
+        return accessPerms.findIndex(function (x) { return x.toLocaleUpperCase() == perm; }) > -1;
+    }
+    Session.IsSuperPermEnabled = IsSuperPermEnabled;
+    function IsAccountAdmin(session) {
+        return IsPermEnabled(session, Permission.EPerm.ADMIN);
+    }
+    Session.IsAccountAdmin = IsAccountAdmin;
+    function IsSuperAdmin(session) {
+        return IsSuperPermEnabled(session, Permission.EPerm.ADMIN);
+    }
+    Session.IsSuperAdmin = IsSuperAdmin;
+})(Session || (Session = {}));
+
+var UserGroup;
+(function (UserGroup) {
+    function GetByName(api, accountId, name) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!name || !accountId) {
+                    throw ("Name and AccountID are required.");
+                }
+                return [2 /*return*/, api.GET("account/" + accountId + "/userGroupByName/" + name)];
+            });
+        });
+    }
+    UserGroup.GetByName = GetByName;
+    function GetUsers(api, accountId, id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!accountId || !id) {
+                            throw ("AccountID and ID are required.");
+                        }
+                        return [4 /*yield*/, api.GET("userGroup/" + accountId + "/" + id + "/users")];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, data.Items];
+                }
+            });
+        });
+    }
+    UserGroup.GetUsers = GetUsers;
+    function GetListByPerm(api, accountId, perm) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!accountId || !perm) {
+                            throw ("AccountID and Perm are required.");
+                        }
+                        return [4 /*yield*/, api.GET("userGroupsByFeature/" + accountId + "/" + perm)];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, data.Items];
+                }
+            });
+        });
+    }
+    UserGroup.GetListByPerm = GetListByPerm;
+    function GetList(api, accountId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!accountId) {
+                            throw ("AccountID is required.");
+                        }
+                        return [4 /*yield*/, api.GET("userGroups/" + accountId)];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, data.Items];
+                }
+            });
+        });
+    }
+    UserGroup.GetList = GetList;
+    function Delete(api, accountId, id) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!accountId || !id) {
+                    throw ("AccountID and ID are required.");
+                }
+                return [2 /*return*/, api.DELETE("account/" + accountId + "/userGroupID/" + id)];
+            });
+        });
+    }
+    UserGroup.Delete = Delete;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!data.Name || !data["ClientAccount.ID"]) {
+                            throw ("User group name and client account ID are required.");
+                        }
+                        return [4 /*yield*/, api.POST("userGroup" + (data.ID ? ("/" + data.ID) : ""), data)];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    UserGroup.Update = Update;
+})(UserGroup || (UserGroup = {}));
+
+var User;
+(function (User) {
+    function GetCacheKey(userId, accountId) {
+        return Api.ECacheKey.User + Api.ECacheKey.Id + userId + Api.ECacheKey.Id + accountId;
+    }
+    User.GetCacheKey = GetCacheKey;
+    var EType;
+    (function (EType) {
+        EType["User"] = "LOGIN_USER";
+        EType["AccessToken"] = "ACCESS_TOKEN";
+    })(EType = User.EType || (User.EType = {}));
+    function Get(api, id, accountId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cacheData, req;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!id) {
+                            throw ("ID is required.");
+                        }
+                        cacheData = api.Cache.Get(GetCacheKey(id, accountId));
+                        if (cacheData) {
+                            return [2 /*return*/, cacheData];
+                        }
+                        return [4 /*yield*/, api.GET("user/" + id)];
+                    case 1:
+                        req = _a.sent();
+                        api.Cache.Set(GetCacheKey(id, accountId), req, Api.DEFAULT_CACHE_DURATION);
+                        return [2 /*return*/, req];
+                }
+            });
+        });
+    }
+    User.Get = Get;
+    function Update(api, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(data === null || data === void 0 ? void 0 : data.ID) || !(data === null || data === void 0 ? void 0 : data.Type)) {
+                            throw ("ID and Type are required.");
+                        }
+                        return [4 /*yield*/, api.POST("user/" + data.ID, data)];
+                    case 1:
+                        data = _a.sent();
+                        api.Cache.RemoveByContains(Api.ECacheKey.User + Api.ECacheKey.Id + data.ID);
+                        if (data.Type == EType.AccessToken) {
+                            api.Cache.RemoveByStartsWith(Api.ECacheKey.AccessToken + Api.ECacheKey.Account);
+                        }
+                        else if (data.Type == EType.User) {
+                            api.Cache.RemoveByStartsWith(Api.ECacheKey.User + Api.ECacheKey.Account);
+                        }
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    User.Update = Update;
+    var LoginUser;
+    (function (LoginUser) {
+        function GetListCacheKey(accountId) {
+            return Api.ECacheKey.User + Api.ECacheKey.Account + Api.ECacheKey.Id + accountId;
+        }
+        LoginUser.GetListCacheKey = GetListCacheKey;
+        function GetList(api, accountId, exclusive) {
+            return __awaiter(this, void 0, void 0, function () {
+                var cacheData, req;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (!accountId) {
+                        throw ("Client account ID is required.");
+                    }
+                    if (!exclusive) {
+                        exclusive = false;
+                    }
+                    cacheData = exclusive ? null : api.Cache.Get(GetListCacheKey(accountId));
+                    if (cacheData) {
+                        return [2 /*return*/, cacheData];
+                    }
+                    req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                        var data, e_1;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    _a.trys.push([0, 2, , 3]);
+                                    return [4 /*yield*/, api.GET("users?clientAccountID=" + accountId + (exclusive ? "&allExcludingClientAccount=true" : ""))];
+                                case 1:
+                                    data = _a.sent();
+                                    res(data.Items);
+                                    return [3 /*break*/, 3];
+                                case 2:
+                                    e_1 = _a.sent();
+                                    rej(e_1);
+                                    return [3 /*break*/, 3];
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                    req.then(function (users) {
+                        for (var i = 0; i < users.length; i++) {
+                            api.Cache.Set(GetCacheKey(users[i].ID, accountId), users[i]);
+                        }
+                    });
+                    if (!exclusive) {
+                        api.Cache.Set(GetListCacheKey(accountId), req, Api.DEFAULT_CACHE_DURATION);
+                    }
+                    return [2 /*return*/, req];
+                });
+            });
+        }
+        LoginUser.GetList = GetList;
+    })(LoginUser = User.LoginUser || (User.LoginUser = {}));
+    var AccessToken;
+    (function (AccessToken) {
+        function GetListCacheKey(accountId) {
+            return Api.ECacheKey.AccessToken + Api.ECacheKey.Account + Api.ECacheKey.Id + accountId;
+        }
+        AccessToken.GetListCacheKey = GetListCacheKey;
+        function GetList(api, accountId) {
+            return __awaiter(this, void 0, void 0, function () {
+                var cacheData, req;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    cacheData = api.Cache.Get(GetListCacheKey(accountId));
+                    if (cacheData) {
+                        return [2 /*return*/, cacheData];
+                    }
+                    req = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+                        var data, e_2;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    _a.trys.push([0, 2, , 3]);
+                                    return [4 /*yield*/, api.GET("usersByClientAccount/accessTokens")];
+                                case 1:
+                                    data = _a.sent();
+                                    res(data.Items);
+                                    return [3 /*break*/, 3];
+                                case 2:
+                                    e_2 = _a.sent();
+                                    rej(e_2);
+                                    return [3 /*break*/, 3];
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                    req.then(function (users) {
+                        for (var i = 0; i < users.length; i++) {
+                            api.Cache.Set(GetCacheKey(users[i].ID, accountId), users[i]);
+                        }
+                    });
+                    api.Cache.Set(GetListCacheKey(accountId), req, Api.DEFAULT_CACHE_DURATION);
+                    return [2 /*return*/, req];
+                });
+            });
+        }
+        AccessToken.GetList = GetList;
+        function Delete(api, id) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, api.DELETE("accessToken/" + id)];
+                        case 1:
+                            _a.sent();
+                            api.Cache.RemoveByContains(Api.ECacheKey.User + Api.ECacheKey.Id + id);
+                            api.Cache.RemoveByStartsWith(Api.ECacheKey.AccessToken + Api.ECacheKey.Account);
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        AccessToken.Delete = Delete;
+        function Create(api, data) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!data) {
+                                data = {};
+                            }
+                            if (data.Type == EType.User) {
+                                throw ("User type is not allowed.");
+                            }
+                            if (!data.Type) {
+                                data.Type = EType.AccessToken;
+                            }
+                            return [4 /*yield*/, api.POST("accessToken", data)];
+                        case 1:
+                            data = _a.sent();
+                            api.Cache.RemoveByStartsWith(Api.ECacheKey.AccessToken + Api.ECacheKey.Account);
+                            return [2 /*return*/, data];
+                    }
+                });
+            });
+        }
+        AccessToken.Create = Create;
+    })(AccessToken = User.AccessToken || (User.AccessToken = {}));
+})(User || (User = {}));
+
+var EncryptUtils;
+(function (EncryptUtils) {
+    // https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript
+    function Cyrb53Hash(str, seed) {
+        if (seed === void 0) { seed = 0; }
+        var h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+        for (var i = 0, ch = void 0; i < str.length; i++) {
+            ch = str.charCodeAt(i);
+            h1 = Math.imul(h1 ^ ch, 2654435761);
+            h2 = Math.imul(h2 ^ ch, 1597334677);
+        }
+        h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+        h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+        return (4294967296 * (2097151 & h2) + (h1 >>> 0));
+    }
+    EncryptUtils.Cyrb53Hash = Cyrb53Hash;
+})(EncryptUtils || (EncryptUtils = {}));
+
+var MathUtils;
+(function (MathUtils) {
+    function Round(num, decimals) {
+        if (decimals === void 0) { decimals = 0; }
+        if (decimals <= 0) {
+            return Math.round(num);
+        }
+        var tmp = "1";
+        for (var i = 0; i < decimals; i++) {
+            tmp += "0";
+        }
+        var d = parseFloat(tmp);
+        return Math.round((num + Number.EPSILON) * d) / d;
+    }
+    MathUtils.Round = Round;
+    function RandInt(min, max) {
+        if (min == max) {
+            return min;
+        }
+        else if (min > max) {
+            throw ("Min is greater than max.");
+        }
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    MathUtils.RandInt = RandInt;
+})(MathUtils || (MathUtils = {}));
+
+export { AnnDocument, AbstractApi, Api, BruceApi, CamApi, IdmApi, Calculator, BruceEvent, CacheControl, Camera, Cartes, Carto, Color, DelayQueue, Geometry, UTC, EntityAttachmentType, EntityAttachment, EntityComment, EntityLink, EntityLod, EntityRelationType, EntityRelation, EntitySource, EntityTag, EntityType, Entity, EntityGlobe, EntityFilterGetter, EntityLoadedGetter, ClientFile, ProgramKey, MenuItemZoomControl, MenuItem, ProjectViewBookmark, ProjectView, PendingAction, Style, TilesetEntitiesMapTiles, TilesetExtMapTiles, Tileset, Ucs, Permission, Session, UserGroup, User, EncryptUtils, MathUtils, ObjectUtils, PathUtils };
+//# sourceMappingURL=bruce-models.es5.js.map