bruce-models 4.1.5 → 4.1.6

package/dist/bruce-models.umd.js

@@ -84,6 +84,7 @@
             ECacheKey["EntityHistoricData"] = "entityhistoricdata";
             ECacheKey["EntityHistoricDataRec"] = "entityhistoricdatarec";
             ECacheKey["EntityHistoricDataStats"] = "entityhistoricdatastats";
+            ECacheKey["AccountLimits"] = "accountlimits";
         })(ECacheKey = Api.ECacheKey || (Api.ECacheKey = {}));
         // 1 minute.
         Api.DEFAULT_CACHE_DURATION = 60 * 1000;
@@ -1994,9 +1995,6 @@
             if (ENVIRONMENT.IS_SELF_MANAGED) {
                 throw ("Self managed mode ON. You are getting this error because you didn't pass an Api instance to a function.");
             }
-            if (!ENVIRONMENT.PARAMS.accountId) {
-                console.warn("No accountId set. This is required for the getters to work properly.");
-            }
             if (!_getters) {
                 _getters = new ApiGetters({
                     accountId: ENVIRONMENT.PARAMS.accountId,
@@ -2941,7 +2939,7 @@
          * @returns
          */
         function Parse(str) {
-            if (!str) {
+            if (!(str === null || str === void 0 ? void 0 : str.length)) {
                 return [];
             }
             const broken = str.split("\"/\"");
@@ -2971,6 +2969,9 @@
          * @returns
          */
         function Wrap(path) {
+            if (!(path === null || path === void 0 ? void 0 : path.length)) {
+                return "";
+            }
             let tmp = "\"";
             for (let i = 0; i < path.length; i++) {
                 let section = path[i];
@@ -2989,6 +2990,9 @@
          * @returns
          */
         function ParseLegacy(str) {
+            if (!(str === null || str === void 0 ? void 0 : str.length)) {
+                return [];
+            }
             const broken = str.split(".");
             for (let i = 0; i < broken.length; i++) {
                 let piece = broken[0];
@@ -4860,22 +4864,123 @@
             EMonth[EMonth["November"] = 11] = "November";
             EMonth[EMonth["December"] = 12] = "December";
         })(EMonth = UTC.EMonth || (UTC.EMonth = {}));
+        /**
+         * Returns an ISO 8601 string representation of the provided date.
+         * @param utc
+         */
+        function ToString(utc) {
+            return ToDate(utc).toISOString();
+        }
+        UTC.ToString = ToString;
         function ToDate(utc) {
-            return new Date(utc.y, utc.m - 1, utc.d, utc.hh, utc.mm, utc.ss, 0);
+            return new Date(Date.UTC(utc.y, utc.m - 1, utc.d, utc.hh, utc.mm, utc.ss, 0));
         }
         UTC.ToDate = ToDate;
-        function FromDate(date) {
+        function FromDate(utc) {
             return {
-                y: date.getUTCFullYear(),
-                m: date.getUTCMonth() + 1,
-                d: date.getUTCDate(),
-                hh: date.getUTCHours(),
-                mm: date.getUTCMinutes(),
-                ss: date.getUTCSeconds()
+                y: utc.getUTCFullYear(),
+                m: utc.getUTCMonth() + 1,
+                d: utc.getUTCDate(),
+                hh: utc.getUTCHours(),
+                mm: utc.getUTCMinutes(),
+                ss: utc.getUTCSeconds()
             };
         }
         UTC.FromDate = FromDate;
+        /**
+         * Returns how many seconds have passed between two dates.
+         * If the second date is not provided, it will be the current date.
+         * @param from
+         * @param to
+         * @returns
+         */
+        function GetPassedSeconds(from, to) {
+            if (!to) {
+                to = FromDate(new Date());
+            }
+            const fromTime = ToDate(from).getTime();
+            const toTime = ToDate(to).getTime();
+            return Math.floor((toTime - fromTime) / 1000);
+        }
+        UTC.GetPassedSeconds = GetPassedSeconds;
+        /**
+         * Returns a human-readable string that describes how much time has passed since the provided date.
+         * @param utc
+         */
+        function GetPassedTime(utc) {
+            const passedSeconds = GetPassedSeconds(utc);
+            if (passedSeconds < 60) {
+                return `${passedSeconds} second${passedSeconds > 1 ? "s" : ""} ago`;
+            }
+            const passedMinutes = Math.floor(passedSeconds / 60);
+            if (passedMinutes < 60) {
+                return `${passedMinutes} minute${passedMinutes > 1 ? "s" : ""} ago`;
+            }
+            const passedHours = Math.floor(passedMinutes / 60);
+            if (passedHours < 24) {
+                return `${passedHours} hour${passedHours > 1 ? "s" : ""} ago`;
+            }
+            const passedDays = Math.floor(passedHours / 24);
+            if (passedDays < 30) {
+                return `${passedDays} day${passedDays > 1 ? "s" : ""} ago`;
+            }
+            const passedMonths = Math.floor(passedDays / 30);
+            if (passedMonths < 12) {
+                return `${passedMonths} month${passedMonths > 1 ? "s" : ""} ago`;
+            }
+            const passedYears = Math.floor(passedMonths / 12);
+            return `${passedYears} year${passedYears > 1 ? "s" : ""} ago`;
+        }
+        UTC.GetPassedTime = GetPassedTime;
+        /**
+         * Returns a human-readable string that describes the provided date.
+         * If a timezone is not provided then it will use the locale timezone.
+         * @param utc
+         * @param timezone
+         */
+        function GetDateTime(utc, timezone) {
+            const date = ToDate(utc);
+            // Possibly could just pass the timezone and it might get ignored if missing.
+            if (timezone) {
+                return date.toLocaleString("en-US", {
+                    timeZone: timezone,
+                    hour12: true,
+                    hour: "numeric",
+                    minute: "numeric",
+                    year: "2-digit",
+                    month: "2-digit",
+                    day: "2-digit"
+                }) + " " + getTimezoneName(timezone);
+            }
+            return date.toLocaleString(undefined, {
+                hour12: true,
+                hour: "numeric",
+                minute: "numeric",
+                year: "2-digit",
+                month: "2-digit",
+                day: "2-digit"
+            });
+        }
+        UTC.GetDateTime = GetDateTime;
     })(exports.UTC || (exports.UTC = {}));
+    // Found here https://stackoverflow.com/questions/9772955/how-can-i-get-the-timezone-name-in-javascript
+    // Formats a given timezone into a human readable format.
+    function getTimezoneName(timezone) {
+        const today = new Date();
+        const short = today.toLocaleDateString(undefined, { timeZone: timezone });
+        const full = today.toLocaleDateString(undefined, { timeZoneName: "long", timeZone: timezone });
+        // Trying to remove date from the string in a locale-agnostic way
+        const shortIndex = full.indexOf(short);
+        if (shortIndex >= 0) {
+            const trimmed = full.substring(0, shortIndex) + full.substring(shortIndex + short.length);
+            // by this time `trimmed` should be the timezone's name with some punctuation -
+            // trim it from both sides
+            return trimmed.replace(/^[\s,.\-:;]+|[\s,.\-:;]+$/g, "");
+        }
+        // in some magic case when short representation of date is not present in the long one, 
+        // just return the long one as a fallback, since it should contain the timezone's name
+        return full;
+    }
 
     /**
      * A simple LRU cache implementation.
@@ -6894,7 +6999,7 @@
          * @param path
          */
         function RemoveAttribute(items, path) {
-            if (!items || !path || !path.length) {
+            if (!items || !(path === null || path === void 0 ? void 0 : path.length)) {
                 return;
             }
             const key = path[0];
@@ -6923,6 +7028,9 @@
          * @param attribute
          */
         function AddAttribute(items, path, attribute) {
+            if (!items || !(path === null || path === void 0 ? void 0 : path.length)) {
+                return;
+            }
             const key = path[0];
             if (path.length === 1) {
                 // If we're at the last key in the path, add the attribute to the items array.
@@ -6951,150 +7059,87 @@
         EntityAttribute.AddAttribute = AddAttribute;
     })(exports.EntityAttribute || (exports.EntityAttribute = {}));
 
-    (function (Uploader) {
-        Uploader.MIN_LARGE_FILE_SIZE = 100000000; // 100MB.
+    (function (Style) {
         /**
-         * Uploads a file to the server.
+         * Types of styles available.
+         * The type will dictate what settings are available.
+         */
+        let EType;
+        (function (EType) {
+            EType["Entity"] = "ENTITY";
+            EType["EntityRelationship"] = "ENTITY_RELATIONSHIP";
+        })(EType = Style.EType || (Style.EType = {}));
+        /**
+         * Available types of points.
+         * Default is POINT.
+         */
+        let EPointType;
+        (function (EPointType) {
+            // Render a sphere with a fixed pixel size.
+            EPointType["Point"] = "POINT";
+            // Render an icon.
+            EPointType["Icon"] = "ICON";
+            // Render a cylinder with a fixed meter size.
+            EPointType["Cylinder"] = "CYLINDER";
+        })(EPointType = Style.EPointType || (Style.EPointType = {}));
+        /**
+         * Returns a list of styles.
          * @param params
          * @returns
          */
-        function DoMultiPartUpload(params) {
+        function GetList(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { file, api, urlSuffix: url, req, onProgress } = params;
+                let { api, req: reqParams } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                const FILE_PORTION_SIZE = 100000000; // 100MB.
-                let fileSize = file.size;
-                let fileOffset = 0;
-                let filePartsCount = fileSize / FILE_PORTION_SIZE;
-                let t = Math.trunc(filePartsCount);
-                filePartsCount = filePartsCount > t ? t + 1 : t;
-                let filePartIndex = 1;
-                let uploadToken = exports.ObjectUtils.UId();
-                let data;
-                while (fileOffset < fileSize) {
-                    let partSize = Math.min(FILE_PORTION_SIZE, fileSize - fileOffset);
-                    let retryCount = 5;
-                    let retryWait = 1000;
-                    while (retryCount > 0) {
-                        try {
-                            const blob = file.slice(fileOffset, fileOffset + partSize);
-                            const partialFile = new File([blob], file.name, { type: file.type });
-                            const formData = new FormData();
-                            formData.append("originalFileName", file.name);
-                            formData.append("token", uploadToken);
-                            formData.append("count", "" + filePartsCount);
-                            formData.append("part", "" + filePartIndex);
-                            formData.append("file", partialFile);
-                            const reqParams = exports.Api.PrepReqParams(req);
-                            reqParams.formData = formData;
-                            reqParams.onProgress = (progress) => {
-                                const sofar = fileOffset + progress.loaded;
-                                const percent = Math.round((sofar / file.size) * 100);
-                                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
-                                    percent: percent,
-                                    uploaded: false
-                                });
-                            };
-                            data = yield api.UPLOAD(url, partialFile, reqParams);
-                            retryCount = 0;
-                        }
-                        catch (up) {
-                            retryCount -= 1;
-                            if (retryCount <= 0) {
-                                throw up;
-                            }
-                            yield new Promise((res) => setTimeout(res, retryWait));
-                            retryWait = retryWait * 2;
-                        }
-                    }
-                    fileOffset += partSize;
-                    filePartIndex++;
+                const cache = yield api.GetCacheItem(GetListCacheKey(), reqParams);
+                if (cache === null || cache === void 0 ? void 0 : cache.found) {
+                    return cache.data;
                 }
-                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
-                    percent: 100,
-                    uploaded: true
+                const res = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield api.GET("ui.entityDisplaySettings", exports.Api.PrepReqParams(reqParams));
+                        res({
+                            styles: data.Items
+                        });
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                }));
+                yield api.SetCacheItem({
+                    key: GetListCacheKey(),
+                    value: res,
+                    req: reqParams
                 });
-                return data;
+                return res;
             });
         }
-        Uploader.DoMultiPartUpload = DoMultiPartUpload;
-    })(exports.Uploader || (exports.Uploader = {}));
-
-    (function (ClientFile) {
-        let EPurpose;
-        (function (EPurpose) {
-            // Use this purpose for uploading bookmark thumbnail images.
-            // This will allow lower level privileges to upload (small) bookmark thumbnails.
-            EPurpose["BookmarkThumbnail"] = "Bookmark Thumbnail";
-        })(EPurpose = ClientFile.EPurpose || (ClientFile.EPurpose = {}));
-        /**
-         * Returns the URL for a client file.
-         * @param params
-         * @returns
-         */
-        function GetUrl(params) {
-            let { api, fileId, viaCdn } = params;
-            if (!api) {
-                api = exports.ENVIRONMENT.Api().GetBruceApi();
-            }
-            const urlSuffix = `file/${fileId}`;
-            const cdnUrl = viaCdn ? api.ConstructCdnUrl(urlSuffix) : null;
-            if (cdnUrl) {
-                return cdnUrl;
-            }
-            let url = `${api.GetBaseUrl()}${urlSuffix}`;
-            // Invalidating cache manually because we have a wave of invalid headers now cached across devices.
-            url = exports.UrlUtils.AddQueryParam(url, "cc", "1");
-            return url;
-        }
-        ClientFile.GetUrl = GetUrl;
-        /**
-         * Returns the URL for a client file with the extension.
-         * @param params
-         * @returns
-         */
-        function GetUrlWithExt(params) {
-            let { api, file, viaCdn } = params;
-            if (!api) {
-                api = exports.ENVIRONMENT.Api().GetBruceApi();
-            }
-            const urlSuffix = file.FileExt ? `file/${file.ID}${file.FileExt}` : `file/${file.ID}`;
-            const cdnUrl = viaCdn ? api.ConstructCdnUrl(urlSuffix) : null;
-            if (cdnUrl) {
-                return cdnUrl;
-            }
-            let url = `${api.GetBaseUrl()}${urlSuffix}`;
-            // Invalidating cache manually because we have a wave of invalid headers now cached across devices.
-            url = exports.UrlUtils.AddQueryParam(url, "cc", "1");
-            return url;
-        }
-        ClientFile.GetUrlWithExt = GetUrlWithExt;
+        Style.GetList = GetList;
         /**
-         * Returns a client file record by ID.
+         * Returns a style.
          * @param params
          * @returns
          */
         function Get(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, fileId, req: reqParams } = params;
+                let { api, styleId: id, req: reqParams } = params;
+                if (!id) {
+                    throw ("Style ID is required.");
+                }
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                if (!fileId) {
-                    throw ("File ID is required.");
-                }
-                const key = GetCacheKey(fileId);
-                const cache = yield api.GetCacheItem(key, reqParams);
+                const cache = yield api.GetCacheItem(GetCacheKey(id), reqParams);
                 if (cache === null || cache === void 0 ? void 0 : cache.found) {
                     return cache.data;
                 }
                 const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
                     try {
-                        const data = yield api.GET(`file/${fileId}/details`, exports.Api.PrepReqParams(reqParams));
+                        const data = yield api.GET(`ui.entityDisplaySetting/${id}`, exports.Api.PrepReqParams(reqParams));
                         res({
-                            clientFile: data
+                            style: data
                         });
                     }
                     catch (e) {
@@ -7102,64 +7147,750 @@
                     }
                 }));
                 yield api.SetCacheItem({
-                    key,
+                    key: GetCacheKey(id),
                     value: prom,
                     req: reqParams
                 });
                 return prom;
             });
         }
-        ClientFile.Get = Get;
+        Style.Get = Get;
         /**
-         * Deletes one or many client file records by IDs.
+         * Creates or updates a style.
          * @param params
+         * @returns
          */
-        function Delete(params) {
+        function Update(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, fileIds, req: reqParams } = params;
-                if (!fileIds.length) {
-                    return Promise.resolve();
+                let { api, style: data, req: reqParams } = params;
+                if (!(data === null || data === void 0 ? void 0 : data.Name)) {
+                    throw ("Style name is required.");
                 }
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                const data = {
-                    Items: fileIds
-                };
-                yield api.POST("deleteFiles", data, exports.Api.PrepReqParams(reqParams));
-                for (let i = 0; i < fileIds.length; i++) {
-                    const key = GetCacheKey(fileIds[i]);
-                    api.Cache.Remove(key);
+                if (!data.ID) {
+                    data.ID = 0;
                 }
+                const res = yield api.POST(`ui.entityDisplaySetting/${data.ID}`, data, exports.Api.PrepReqParams(reqParams));
+                api.Cache.Remove(GetCacheKey(data.ID));
+                api.Cache.Remove(GetListCacheKey());
+                return {
+                    style: res
+                };
             });
         }
-        ClientFile.Delete = Delete;
+        Style.Update = Update;
         /**
-         * Uploads a file and creates a new client file record.
+         * Deletes a style.
          * @param params
-         * @returns
          */
-        function Upload(params) {
+        function Delete(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, file, purpose, req, onProgress } = params;
+                let { api, styleId: id, req: reqParams } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                if (!file) {
-                    throw ("File is required.");
-                }
-                const size = file === null || file === void 0 ? void 0 : file.size;
-                if (!size) {
-                    throw ("You cannot upload a 0byte sized file.");
+                if (!id) {
+                    throw ("Style ID is required.");
                 }
-                req = exports.Api.PrepReqParams(req);
-                let clientFile;
-                if (size > exports.Uploader.MIN_LARGE_FILE_SIZE) {
-                    clientFile = yield exports.Uploader.DoMultiPartUpload({
-                        api,
-                        file,
-                        urlSuffix: "fileUpload",
-                        req,
+                yield api.DELETE(`ui.entityDisplaySetting/${id}`, exports.Api.PrepReqParams(reqParams));
+                api.Cache.Remove(GetCacheKey(id));
+                api.Cache.Remove(GetListCacheKey());
+            });
+        }
+        Style.Delete = Delete;
+        /**
+         * Returns cache identifier for a style.
+         * Example: {
+         *     const api: BruceApi.Api = ...;
+         *     const key = GetCacheKey(1);
+         *     api.Cache.Remove(key);
+         * }
+         * @param id
+         * @returns
+         */
+        function GetCacheKey(id) {
+            return exports.Api.ECacheKey.Style + exports.Api.ECacheKey.Id + id;
+        }
+        Style.GetCacheKey = GetCacheKey;
+        /**
+         * Returns cache identifier for a list of styles.
+         * Example: {
+         *     const api: BruceApi.Api = ...;
+         *     const key = GetListCacheKey();
+         *     api.Cache.Remove(key);
+         * }
+         * @returns
+         */
+        function GetListCacheKey() {
+            return exports.Api.ECacheKey.Style;
+        }
+        Style.GetListCacheKey = GetListCacheKey;
+    })(exports.Style || (exports.Style = {}));
+
+    (function (Comment) {
+        // Entity Type used for storing comment records.
+        Comment.ENTITY_TYPE_ID = "COMMENTS";
+        // Relationship Type ID for linking relies to comments.
+        Comment.REPLY_RELATIONSHIP_TYPE_ID = "COMMENTS_REPLY";
+        // Possible kinds of comments.
+        let EType;
+        (function (EType) {
+            EType["Comment"] = "COMMENT";
+            EType["Reply"] = "REPLY";
+        })(EType = Comment.EType || (Comment.EType = {}));
+        /**
+         * Returns a list of comments based on the provided filter.
+         * @param params
+         * @returns
+         */
+        function GetList(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, req, filter } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                req = exports.Api.PrepReqParams(req);
+                if (!(yield getEntityTypeExists(api, req))) {
+                    return {
+                        comments: []
+                    };
+                }
+                const reqFilter = {};
+                if (filter.viewId) {
+                    reqFilter["viewId"] = {
+                        "equals": filter.viewId
+                    };
+                }
+                if (filter.userId) {
+                    reqFilter["CreatedBy.User.ID"] = {
+                        "equals": filter.userId
+                    };
+                }
+                if (filter.text) {
+                    reqFilter["text"] = {
+                        "contains": filter.text
+                    };
+                }
+                if (filter.entityId) {
+                    reqFilter["entityId"] = {
+                        "equals": filter.entityId
+                    };
+                }
+                const records = (yield exports.Entity.GetList({
+                    api,
+                    req,
+                    filter: {
+                        entityTypeId: Comment.ENTITY_TYPE_ID,
+                        pageSize: filter.amount == null ? 20 : filter.amount,
+                        pageIndex: filter.index == null ? 0 : filter.index,
+                        entityTypeConditions: reqFilter,
+                        orderBy: "lastUpdateTime"
+                    }
+                })).entities;
+                return {
+                    comments: records
+                };
+            });
+        }
+        Comment.GetList = GetList;
+        /**
+         * Ensure the Entity Type exists.
+         * If it does not exist, it will be created.
+         * @param params
+         */
+        function AssertEntityType(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                req = exports.Api.PrepReqParams(req);
+                // If the Entity Type does not exist, create it.
+                if (!(yield getEntityTypeExists(api, req))) {
+                    // Create Style and set it to the Entity Type.
+                    const styleId = yield ensureStyleExists(api);
+                    const template = JSON.parse(JSON.stringify(ENTITY_TYPE_TEMPLATE));
+                    template["DisplaySetting.ID"] = styleId;
+                    yield exports.EntityType.Update({
+                        api,
+                        entityType: template
+                    });
+                }
+            });
+        }
+        Comment.AssertEntityType = AssertEntityType;
+        /**
+         * Ensure the Relation Type exists.
+         * If it does not exist, it will be created.
+         * @param params
+         */
+        function AssertRelationType(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                req = exports.Api.PrepReqParams(req);
+                yield ensureRelationExists(api, req);
+            });
+        }
+        Comment.AssertRelationType = AssertRelationType;
+    })(exports.Comment || (exports.Comment = {}));
+    function getEntityTypeExists(api, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { entityType: data } = yield exports.EntityType.Get({
+                    api,
+                    req: req,
+                    entityTypeId: exports.Comment.ENTITY_TYPE_ID
+                });
+                return !!data;
+            }
+            catch (e) {
+                // TODO: suppress if the error is related to not being found.
+                console.error(e);
+            }
+            return false;
+        });
+    }
+    function ensureStyleExists(api, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const template = JSON.parse(JSON.stringify(STYLE_SETTINGS_TEMPLATE));
+                const { style } = yield exports.Style.Update({
+                    api,
+                    req: req,
+                    style: {
+                        Name: "Comment Style",
+                        Settings: template,
+                        Type: exports.Style.EType.Entity,
+                        ID: 0
+                    }
+                });
+                return style.ID;
+            }
+            catch (e) {
+                console.error(e);
+            }
+            return 0;
+        });
+    }
+    function ensureRelationExists(api, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { relationType: data } = yield exports.EntityRelationType.Get({
+                    api,
+                    req: req,
+                    relationTypeId: exports.Comment.REPLY_RELATIONSHIP_TYPE_ID
+                });
+                if (!data) {
+                    throw ("Relation Type not found");
+                }
+            }
+            catch (e) {
+                yield exports.EntityRelationType.Update({
+                    api,
+                    req: req,
+                    relationType: {
+                        ID: exports.Comment.REPLY_RELATIONSHIP_TYPE_ID,
+                        ForwardName: "Parent of",
+                        ReverseName: "Reply to",
+                        Name: "Comment Reply"
+                    }
+                });
+            }
+        });
+    }
+    const STYLE_SETTINGS_TEMPLATE = {
+        pointStyle: {
+            "color": [
+                {
+                    "type": 0,
+                    "value": "rgba(33,150,243,0.8)"
+                }
+            ],
+            "CylinderBorderEnabled": false,
+            "CylinderBorderWidth": [
+                {
+                    "type": 1,
+                    "value": "15"
+                }
+            ],
+            "CylinderFillExtrusion": [
+                {
+                    "type": 1,
+                    "value": "40"
+                }
+            ],
+            "Type": exports.Style.EPointType.Icon,
+            "iconId": null,
+            "altitudeOption": {
+                "name": "Absolute position",
+                "id": 1
+            },
+            "size": [
+                {
+                    "type": 1,
+                    "value": "20"
+                }
+            ],
+            "CylinderFillColor": [
+                {
+                    "type": 1,
+                    "value": "rgba(33,150,243,0.8)"
+                }
+            ],
+            "CylinderBorderExtrusion": [
+                {
+                    "type": 1,
+                    "value": "35"
+                }
+            ],
+            "CylinderRadius": [
+                {
+                    "type": 1,
+                    "value": "20"
+                }
+            ],
+            "iconUrl": [
+                {
+                    "type": 1,
+                    "value": "https://template.api.nextspace-uat.net/file/faf2194d-3a95-40cc-a6b3-6a7aa223f766.png"
+                }
+            ],
+            "ClusterNearbyEntities": false,
+            "CylinderBorderColor": [
+                {
+                    "type": 1,
+                    "value": "rgba(33,150,243,0.8)"
+                }
+            ],
+            "iconScale": [
+                {
+                    "type": 1,
+                    "value": 1
+                }
+            ],
+            "MinimumEntitiesCountForClustering": [
+                {
+                    "type": 1,
+                    "value": "2"
+                }
+            ]
+        }
+    };
+    const ENTITY_TYPE_TEMPLATE = {
+        ID: exports.Comment.ENTITY_TYPE_ID,
+        Name: "Comments",
+        DataSchema: {
+            "Key": "root",
+            "Name": "Root",
+            "Type": exports.EntityAttribute.EType.Structure,
+            Structure: [
+                {
+                    "IsIndexed": true,
+                    "IsImportant": false,
+                    "Type": exports.EntityAttribute.EType.String,
+                    "IsArray": false,
+                    "Size": 40,
+                    "Key": "ID",
+                    "Name": "Identity",
+                    "IsFamilyAttribute": false,
+                    "IsFamilyAttributeDefault": false
+                },
+                {
+                    "IsIndexed": false,
+                    "IsImportant": false,
+                    "Type": exports.EntityAttribute.EType.Geometry,
+                    "IsArray": false,
+                    "Size": 0,
+                    "Key": "geometry",
+                    "Name": "Geometry",
+                    "IsFamilyAttribute": false,
+                    "IsFamilyAttributeDefault": false
+                },
+                {
+                    "IsImportant": false,
+                    "Type": exports.EntityAttribute.EType.Structure,
+                    "IsArray": false,
+                    "Structure": [
+                        {
+                            "IsIndexed": true,
+                            "IsImportant": false,
+                            "Type": exports.EntityAttribute.EType.Double,
+                            "IsArray": false,
+                            "Key": "minLongitude",
+                            "Name": "Min Longitude",
+                            "IsFamilyAttribute": false,
+                            "IsFamilyAttributeDefault": false
+                        },
+                        {
+                            "IsIndexed": true,
+                            "IsImportant": false,
+                            "Type": exports.EntityAttribute.EType.Double,
+                            "IsArray": false,
+                            "Key": "minLatitude",
+                            "Name": "Min Latitude",
+                            "IsFamilyAttribute": false,
+                            "IsFamilyAttributeDefault": false
+                        },
+                        {
+                            "IsIndexed": true,
+                            "IsImportant": false,
+                            "Type": exports.EntityAttribute.EType.Double,
+                            "IsArray": false,
+                            "Size": 0,
+                            "Key": "minAltitude",
+                            "Name": "Min Altitude",
+                            "IsFamilyAttribute": false,
+                            "IsFamilyAttributeDefault": false
+                        },
+                        {
+                            "IsIndexed": true,
+                            "IsImportant": false,
+                            "Type": exports.EntityAttribute.EType.Double,
+                            "IsArray": false,
+                            "Key": "maxLongitude",
+                            "Name": "Max Longitude",
+                            "IsFamilyAttribute": false,
+                            "IsFamilyAttributeDefault": false
+                        },
+                        {
+                            "IsIndexed": true,
+                            "IsImportant": false,
+                            "Type": exports.EntityAttribute.EType.Double,
+                            "IsArray": false,
+                            "Key": "maxLatitude",
+                            "Name": "Max Latitude",
+                            "IsFamilyAttribute": false,
+                            "IsFamilyAttributeDefault": false
+                        },
+                        {
+                            "IsIndexed": true,
+                            "IsImportant": false,
+                            "Type": exports.EntityAttribute.EType.Double,
+                            "IsArray": false,
+                            "Size": 0,
+                            "Key": "maxAltitude",
+                            "Name": "Max Altitude",
+                            "IsFamilyAttribute": false,
+                            "IsFamilyAttributeDefault": false
+                        }
+                    ],
+                    "Key": "boundaries",
+                    "Name": "Boundaries",
+                    "IsFamilyAttribute": false,
+                    "IsFamilyAttributeDefault": false
+                },
+                {
+                    "IsImportant": false,
+                    "Type": exports.EntityAttribute.EType.Structure,
+                    "IsArray": false,
+                    "Structure": [
+                        {
+                            "IsIndexed": true,
+                            "IsImportant": false,
+                            "Type": exports.EntityAttribute.EType.Double,
+                            "IsArray": false,
+                            "Key": "latitude",
+                            "Name": "Latitude",
+                            "IsFamilyAttribute": false,
+                            "IsFamilyAttributeDefault": false
+                        },
+                        {
+                            "IsIndexed": true,
+                            "IsImportant": false,
+                            "Type": exports.EntityAttribute.EType.Double,
+                            "IsArray": false,
+                            "Key": "longitude",
+                            "Name": "Longitude",
+                            "IsFamilyAttribute": false,
+                            "IsFamilyAttributeDefault": false
+                        },
+                        {
+                            "IsIndexed": true,
+                            "IsImportant": false,
+                            "Type": exports.EntityAttribute.EType.Double,
+                            "IsArray": false,
+                            "Key": "altitude",
+                            "Name": "Altitude",
+                            "IsFamilyAttribute": false,
+                            "IsFamilyAttributeDefault": false
+                        }
+                    ],
+                    "Key": "location",
+                    "Name": "Location",
+                    "IsFamilyAttribute": false,
+                    "IsFamilyAttributeDefault": false
+                },
+                {
+                    "IsIndexed": true,
+                    "IsImportant": true,
+                    "Type": exports.EntityAttribute.EType.String,
+                    "IsArray": false,
+                    "Size": 60,
+                    "Key": "viewId",
+                    "Name": "View Id",
+                    "IsFamilyAttribute": false,
+                    "IsFamilyAttributeDefault": false
+                },
+                {
+                    "IsIndexed": true,
+                    "IsImportant": true,
+                    "Type": exports.EntityAttribute.EType.String,
+                    "IsArray": false,
+                    "Size": 60,
+                    "Key": "bookmarkId",
+                    "Name": "Bookmark Id",
+                    "IsFamilyAttribute": false,
+                    "IsFamilyAttributeDefault": false
+                },
+                {
+                    "IsIndexed": true,
+                    "IsImportant": true,
+                    "Type": exports.EntityAttribute.EType.String,
+                    "IsArray": false,
+                    "Key": "text",
+                    "Name": "Comment",
+                    "IsFamilyAttribute": false,
+                    "IsFamilyAttributeDefault": false
+                },
+                {
+                    "IsIndexed": true,
+                    "IsImportant": true,
+                    "Type": exports.EntityAttribute.EType.Datetime,
+                    "IsArray": false,
+                    "Key": "lastUpdateTime",
+                    "Name": "Last Update Time",
+                    "IsFamilyAttribute": false,
+                    "IsFamilyAttributeDefault": false
+                },
+                {
+                    "IsIndexed": true,
+                    "IsImportant": true,
+                    "Type": exports.EntityAttribute.EType.String,
+                    "IsArray": false,
+                    "Key": "entityId",
+                    "Name": "Related Entity ID",
+                    "IsFamilyAttribute": false,
+                    "IsFamilyAttributeDefault": false
+                }
+            ]
+        },
+        "DisplaySetting.ID": 0
+    };
+
+    (function (Uploader) {
+        Uploader.MIN_LARGE_FILE_SIZE = 100000000; // 100MB.
+        /**
+         * Uploads a file to the server.
+         * @param params
+         * @returns
+         */
+        function DoMultiPartUpload(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { file, api, urlSuffix: url, req, onProgress } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                const FILE_PORTION_SIZE = 100000000; // 100MB.
+                let fileSize = file.size;
+                let fileOffset = 0;
+                let filePartsCount = fileSize / FILE_PORTION_SIZE;
+                let t = Math.trunc(filePartsCount);
+                filePartsCount = filePartsCount > t ? t + 1 : t;
+                let filePartIndex = 1;
+                let uploadToken = exports.ObjectUtils.UId();
+                let data;
+                while (fileOffset < fileSize) {
+                    let partSize = Math.min(FILE_PORTION_SIZE, fileSize - fileOffset);
+                    let retryCount = 5;
+                    let retryWait = 1000;
+                    while (retryCount > 0) {
+                        try {
+                            const blob = file.slice(fileOffset, fileOffset + partSize);
+                            const partialFile = new File([blob], file.name, { type: file.type });
+                            const formData = new FormData();
+                            formData.append("originalFileName", file.name);
+                            formData.append("token", uploadToken);
+                            formData.append("count", "" + filePartsCount);
+                            formData.append("part", "" + filePartIndex);
+                            formData.append("file", partialFile);
+                            const reqParams = exports.Api.PrepReqParams(req);
+                            reqParams.formData = formData;
+                            reqParams.onProgress = (progress) => {
+                                const sofar = fileOffset + progress.loaded;
+                                const percent = Math.round((sofar / file.size) * 100);
+                                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                                    percent: percent,
+                                    uploaded: false
+                                });
+                            };
+                            data = yield api.UPLOAD(url, partialFile, reqParams);
+                            retryCount = 0;
+                        }
+                        catch (up) {
+                            retryCount -= 1;
+                            if (retryCount <= 0) {
+                                throw up;
+                            }
+                            yield new Promise((res) => setTimeout(res, retryWait));
+                            retryWait = retryWait * 2;
+                        }
+                    }
+                    fileOffset += partSize;
+                    filePartIndex++;
+                }
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    percent: 100,
+                    uploaded: true
+                });
+                return data;
+            });
+        }
+        Uploader.DoMultiPartUpload = DoMultiPartUpload;
+    })(exports.Uploader || (exports.Uploader = {}));
+
+    (function (ClientFile) {
+        let EPurpose;
+        (function (EPurpose) {
+            // Use this purpose for uploading bookmark thumbnail images.
+            // This will allow lower level privileges to upload (small) bookmark thumbnails.
+            EPurpose["BookmarkThumbnail"] = "Bookmark Thumbnail";
+        })(EPurpose = ClientFile.EPurpose || (ClientFile.EPurpose = {}));
+        /**
+         * Returns the URL for a client file.
+         * @param params
+         * @returns
+         */
+        function GetUrl(params) {
+            let { api, fileId, viaCdn } = params;
+            if (!api) {
+                api = exports.ENVIRONMENT.Api().GetBruceApi();
+            }
+            const urlSuffix = `file/${fileId}`;
+            const cdnUrl = viaCdn ? api.ConstructCdnUrl(urlSuffix) : null;
+            if (cdnUrl) {
+                return cdnUrl;
+            }
+            let url = `${api.GetBaseUrl()}${urlSuffix}`;
+            // Invalidating cache manually because we have a wave of invalid headers now cached across devices.
+            url = exports.UrlUtils.AddQueryParam(url, "cc", "1");
+            return url;
+        }
+        ClientFile.GetUrl = GetUrl;
+        /**
+         * Returns the URL for a client file with the extension.
+         * @param params
+         * @returns
+         */
+        function GetUrlWithExt(params) {
+            let { api, file, viaCdn } = params;
+            if (!api) {
+                api = exports.ENVIRONMENT.Api().GetBruceApi();
+            }
+            const urlSuffix = file.FileExt ? `file/${file.ID}${file.FileExt}` : `file/${file.ID}`;
+            const cdnUrl = viaCdn ? api.ConstructCdnUrl(urlSuffix) : null;
+            if (cdnUrl) {
+                return cdnUrl;
+            }
+            let url = `${api.GetBaseUrl()}${urlSuffix}`;
+            // Invalidating cache manually because we have a wave of invalid headers now cached across devices.
+            url = exports.UrlUtils.AddQueryParam(url, "cc", "1");
+            return url;
+        }
+        ClientFile.GetUrlWithExt = GetUrlWithExt;
+        /**
+         * Returns a client file record by ID.
+         * @param params
+         * @returns
+         */
+        function Get(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, fileId, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!fileId) {
+                    throw ("File ID is required.");
+                }
+                const key = GetCacheKey(fileId);
+                const cache = yield api.GetCacheItem(key, reqParams);
+                if (cache === null || cache === void 0 ? void 0 : cache.found) {
+                    return cache.data;
+                }
+                const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield api.GET(`file/${fileId}/details`, exports.Api.PrepReqParams(reqParams));
+                        res({
+                            clientFile: data
+                        });
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                }));
+                yield api.SetCacheItem({
+                    key,
+                    value: prom,
+                    req: reqParams
+                });
+                return prom;
+            });
+        }
+        ClientFile.Get = Get;
+        /**
+         * Deletes one or many client file records by IDs.
+         * @param params
+         */
+        function Delete(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, fileIds, req: reqParams } = params;
+                if (!fileIds.length) {
+                    return Promise.resolve();
+                }
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                const data = {
+                    Items: fileIds
+                };
+                yield api.POST("deleteFiles", data, exports.Api.PrepReqParams(reqParams));
+                for (let i = 0; i < fileIds.length; i++) {
+                    const key = GetCacheKey(fileIds[i]);
+                    api.Cache.Remove(key);
+                }
+            });
+        }
+        ClientFile.Delete = Delete;
+        /**
+         * Uploads a file and creates a new client file record.
+         * @param params
+         * @returns
+         */
+        function Upload(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, file, purpose, req, onProgress } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!file) {
+                    throw ("File is required.");
+                }
+                const size = file === null || file === void 0 ? void 0 : file.size;
+                if (!size) {
+                    throw ("You cannot upload a 0byte sized file.");
+                }
+                req = exports.Api.PrepReqParams(req);
+                let clientFile;
+                if (size > exports.Uploader.MIN_LARGE_FILE_SIZE) {
+                    clientFile = yield exports.Uploader.DoMultiPartUpload({
+                        api,
+                        file,
+                        urlSuffix: "fileUpload",
+                        req,
                         onProgress
                     });
                     // TODO: Check if we can add it to the request like the small file upload.
@@ -9328,186 +10059,16 @@
             return __awaiter(this, void 0, void 0, function* () {
                 let { api, actionId, req: reqParams } = params;
                 if (!actionId) {
-                    throw ("Action ID is required.");
-                }
-                if (!api) {
-                    api = exports.ENVIRONMENT.Api().GetBruceApi();
-                }
-                yield api.DELETE(`pendingAction/${actionId}`, exports.Api.PrepReqParams(reqParams));
-            });
-        }
-        PendingAction.Cancel = Cancel;
-    })(exports.PendingAction || (exports.PendingAction = {}));
-
-    (function (Style) {
-        /**
-         * Types of styles available.
-         * The type will dictate what settings are available.
-         */
-        let EType;
-        (function (EType) {
-            EType["Entity"] = "ENTITY";
-            EType["EntityRelationship"] = "ENTITY_RELATIONSHIP";
-        })(EType = Style.EType || (Style.EType = {}));
-        /**
-         * Available types of points.
-         * Default is POINT.
-         */
-        let EPointType;
-        (function (EPointType) {
-            // Render a sphere with a fixed pixel size.
-            EPointType["Point"] = "POINT";
-            // Render an icon.
-            EPointType["Icon"] = "ICON";
-            // Render a cylinder with a fixed meter size.
-            EPointType["Cylinder"] = "CYLINDER";
-        })(EPointType = Style.EPointType || (Style.EPointType = {}));
-        /**
-         * Returns a list of styles.
-         * @param params
-         * @returns
-         */
-        function GetList(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let { api, req: reqParams } = params;
-                if (!api) {
-                    api = exports.ENVIRONMENT.Api().GetBruceApi();
-                }
-                const cache = yield api.GetCacheItem(GetListCacheKey(), reqParams);
-                if (cache === null || cache === void 0 ? void 0 : cache.found) {
-                    return cache.data;
-                }
-                const res = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const data = yield api.GET("ui.entityDisplaySettings", exports.Api.PrepReqParams(reqParams));
-                        res({
-                            styles: data.Items
-                        });
-                    }
-                    catch (e) {
-                        rej(e);
-                    }
-                }));
-                yield api.SetCacheItem({
-                    key: GetListCacheKey(),
-                    value: res,
-                    req: reqParams
-                });
-                return res;
-            });
-        }
-        Style.GetList = GetList;
-        /**
-         * Returns a style.
-         * @param params
-         * @returns
-         */
-        function Get(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let { api, styleId: id, req: reqParams } = params;
-                if (!id) {
-                    throw ("Style ID is required.");
-                }
-                if (!api) {
-                    api = exports.ENVIRONMENT.Api().GetBruceApi();
-                }
-                const cache = yield api.GetCacheItem(GetCacheKey(id), reqParams);
-                if (cache === null || cache === void 0 ? void 0 : cache.found) {
-                    return cache.data;
-                }
-                const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const data = yield api.GET(`ui.entityDisplaySetting/${id}`, exports.Api.PrepReqParams(reqParams));
-                        res({
-                            style: data
-                        });
-                    }
-                    catch (e) {
-                        rej(e);
-                    }
-                }));
-                yield api.SetCacheItem({
-                    key: GetCacheKey(id),
-                    value: prom,
-                    req: reqParams
-                });
-                return prom;
-            });
-        }
-        Style.Get = Get;
-        /**
-         * Creates or updates a style.
-         * @param params
-         * @returns
-         */
-        function Update(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let { api, style: data, req: reqParams } = params;
-                if (!(data === null || data === void 0 ? void 0 : data.Name)) {
-                    throw ("Style name is required.");
-                }
-                if (!api) {
-                    api = exports.ENVIRONMENT.Api().GetBruceApi();
-                }
-                if (!data.ID) {
-                    data.ID = 0;
-                }
-                const res = yield api.POST(`ui.entityDisplaySetting/${data.ID}`, data, exports.Api.PrepReqParams(reqParams));
-                api.Cache.Remove(GetCacheKey(data.ID));
-                api.Cache.Remove(GetListCacheKey());
-                return {
-                    style: res
-                };
-            });
-        }
-        Style.Update = Update;
-        /**
-         * Deletes a style.
-         * @param params
-         */
-        function Delete(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let { api, styleId: id, req: reqParams } = params;
-                if (!api) {
-                    api = exports.ENVIRONMENT.Api().GetBruceApi();
-                }
-                if (!id) {
-                    throw ("Style ID is required.");
-                }
-                yield api.DELETE(`ui.entityDisplaySetting/${id}`, exports.Api.PrepReqParams(reqParams));
-                api.Cache.Remove(GetCacheKey(id));
-                api.Cache.Remove(GetListCacheKey());
-            });
-        }
-        Style.Delete = Delete;
-        /**
-         * Returns cache identifier for a style.
-         * Example: {
-         *     const api: BruceApi.Api = ...;
-         *     const key = GetCacheKey(1);
-         *     api.Cache.Remove(key);
-         * }
-         * @param id
-         * @returns
-         */
-        function GetCacheKey(id) {
-            return exports.Api.ECacheKey.Style + exports.Api.ECacheKey.Id + id;
-        }
-        Style.GetCacheKey = GetCacheKey;
-        /**
-         * Returns cache identifier for a list of styles.
-         * Example: {
-         *     const api: BruceApi.Api = ...;
-         *     const key = GetListCacheKey();
-         *     api.Cache.Remove(key);
-         * }
-         * @returns
-         */
-        function GetListCacheKey() {
-            return exports.Api.ECacheKey.Style;
+                    throw ("Action ID is required.");
+                }
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                yield api.DELETE(`pendingAction/${actionId}`, exports.Api.PrepReqParams(reqParams));
+            });
         }
-        Style.GetListCacheKey = GetListCacheKey;
-    })(exports.Style || (exports.Style = {}));
+        PendingAction.Cancel = Cancel;
+    })(exports.PendingAction || (exports.PendingAction = {}));
 
     /**
      * Permissions in Nextspace are arbitrary strings with meaning in specific contexts.
@@ -10672,6 +11233,609 @@
         AccountFeatures.GetCacheKey = GetCacheKey;
     })(exports.AccountFeatures || (exports.AccountFeatures = {}));
 
+    (function (AccountLimits) {
+        let ELimit;
+        (function (ELimit) {
+            ELimit["MaxProjectViewCount"] = "MaxProjectViewCount";
+            ELimit["MaxStorageUseGigabytes"] = "MaxStorageUseGigabytes";
+            ELimit["MaxEntitiesCount"] = "MaxEntitiesCount";
+            ELimit["MaxFileImportSizeGigabytes"] = "MaxFileImportSizeGigabytes";
+            ELimit["OperatorAccessAllowed"] = "OperatorAccessAllowed";
+            ELimit["DenyPublicAccess"] = "DenyPublicAccess";
+            ELimit["EnableSSOLogin"] = "EnableSSOLogin";
+            ELimit["EnableSSOLoginAutoRedirect"] = "EnableSSOLoginAutoRedirect";
+        })(ELimit = AccountLimits.ELimit || (AccountLimits.ELimit = {}));
+        /**
+         * Returns a dictionary of limits for the given account.
+         * @param params
+         * @returns
+         */
+        function GetLimits(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { accountId, api, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                }
+                req = exports.Api.PrepReqParams(req);
+                const cacheData = api.GetCacheItem(GetLimitsCacheKey(accountId));
+                if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.found) {
+                    return cacheData.data;
+                }
+                const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield api.GET(`account/${accountId}?WithLimits=true`);
+                        const limits = data.Limits ? data.Limits : {};
+                        res({
+                            limits: limits
+                        });
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                }));
+                api.SetCacheItem({
+                    key: GetLimitsCacheKey(accountId),
+                    value: prom,
+                    req: req
+                });
+                return prom;
+            });
+        }
+        AccountLimits.GetLimits = GetLimits;
+        /**
+         * Returns a numeric limit for the given account.
+         * @param params
+         */
+        function GetNumericLimit(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { key, api, req, onErrorValue, onEmptyValue, accountId } = params;
+                try {
+                    const { limits } = yield GetLimits({
+                        accountId: accountId,
+                        api: api,
+                        req: req
+                    });
+                    const limit = limits[key];
+                    if (limit == null || limit.Numeric == null) {
+                        return onEmptyValue;
+                    }
+                    return Number(limit.Numeric);
+                }
+                catch (e) {
+                    return onErrorValue;
+                }
+            });
+        }
+        AccountLimits.GetNumericLimit = GetNumericLimit;
+        /**
+         * Returns a boolean limit for the given account.
+         * @param params
+         */
+        function GetBooleanLimit(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { key, api, req, onErrorValue, onEmptyValue, accountId } = params;
+                try {
+                    const { limits } = yield GetLimits({
+                        accountId: accountId,
+                        api: api,
+                        req: req
+                    });
+                    const limit = limits[key];
+                    if (limit == null || limit.Boolean == null) {
+                        return onEmptyValue;
+                    }
+                    return Boolean(limit.Boolean);
+                }
+                catch (e) {
+                    return onErrorValue;
+                }
+            });
+        }
+        AccountLimits.GetBooleanLimit = GetBooleanLimit;
+        /**
+         * Returns a string limit for the given account.
+         * @param params
+         */
+        function GetStringLimit(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { key, api, req, onErrorValue, onEmptyValue, accountId } = params;
+                try {
+                    const { limits } = yield GetLimits({
+                        accountId: accountId,
+                        api: api,
+                        req: req
+                    });
+                    const limit = limits[key];
+                    if (limit == null || limit.String == null) {
+                        return onEmptyValue;
+                    }
+                    return limit.String;
+                }
+                catch (e) {
+                    return onErrorValue;
+                }
+            });
+        }
+        AccountLimits.GetStringLimit = GetStringLimit;
+        /**
+         * Functions for validating if a user can do things sit here.
+         */
+        let Assert;
+        (function (Assert) {
+            /**
+             * Returns if project view creation is allowed for the account.
+             */
+            function GetCanCreateProjectView(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.getters) {
+                        params.getters = exports.ENVIRONMENT.Api();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = params.getters.GetAccountId();
+                    }
+                    let current = -1;
+                    let max = yield GetNumericLimit({
+                        accountId: params.accountId,
+                        key: ELimit.MaxProjectViewCount,
+                        onEmptyValue: 0,
+                        onErrorValue: null,
+                        api: params.getters.GetGuardianApi()
+                    });
+                    if (max != null) {
+                        // Should use proper statistic API as this will exclude project views the user cannot access.
+                        try {
+                            const { views } = yield exports.ProjectView.GetList({
+                                api: params.getters.GetBruceApi({
+                                    accountId: params.accountId
+                                })
+                            });
+                            current = views.length;
+                        }
+                        catch (e) {
+                            console.error(e);
+                            max = null;
+                        }
+                    }
+                    if (max == null) {
+                        return {
+                            allowed: false,
+                            errorText: "We apologize but Project View creation is currently unavailable."
+                        };
+                    }
+                    else if (max == -1) {
+                        return {
+                            allowed: true
+                        };
+                    }
+                    else if (current == -1) {
+                        return {
+                            allowed: false,
+                            errorText: "We apologize but Project View creation is currently unavailable."
+                        };
+                    }
+                    else if (current >= max) {
+                        return {
+                            allowed: false,
+                            errorText: `You have reached the maximum number of Project Views allowed for your account. Your limit is ${max} Project ${max == 1 ? "View" : "Views"} and you have ${current}.`
+                        };
+                    }
+                    return {
+                        allowed: true
+                    };
+                });
+            }
+            Assert.GetCanCreateProjectView = GetCanCreateProjectView;
+            /**
+             * Returns the project view limit for an account.
+             * If -1 is returned then it is unlimited.
+             * @param params
+             * @returns
+             */
+            function GetProjectViewLimit(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.api) {
+                        params.api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = exports.ENVIRONMENT.Api().GetAccountId();
+                    }
+                    const max = yield GetNumericLimit({
+                        accountId: params.accountId,
+                        key: ELimit.MaxProjectViewCount,
+                        onEmptyValue: 0,
+                        onErrorValue: null,
+                        api: params.api
+                    });
+                    // Our error so we'll just allow unlimited for the time being.
+                    if (max == null) {
+                        return -1;
+                    }
+                    return max;
+                });
+            }
+            Assert.GetProjectViewLimit = GetProjectViewLimit;
+            /**
+             * Returns if file uploads are allowed for the account.
+             */
+            function GetCanUploadFile(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.getters) {
+                        params.getters = exports.ENVIRONMENT.Api();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = params.getters.GetAccountId();
+                    }
+                    let current = -1;
+                    let max = yield GetNumericLimit({
+                        accountId: params.accountId,
+                        key: ELimit.MaxStorageUseGigabytes,
+                        onEmptyValue: 0,
+                        onErrorValue: null,
+                        api: params.getters.GetGuardianApi()
+                    });
+                    if (max != null && max > 0) {
+                        try {
+                            const api = params.getters.GetBruceApi({
+                                accountId: params.accountId
+                            });
+                            const stats = yield api.GET("account/summary-stats");
+                            if (stats === null || stats === void 0 ? void 0 : stats.ID) {
+                                const result = stats === null || stats === void 0 ? void 0 : stats.Result;
+                                try {
+                                    const resJson = JSON.parse(result);
+                                    const fileBytes = resJson.TotalStorageUseBytes;
+                                    const fileGB = fileBytes != null && !isNaN(fileBytes) && fileBytes != -1 ? exports.MathUtils.Round(fileBytes / 1024 / 1024 / 1024, 2) : null;
+                                    // Still counting so we'll give unlimited for the time being.
+                                    // This count can take ages so we won't make the user wait.
+                                    if (fileGB == null || isNaN(fileGB)) {
+                                        max = -1;
+                                    }
+                                    else {
+                                        current = fileGB;
+                                    }
+                                }
+                                // We won't count this as a fatal error because who knows how stable this is.
+                                catch (e) {
+                                    console.error(e);
+                                }
+                            }
+                            // Unknown so we'll just give unlimited for the time being.
+                            else {
+                                max = -1;
+                            }
+                        }
+                        catch (e) {
+                            console.error(e);
+                            max = null;
+                        }
+                    }
+                    // Optional param for a file size to add to the current storage amount.
+                    // Eg: user is uploading a 3gb file, is that allowed right now?
+                    if (current != -1 && !isNaN(params.fileSize) && params.fileSize) {
+                        current += exports.MathUtils.Round(params.fileSize / 1024 / 1024 / 1024, 3);
+                    }
+                    if (max == null) {
+                        return {
+                            allowed: false,
+                            errorText: "We apologize but file uploads are currently unavailable."
+                        };
+                    }
+                    else if (max == -1) {
+                        return {
+                            allowed: true
+                        };
+                    }
+                    else if (current == -1) {
+                        return {
+                            allowed: false,
+                            errorText: "We apologize but file uploads are currently unavailable."
+                        };
+                    }
+                    else if (current >= max) {
+                        return {
+                            allowed: false,
+                            errorText: `You have reached the maximum amount of storage allowed for your account. You are limited to ${max.toLocaleString()} ${max == 1 ? "GB" : "GBs"} of storage.`
+                        };
+                    }
+                    return {
+                        allowed: true
+                    };
+                });
+            }
+            Assert.GetCanUploadFile = GetCanUploadFile;
+            /**
+             * Returns the file limit for an account.
+             * If -1 is returned then it is unlimited.
+             * @param params
+             * @returns
+             */
+            function GetFileGBLimit(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.api) {
+                        params.api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = exports.ENVIRONMENT.Api().GetAccountId();
+                    }
+                    const max = yield GetNumericLimit({
+                        accountId: params.accountId,
+                        key: ELimit.MaxStorageUseGigabytes,
+                        onEmptyValue: 0,
+                        onErrorValue: null,
+                        api: params.api
+                    });
+                    // Our error so we'll just allow unlimited for the time being.
+                    if (max == null) {
+                        return -1;
+                    }
+                    return max;
+                });
+            }
+            Assert.GetFileGBLimit = GetFileGBLimit;
+            /**
+             * Returns the maximum file import size for an account.
+             * If -1 is returned then it is unlimited.
+             * @param params
+             * @returns
+             */
+            function GetMaxImportSizeGB(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.api) {
+                        params.api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = exports.ENVIRONMENT.Api().GetAccountId();
+                    }
+                    const max = yield GetNumericLimit({
+                        accountId: params.accountId,
+                        key: ELimit.MaxFileImportSizeGigabytes,
+                        onEmptyValue: 0,
+                        onErrorValue: null,
+                        api: params.api
+                    });
+                    // Our error so we'll just allow unlimited for the time being.
+                    if (max == null) {
+                        return -1;
+                    }
+                    return max;
+                });
+            }
+            Assert.GetMaxImportSizeGB = GetMaxImportSizeGB;
+            /**
+             * Returns if entity creation is allowed for the account.
+             */
+            function GetCanCreateEntity(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.getters) {
+                        params.getters = exports.ENVIRONMENT.Api();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = params.getters.GetAccountId();
+                    }
+                    let current = -1;
+                    let max = yield GetNumericLimit({
+                        accountId: params.accountId,
+                        key: ELimit.MaxEntitiesCount,
+                        onEmptyValue: 0,
+                        onErrorValue: null,
+                        api: params.getters.GetGuardianApi()
+                    });
+                    if (max != null && max > 0) {
+                        try {
+                            const api = params.getters.GetBruceApi({
+                                accountId: params.accountId
+                            });
+                            const stats = yield api.GET("account/summary-stats");
+                            if (stats === null || stats === void 0 ? void 0 : stats.ID) {
+                                const result = stats === null || stats === void 0 ? void 0 : stats.Result;
+                                try {
+                                    const resJson = JSON.parse(result);
+                                    const eCount = resJson.EntitiesCount;
+                                    // Still counting so we'll give unlimited for the time being.
+                                    // This count can take ages so we won't make the user wait.
+                                    if (eCount == null || isNaN(eCount)) {
+                                        max = -1;
+                                    }
+                                    else {
+                                        current = eCount;
+                                    }
+                                }
+                                // We won't count this as a fatal error because who knows how stable this is.
+                                catch (e) {
+                                    console.error(e);
+                                }
+                            }
+                            // Unknown so we'll just give unlimited for the time being.
+                            else {
+                                max = -1;
+                            }
+                        }
+                        catch (e) {
+                            console.error(e);
+                            max = null;
+                        }
+                    }
+                    // Optional param for an entity count to add to the current entity amount.
+                    // Eg: user is creating 3 entities, is that allowed right now?
+                    if (current != -1 && !isNaN(params.count) && params.count) {
+                        current += params.count;
+                        // Remove one since we do an inclusive check later in the code.
+                        current -= 1;
+                    }
+                    if (max == null) {
+                        return {
+                            allowed: false,
+                            errorText: "We apologize but Entity creation is currently unavailable."
+                        };
+                    }
+                    else if (max == -1) {
+                        return {
+                            allowed: true
+                        };
+                    }
+                    else if (current == -1) {
+                        return {
+                            allowed: false,
+                            errorText: "We apologize but Entity creation is currently unavailable."
+                        };
+                    }
+                    else if (current >= max) {
+                        return {
+                            allowed: false,
+                            errorText: `You have reached the maximum number of Entities allowed for your account. You are limited to ${max.toLocaleString()} ${max == 1 ? "Entity" : "Entities"}.`
+                        };
+                    }
+                    return {
+                        allowed: true
+                    };
+                });
+            }
+            Assert.GetCanCreateEntity = GetCanCreateEntity;
+            /**
+             * Returns the entity limit for an account.
+             * If -1 is returned then it is unlimited.
+             */
+            function GetEntityLimit(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.api) {
+                        params.api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = exports.ENVIRONMENT.Api().GetAccountId();
+                    }
+                    const max = yield GetNumericLimit({
+                        accountId: params.accountId,
+                        key: ELimit.MaxEntitiesCount,
+                        onEmptyValue: 0,
+                        onErrorValue: null,
+                        api: params.api
+                    });
+                    // Our error so we'll just allow unlimited for the time being.
+                    if (max == null) {
+                        return -1;
+                    }
+                    return max;
+                });
+            }
+            Assert.GetEntityLimit = GetEntityLimit;
+            /**
+             * Returns if Operator access is allowed for the account.
+             * @param params
+             * @returns
+             */
+            function GetCanOpenOperator(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.api) {
+                        params.api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = exports.ENVIRONMENT.Api().GetAccountId();
+                    }
+                    const allowed = yield GetBooleanLimit({
+                        accountId: params.accountId,
+                        key: ELimit.OperatorAccessAllowed,
+                        onEmptyValue: false,
+                        onErrorValue: null,
+                        api: params.api
+                    });
+                    if (allowed == null) {
+                        return {
+                            allowed: false,
+                            errorText: "We apologize but Operator access is currently unavailable."
+                        };
+                    }
+                    else if (allowed) {
+                        return {
+                            allowed: true
+                        };
+                    }
+                    else {
+                        return {
+                            allowed: false,
+                            errorText: "You do not have access to Operator."
+                        };
+                    }
+                });
+            }
+            Assert.GetCanOpenOperator = GetCanOpenOperator;
+            /**
+             * Returns SSO login settings for the account.
+             * @param params
+             * @returns
+             */
+            function GetSSOLoginSettings(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.api) {
+                        params.api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = exports.ENVIRONMENT.Api().GetAccountId();
+                    }
+                    const enabled = yield GetBooleanLimit({
+                        accountId: params.accountId,
+                        key: ELimit.EnableSSOLogin,
+                        onEmptyValue: false,
+                        onErrorValue: null,
+                        api: params.api
+                    });
+                    const autoRedirect = yield GetBooleanLimit({
+                        accountId: params.accountId,
+                        key: ELimit.EnableSSOLoginAutoRedirect,
+                        onEmptyValue: false,
+                        onErrorValue: null,
+                        api: params.api
+                    });
+                    if (enabled == null || autoRedirect == null) {
+                        return {
+                            enabled: false,
+                            autoRedirect: false,
+                            errorText: "We apologize but SSO login is currently unavailable."
+                        };
+                    }
+                    return {
+                        enabled: enabled,
+                        autoRedirect: autoRedirect
+                    };
+                });
+            }
+            Assert.GetSSOLoginSettings = GetSSOLoginSettings;
+            /**
+             * Returns if public access is denied to this account.
+             * @param params
+             * @returns
+             */
+            function GetDenyPublicAccess(params) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!params.api) {
+                        params.api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                    }
+                    if (!params.accountId) {
+                        params.accountId = exports.ENVIRONMENT.Api().GetAccountId();
+                    }
+                    const enabled = yield GetBooleanLimit({
+                        accountId: params.accountId,
+                        key: ELimit.DenyPublicAccess,
+                        // If empty then we'll assume we are not denying public access.
+                        onEmptyValue: false,
+                        // If we crash we are denying public access.
+                        onErrorValue: true,
+                        api: params.api
+                    });
+                    return enabled;
+                });
+            }
+            Assert.GetDenyPublicAccess = GetDenyPublicAccess;
+        })(Assert = AccountLimits.Assert || (AccountLimits.Assert = {}));
+        /**
+         * Cache key for requesting account limits for a specific account.
+         * @param accountId
+         */
+        function GetLimitsCacheKey(accountId) {
+            return exports.Api.ECacheKey.AccountLimits + exports.Api.ECacheKey.Id + accountId;
+        }
+        AccountLimits.GetLimitsCacheKey = GetLimitsCacheKey;
+    })(exports.AccountLimits || (exports.AccountLimits = {}));
+
     (function (EncryptUtils) {
         // https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript
         function Cyrb53Hash(str, seed = 0) {
@@ -11684,7 +12848,7 @@
     })(exports.DataSource || (exports.DataSource = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "4.1.5";
+    const VERSION = "4.1.6";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;