bruce-models 7.0.6 → 7.0.8

package/dist/bruce-models.umd.js

@@ -1833,7 +1833,18 @@
                     _getters.SetEnv(params.env);
                 }
             }
-            ENVIRONMENT.PARAMS = Object.assign(Object.assign({}, ENVIRONMENT.PARAMS), params);
+            if (params.dereference) {
+                ENVIRONMENT.PARAMS = Object.assign(Object.assign({}, ENVIRONMENT.PARAMS), params);
+            }
+            else {
+                const keys = Object.keys(params);
+                for (const key of keys) {
+                    const value = params[key];
+                    if (value !== undefined) {
+                        ENVIRONMENT.PARAMS[key] = value;
+                    }
+                }
+            }
             (_a = ENVIRONMENT.OnParamsChange) === null || _a === void 0 ? void 0 : _a.Trigger();
         }
         ENVIRONMENT.Reset = Reset;
@@ -2693,950 +2704,950 @@
     })(exports.ObjectUtils || (exports.ObjectUtils = {}));
 
     /**
-     * Describes an entity type schema attribute.
+     * Utility to help with parsing and wrapping Nextspace paths.
      */
-    (function (EntityAttribute) {
-        let EType;
-        (function (EType) {
-            // Arbitrary text attribute.
-            EType["String"] = "String";
-            // Floating point number attribute.
-            EType["Double"] = "Double";
-            // Whole number attribute.
-            EType["Integer"] = "Integer";
-            // iso8601 date time string.
-            EType["Datetime"] = "Datetime";
-            // Group of attributes.
-            EType["Structure"] = "Structure";
-            // Nextspace vector geometry.
-            EType["Geometry"] = "Geometry";
-            // True/false attribute.
-            EType["Boolean"] = "Boolean";
-            // String User ID.
-            EType["User"] = "User";
-            // String Group ID.
-            EType["UserGroup"] = "UserGroup";
-            // String Entity ID.
-            EType["Entity"] = "Entity";
-            // Url attribute.
-            EType["Url"] = "Url";
-            // Serial number that increments for each new entity/missing-attr-value.
-            EType["Serial"] = "Serial";
-        })(EType = EntityAttribute.EType || (EntityAttribute.EType = {}));
-        /**
-         * Describes url open behavior.
-         */
-        let EOpenBehavior;
-        (function (EOpenBehavior) {
-            EOpenBehavior["POPUP"] = "POPUP";
-            EOpenBehavior["NEW_TAB"] = "NEW_TAB";
-        })(EOpenBehavior = EntityAttribute.EOpenBehavior || (EntityAttribute.EOpenBehavior = {}));
+    (function (PathUtils) {
         /**
-         * Returns an attribute from a provided hierarchy of attributes.
-         * Eg: Use the path: ["Bruce", "ID"] to find the "ID" attribute.
-         * @param items
-         * @param path
+         * Parses a Bruce string path into an array of strings.
+         * Example of path: "\"location\"/\"latitude\"" or "location/latitude".
+         * @param str
          * @returns
          */
-        function GetAttribute(items, path) {
-            if (!items || !path || !path.length) {
-                return null;
-            }
-            const key = path[0];
-            const item = items.find((i) => i.Key === key);
-            if (!item) {
-                return null;
+        function Parse(str) {
+            if (!(str === null || str === void 0 ? void 0 : str.length)) {
+                return [];
             }
-            if (path.length === 1) {
-                return item;
+            const broken = str.split("/");
+            // Remove quotes from the first and last chars.
+            for (let i = 0; i < broken.length; i++) {
+                let piece = broken[i];
+                if (piece.startsWith("\"")) {
+                    piece = piece.substring(1);
+                }
+                if (piece.endsWith("\"")) {
+                    piece = piece.substring(0, piece.length - 1);
+                }
+                broken[i] = piece;
             }
-            return GetAttribute(item.Structure, path.slice(1));
+            return broken;
         }
-        EntityAttribute.GetAttribute = GetAttribute;
+        PathUtils.Parse = Parse;
         /**
-         * Removes an attribute from a provided hierarchy of attributes.
-         * Eg: Use the path: ["Bruce", "ID"] to remove the "ID" attribute.
-         * This will mutate the items array.
-         * @param items
+         * Wraps an array of strings into a Nextspace string path.
          * @param path
+         * @returns
          */
-        function RemoveAttribute(items, path) {
-            if (!items || !(path === null || path === void 0 ? void 0 : path.length)) {
-                return;
+        function Wrap(path) {
+            if (!(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, remove the item from the items array.
-                const index = items.findIndex((i) => i.Key === key);
-                if (index !== -1) {
-                    items.splice(index, 1);
+            let tmp = "\"";
+            for (let i = 0; i < path.length; i++) {
+                let section = path[i];
+                tmp += section;
+                if (i < path.length - 1) {
+                    tmp += "\"/\"";
                 }
-                return;
-            }
-            // If we're not at the end of the path, dig further.
-            const item = items.find((i) => i.Key === key);
-            if (item && item.Structure) {
-                RemoveAttribute(item.Structure, path.slice(1));
             }
+            tmp += "\"";
+            return tmp;
         }
-        EntityAttribute.RemoveAttribute = RemoveAttribute;
+        PathUtils.Wrap = Wrap;
         /**
-         * Adds an attribute to a provided hierarchy of attributes.
-         * Eg: Use the path: ["Bruce", "ID"] to add the "ID" attribute.
-         * This will mutate the items array.
-         * This requires the path to be valid and for a parent attribute to exist.
-         * @param items
-         * @param path
-         * @param attribute
+         * Parses a Nextspace legacy string path into an array of strings.
+         * @param str
+         * @returns
          */
-        function AddAttribute(items, path, attribute) {
-            if (!items || !(path === null || path === void 0 ? void 0 : path.length)) {
-                return;
+        function ParseLegacy(str) {
+            if (!(str === null || str === void 0 ? void 0 : str.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.
-                const index = items.findIndex((i) => i.Key === key);
-                if (index !== -1) {
-                    // Overwrite existing attribute if it already exists.
-                    items[index] = attribute;
+            const broken = str.split(".");
+            for (let i = 0; i < broken.length; i++) {
+                let piece = broken[i];
+                if (piece.startsWith("\"")) {
+                    piece = piece.substring(1);
                 }
-                else {
-                    // Add new attribute if it doesn't exist.
-                    items.push(attribute);
+                if (piece.endsWith("\"")) {
+                    piece = piece.substring(0, piece.length - 1);
                 }
-                return;
-            }
-            // If we're not at the end of the path, dig further.
-            let item = items.find((i) => i.Key === key);
-            if (!item) {
-                item = { Key: key, Structure: [] };
-                items.push(item);
-            }
-            if (!item.Structure) {
-                item.Structure = [];
+                broken[i] = piece;
             }
-            AddAttribute(item.Structure, path.slice(1), attribute);
+            return broken;
         }
-        EntityAttribute.AddAttribute = AddAttribute;
-    })(exports.EntityAttribute || (exports.EntityAttribute = {}));
+        PathUtils.ParseLegacy = ParseLegacy;
+    })(exports.PathUtils || (exports.PathUtils = {}));
 
-    (function (EntityType) {
+    (function (EntityHistoricData) {
         /**
-         * Gets an entity type record.
+         * Returns historic data for an array of Entity IDs.
+         * A maximum number of records will be returned per Entity ID, this information is returned in the response.
          * @param params
          * @returns
          */
-        function Get(params) {
+        function GetList(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, entityTypeId: typeId, req: reqParams, expandLODs } = params;
-                if (!typeId) {
-                    throw ("Type ID is required.");
+                let { entityIds, attrKey, dateTimeFrom, dateTimeTo, api, req } = params;
+                // Save time and just return a none response if no entity IDs are provided.
+                if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
+                    return {
+                        limitPerEntity: 0,
+                        recordsByIds: {}
+                    };
                 }
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                const key = GetCacheKey(typeId, expandLODs);
-                const cache = api.GetCacheItem(key, reqParams);
-                if (cache === null || cache === void 0 ? void 0 : cache.found) {
-                    return cache.data;
+                let attrKeyStr = null;
+                if (attrKey) {
+                    if (typeof attrKey != "string") {
+                        attrKeyStr = exports.PathUtils.Wrap(attrKey);
+                    }
+                    else {
+                        attrKeyStr = attrKey;
+                    }
                 }
-                const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const urlParams = new URLSearchParams();
-                        if (expandLODs) {
-                            urlParams.append("Expand", "LOD");
+                // If we have more than 100 Entity IDs we'll have to split the request to avoid a URL that is too long.
+                const MAX_IDS = 100;
+                // We will recursively call this function to get all the data.
+                // Then merge at the end and return.
+                if (entityIds.length > MAX_IDS) {
+                    const reqs = [];
+                    // Making the ID batches.
+                    // If this is too long we can end up in a loop.
+                    const splitEntityIds = [];
+                    for (let i = 0; i < entityIds.length; i += MAX_IDS) {
+                        const batchIds = entityIds.slice(i, i + MAX_IDS);
+                        // Detecting this early to avoid infinite loops.
+                        if (batchIds.length > MAX_IDS) {
+                            throw new Error("Nextspace Developer Error: EntityHistoricData.GetList() has too many Entity IDs. Please contact support.");
                         }
-                        const url = `entitytype/${typeId}?${urlParams.toString()}`;
-                        const data = yield api.GET(url, exports.Api.PrepReqParams(reqParams));
-                        appendInternalAttrSchema(data);
-                        res({
-                            entityType: data
-                        });
+                        splitEntityIds.push(batchIds);
                     }
-                    catch (e) {
-                        rej(e);
+                    for (const splitEntityId of splitEntityIds) {
+                        reqs.push(GetList({
+                            entityIds: splitEntityId,
+                            attrKey: attrKeyStr,
+                            dateTimeFrom: dateTimeFrom,
+                            dateTimeTo: dateTimeTo,
+                            api: api,
+                            req: req
+                        }));
                     }
-                }));
-                api.SetCacheItem({
-                    key,
-                    value: prom,
-                    req: reqParams
-                });
-                return prom;
-            });
-        }
-        EntityType.Get = Get;
-        /**
-         * Deletes an entity type record and all corresponding entities.
-         * @param params
-         */
-        function Delete(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let { api, entityTypeId: typeId, req: reqParams } = params;
-                if (!typeId) {
-                    throw ("Type ID is required.");
-                }
-                if (!api) {
-                    api = exports.ENVIRONMENT.Api().GetBruceApi();
-                }
-                yield api.DELETE(`entitytype/${typeId}`, exports.Api.PrepReqParams(reqParams));
-                api.Cache.RemoveByStartsWith(GetCacheKey(typeId));
-                api.Cache.RemoveByStartsWith(GetListCacheKey());
-            });
-        }
-        EntityType.Delete = Delete;
-        /**
-         * Gets a list of entity types.
-         * @param params
-         * @returns
-         */
-        function GetList(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let { entityTypeIds, api, req: reqParams, parentTypeId, expandSettings, search, expandLODs } = params;
-                if (!api) {
-                    api = exports.ENVIRONMENT.Api().GetBruceApi();
-                }
-                const cache = api.GetCacheItem(GetListCacheKey({
-                    typeIds: entityTypeIds,
-                    parentTypeId,
-                    expandLODs,
-                    expandSettings,
-                    search
-                }), reqParams);
-                if (cache === null || cache === void 0 ? void 0 : cache.found) {
-                    return cache.data;
-                }
-                const req = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        // If we have an array of typeIds then we'll request in batches to avoid overflowing the URL.
-                        const BATCH_SIZE = 20;
-                        const reqs = [];
-                        if (entityTypeIds) {
-                            for (let i = 0; i < entityTypeIds.length; i += BATCH_SIZE) {
-                                const batch = entityTypeIds.slice(i, i + BATCH_SIZE);
-                                const urlParams = new URLSearchParams();
-                                for (const id of batch) {
-                                    urlParams.append("ID", id);
-                                }
-                                if (parentTypeId) {
-                                    urlParams.append("ParentTypeID", parentTypeId);
-                                }
-                                if (expandSettings && expandLODs) {
-                                    urlParams.append("Expand", "true");
-                                }
-                                else if (expandSettings) {
-                                    urlParams.append("Expand", "Schema");
-                                }
-                                else if (expandLODs) {
-                                    urlParams.append("Expand", "LOD");
-                                }
-                                if (search) {
-                                    urlParams.append("Search", search);
-                                }
-                                reqs.push(api.GET("entitytypes?" + urlParams.toString(), exports.Api.PrepReqParams(reqParams)));
-                            }
-                        }
-                        else {
-                            const urlParams = new URLSearchParams();
-                            if (parentTypeId) {
-                                urlParams.append("ParentTypeID", parentTypeId);
-                            }
-                            if (expandSettings && expandLODs) {
-                                urlParams.append("Expand", "true");
-                            }
-                            else if (expandSettings) {
-                                urlParams.append("Expand", "Schema");
-                            }
-                            else if (expandLODs) {
-                                urlParams.append("Expand", "LOD");
-                            }
-                            if (search) {
-                                urlParams.append("Search", search);
-                            }
-                            reqs.push(api.GET("entitytypes?" + urlParams.toString(), exports.Api.PrepReqParams(reqParams)));
-                        }
-                        const data = yield Promise.all(reqs);
-                        // Populate array, while checking for already added types.
-                        const types = [];
-                        for (const item of data) {
-                            for (const type of item.Items) {
-                                appendInternalAttrSchema(type);
-                                if (!types.find(x => x.ID == type.ID)) {
-                                    types.push(type);
-                                }
-                            }
+                    const res = yield Promise.all(reqs);
+                    const recordsByIds = {};
+                    let limitPerEntity = 0;
+                    for (const r of res) {
+                        limitPerEntity = r.limitPerEntity;
+                        for (const entityId in r.recordsByIds) {
+                            recordsByIds[entityId] = r.recordsByIds[entityId];
                         }
-                        res({
-                            entityTypes: types
-                        });
                     }
-                    catch (e) {
-                        rej(e);
-                    }
-                }));
-                if (!parentTypeId) {
-                    api.SetCacheItem({
-                        key: GetListCacheKey({
-                            typeIds: entityTypeIds,
-                            parentTypeId,
-                            expandSettings,
-                            expandLODs,
-                            search
-                        }),
-                        value: req,
-                        req: reqParams,
-                        duration: 60 * 5 // 5 minutes.
-                    });
+                    // Returning merged data.
+                    return {
+                        recordsByIds: recordsByIds,
+                        limitPerEntity: limitPerEntity
+                    };
                 }
-                return req;
+                const cacheKey = GetListCacheKey(entityIds, attrKeyStr, dateTimeFrom, dateTimeTo);
+                const cached = api.GetCacheItem(cacheKey, req);
+                if (cached === null || cached === void 0 ? void 0 : cached.found) {
+                    return cached.data;
+                }
+                const urlParams = new URLSearchParams();
+                for (const entityId of entityIds) {
+                    urlParams.append("entityId", entityId);
+                }
+                if (attrKeyStr) {
+                    urlParams.append("attrKey", attrKeyStr);
+                }
+                urlParams.append("dateTimeFrom", dateTimeFrom);
+                urlParams.append("dateTimeTo", dateTimeTo);
+                const prom = api.GET(`v1/entity/historicData?${urlParams.toString()}`, exports.Api.PrepReqParams(req));
+                api.SetCacheItem({
+                    key: cacheKey,
+                    value: prom,
+                    req: req,
+                    // Short cache. 30 seconds.
+                    duration: 30000
+                });
+                return prom;
             });
         }
-        EntityType.GetList = GetList;
+        EntityHistoricData.GetList = GetList;
         /**
-         * Updates or creates an entity type record.
+         * Returns historic data statistics for an array of Entity IDs.
          * @param params
          * @returns
          */
-        function Update(params) {
+        function GetStats(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, entityType: data, req: reqParams } = params;
+                let { entityIds, entityTypeId, api, req } = params;
+                // Save time and just return a none response if no entity IDs or type ID are provided.
+                if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length) && !entityTypeId) {
+                    return {
+                        stats: []
+                    };
+                }
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                if (!data) {
-                    data = {};
-                }
-                if (!data.ID) {
-                    data.ID = exports.ObjectUtils.UId();
-                }
-                if (!data.Name) {
-                    data.Name = data.ID;
+                req = exports.Api.PrepReqParams(req);
+                const cacheKey = GetStatsCacheKey(entityIds, entityTypeId);
+                const cached = api.GetCacheItem(cacheKey, req);
+                if (cached === null || cached === void 0 ? void 0 : cached.found) {
+                    return cached.data;
                 }
-                // Will not append if we're not updating schema (not specified).
-                appendInternalAttrSchema(data);
-                const res = yield api.POST(`entitytype/${data.ID}`, data, exports.Api.PrepReqParams(reqParams));
-                api.Cache.RemoveByStartsWith(GetCacheKey(data.ID));
-                api.Cache.RemoveByStartsWith(GetListCacheKey());
-                // Useful to append afterwards as newly created Entity Types may have it missing.
-                // This makes our UI apps not have to check for default attribute existence.
-                appendInternalAttrSchema(res);
-                return {
-                    entityType: res
-                };
+                const prom = yield api.POST("v1/entity/historicData/stats", {
+                    entityIds: entityIds,
+                    entityTypeId: entityTypeId
+                }, req);
+                api.SetCacheItem({
+                    key: cacheKey,
+                    value: prom,
+                    req: req,
+                    // Short cache. 60 seconds.
+                    duration: 60000
+                });
+                return prom;
             });
         }
-        EntityType.Update = Update;
+        EntityHistoricData.GetStats = GetStats;
         /**
-         * Starts a re-index background action on a specified Entity Type.
-         * This will ensure searchable data follows the current schema version.
-         * This will also perform certain data cleanup so that the data is consistent.
+         * Creates or updates historic data records.
+         * Please note that the expected input/output does not include internal fields found inside the "Bruce" attribute.
          * @param params
          * @returns
          */
-        function ReIndex(params) {
+        function Update(params) {
+            var _a;
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, entityTypeId: typeId, req, dataTransformId, reSaveAll } = params;
+                let { records, api, req } = params;
+                // Save time and just return a none response if no records are provided.
+                if (!(records === null || records === void 0 ? void 0 : records.length)) {
+                    return {
+                        records: []
+                    };
+                }
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                const urlParams = new URLSearchParams();
-                if (dataTransformId) {
-                    urlParams.append("dataTransformID", String(dataTransformId));
+                const res = yield api.POST("v1/entity/historicData", {
+                    records: records
+                }, exports.Api.PrepReqParams(req));
+                // Kill cache for every unique attrKey.
+                let attrKeys = records.map(r => r.attrKey);
+                attrKeys = attrKeys.filter((v, i) => attrKeys.indexOf(v) === i);
+                for (const attrKey of attrKeys) {
+                    api.Cache.RemoveByContains(exports.Entity.GetHistoricContainsKey(attrKey));
                 }
-                if (reSaveAll) {
-                    urlParams.append("reSaveAll", "true");
+                // Kill any stats cache that includes any of the Entity IDs.
+                if ((_a = res.records) === null || _a === void 0 ? void 0 : _a.length) {
+                    const entityIds = res.records.map(r => r.entityId).filter((v, i) => v && res.records.indexOf(v) === i);
+                    ClearCacheByEntityIds(api, entityIds);
                 }
-                let url = typeId ? `entityType/${typeId}/reindex` : "entities/reindex";
-                url += "?" + urlParams.toString();
-                req = exports.Api.PrepReqParams(req);
-                const res = yield api.POST(url, {}, req);
-                return {
-                    pendingActionId: res.PendingActionID
-                };
+                return res;
             });
         }
-        EntityType.ReIndex = ReIndex;
+        EntityHistoricData.Update = Update;
         /**
-         * Counts the total number of Entities in an Entity Type.
+         * Deletes historic data records for an array of Entity IDs.
+         * This deletes all records within a provided key + range.
          * @param params
          * @returns
          */
-        function Count(params) {
+        function Delete(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { entityTypeId, api, req } = params;
-                if (!entityTypeId) {
-                    throw ("Type ID is required.");
+                let { entityIds, attrKey, dateTimeFrom, dateTimeTo, api, req } = params;
+                if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
+                    return;
                 }
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                const url = `entityType/${entityTypeId}/entitiesCount`;
-                const { TotalEntities } = yield api.GET(url, exports.Api.PrepReqParams(req));
-                return TotalEntities;
-            });
-        }
-        EntityType.Count = Count;
-        /**
-         * Returns cache identifier for an entity type.
-         * Example: {
-         *     const api: BruceApi.Api = ...;
-         *     const key = GetCacheKey("abc");
-         *     api.Cache.Remove(key);
-         * }
-         * @param typeId
-         * @param expandLODs
-         * @returns
-         */
-        function GetCacheKey(typeId, expandLODs) {
-            let key = `${exports.Api.ECacheKey.EntityType}${exports.Api.ECacheKey.Id}${typeId}`;
-            if (expandLODs) {
-                key += "_LOD_" + expandLODs;
+                if (!attrKey || !dateTimeFrom || !dateTimeTo) {
+                    throw new Error("Invalid parameters provided.");
+                }
+                if (typeof attrKey != "string") {
+                    attrKey = exports.PathUtils.Wrap(attrKey);
+                }
+                const urlParams = new URLSearchParams();
+                for (const entityId of entityIds) {
+                    urlParams.append("entityId", entityId);
+                }
+                urlParams.append("attrKey", attrKey);
+                urlParams.append("dateTimeFrom", dateTimeFrom);
+                urlParams.append("dateTimeTo", dateTimeTo);
+                yield api.DELETE(`v1/entity/historicData?${urlParams.toString()}`, exports.Api.PrepReqParams(req));
+                // Kill cache for all Entity cached Entity records related to the attrKey.
+                api.Cache.RemoveByContains(exports.Entity.GetHistoricContainsKey(attrKey));
+                // Kill any stats cache that includes any of the Entity IDs.
+                ClearCacheByEntityIds(api, entityIds);
+            });
+        }
+        EntityHistoricData.Delete = Delete;
+        function GetListCacheKey(entityIds, attrKey, dateTimeFrom, dateTimeTo) {
+            return exports.Api.ECacheKey.EntityHistoricDataRec + exports.Api.ECacheKey.Id + entityIds.join(",") + exports.Api.ECacheKey.Id + attrKey + exports.Api.ECacheKey.Id + dateTimeFrom + exports.Api.ECacheKey.Id + dateTimeTo;
+        }
+        EntityHistoricData.GetListCacheKey = GetListCacheKey;
+        function GetStatsCacheKey(entityIds, typeId) {
+            if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
+                entityIds = [];
             }
-            return key;
+            if (!typeId) {
+                typeId = "";
+            }
+            return exports.Api.ECacheKey.EntityHistoricDataStats + exports.Api.ECacheKey.Id + typeId + exports.Api.ECacheKey.Id + entityIds.join(",");
         }
-        EntityType.GetCacheKey = GetCacheKey;
+        EntityHistoricData.GetStatsCacheKey = GetStatsCacheKey;
+        function ClearCacheByEntityIds(api, entityIds) {
+            if (!api || !(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
+                return;
+            }
+            const REC_KEY_PREFIX = exports.Api.ECacheKey.EntityHistoricDataRec + exports.Api.ECacheKey.Id;
+            const STATS_KEY_PREFIX = exports.Api.ECacheKey.EntityHistoricDataStats + exports.Api.ECacheKey.Id;
+            api.Cache.RemoveByCallback((key) => {
+                let keyStr = String(key);
+                if (!keyStr.startsWith(STATS_KEY_PREFIX) && !keyStr.startsWith(REC_KEY_PREFIX)) {
+                    return false;
+                }
+                // Shorten to speed up the next step.
+                keyStr = keyStr.replace(STATS_KEY_PREFIX, "").replace(REC_KEY_PREFIX, "");
+                // Look for any matching Entity IDs.
+                for (let i = 0; i < entityIds.length; i++) {
+                    const entityId = entityIds[i];
+                    if (keyStr.includes(entityId)) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+        }
+        EntityHistoricData.ClearCacheByEntityIds = ClearCacheByEntityIds;
+    })(exports.EntityHistoricData || (exports.EntityHistoricData = {}));
+
+    /**
+     * Describes an entity type schema attribute.
+     */
+    (function (EntityAttribute) {
+        let EType;
+        (function (EType) {
+            // Arbitrary text attribute.
+            EType["String"] = "String";
+            // Floating point number attribute.
+            EType["Double"] = "Double";
+            // Whole number attribute.
+            EType["Integer"] = "Integer";
+            // iso8601 date time string.
+            EType["Datetime"] = "Datetime";
+            // Group of attributes.
+            EType["Structure"] = "Structure";
+            // Nextspace vector geometry.
+            EType["Geometry"] = "Geometry";
+            // True/false attribute.
+            EType["Boolean"] = "Boolean";
+            // String User ID.
+            EType["User"] = "User";
+            // String Group ID.
+            EType["UserGroup"] = "UserGroup";
+            // String Entity ID.
+            EType["Entity"] = "Entity";
+            // Url attribute.
+            EType["Url"] = "Url";
+            // Serial number that increments for each new entity/missing-attr-value.
+            EType["Serial"] = "Serial";
+        })(EType = EntityAttribute.EType || (EntityAttribute.EType = {}));
         /**
-         * Returns cache identifier for a list of entity types.
-         * Example: {
-         *     const api: BruceApi.Api = ...;
-         *     const key = GetListCacheKey();
-         *     api.Cache.Remove(key);
-         * }
-         * @param typeIds
+         * Describes url open behavior.
+         */
+        let EOpenBehavior;
+        (function (EOpenBehavior) {
+            EOpenBehavior["POPUP"] = "POPUP";
+            EOpenBehavior["NEW_TAB"] = "NEW_TAB";
+        })(EOpenBehavior = EntityAttribute.EOpenBehavior || (EntityAttribute.EOpenBehavior = {}));
+        /**
+         * Returns an attribute from a provided hierarchy of attributes.
+         * Eg: Use the path: ["Bruce", "ID"] to find the "ID" attribute.
+         * @param items
+         * @param path
          * @returns
          */
-        function GetListCacheKey(params) {
-            if (!params) {
-                params = {};
+        function GetAttribute(items, path) {
+            if (!items || !path || !path.length) {
+                return null;
             }
-            let { typeIds, expandSettings, parentTypeId, expandLODs, search } = params;
-            let key = exports.Api.ECacheKey.EntityType;
-            if (!typeIds) {
-                typeIds = [];
+            const key = path[0];
+            const item = items.find((i) => i.Key === key);
+            if (!item) {
+                return null;
             }
-            key += (typeIds.length ? exports.Api.ECacheKey.Id : "") + typeIds.join(",");
-            if (parentTypeId) {
-                key += "_PARENT_" + parentTypeId;
+            if (path.length === 1) {
+                return item;
             }
-            if (!expandSettings) {
-                expandSettings = false;
+            return GetAttribute(item.Structure, path.slice(1));
+        }
+        EntityAttribute.GetAttribute = GetAttribute;
+        /**
+         * Removes an attribute from a provided hierarchy of attributes.
+         * Eg: Use the path: ["Bruce", "ID"] to remove the "ID" attribute.
+         * This will mutate the items array.
+         * @param items
+         * @param path
+         */
+        function RemoveAttribute(items, path) {
+            if (!items || !(path === null || path === void 0 ? void 0 : path.length)) {
+                return;
             }
-            if (!expandLODs) {
-                expandLODs = false;
+            const key = path[0];
+            if (path.length === 1) {
+                // If we're at the last key in the path, remove the item from the items array.
+                const index = items.findIndex((i) => i.Key === key);
+                if (index !== -1) {
+                    items.splice(index, 1);
+                }
+                return;
             }
-            key += "_SCHEMA_" + expandSettings;
-            key += "_LOD_" + expandLODs;
-            if (search) {
-                key += "_SEARCH_" + search;
+            // If we're not at the end of the path, dig further.
+            const item = items.find((i) => i.Key === key);
+            if (item && item.Structure) {
+                RemoveAttribute(item.Structure, path.slice(1));
             }
-            return key;
-        }
-        EntityType.GetListCacheKey = GetListCacheKey;
-    })(exports.EntityType || (exports.EntityType = {}));
-    /**
-     * Adds expected internal structure items even if they aren't there.
-     * Our API should be including them but this is a safety net.
-     * @param type
-     */
-    function appendInternalAttrSchema(type) {
-        // Schema not loaded. We'll ignore.
-        if (type == null || type.DataSchema == null) {
-            return;
-        }
-        // Append internal attributes.
-        if (!type.DataSchema.Structure) {
-            type.DataSchema.Structure = [];
         }
-        let bruce = type.DataSchema.Structure.find(a => a.Key == "Bruce");
-        if (!bruce) {
-            bruce = {
-                Key: "Bruce",
-                Name: "Bruce",
-                Description: "Nextspace internal attributes.",
-                Type: exports.EntityAttribute.EType.Structure,
-                Structure: [],
-                IsIndexed: true,
-                IsImportant: false
-            };
-            type.DataSchema.Structure.push(bruce);
-        }
-        if (!bruce.Structure) {
-            bruce.Structure = [];
-        }
-        // Append any missing internal attributes.
-        if (!bruce.Structure.find(x => x.Key == "ID")) {
-            bruce.Structure.push({
-                Key: "ID",
-                Name: "ID",
-                Description: "Unique identifier for the Entity.",
-                Type: exports.EntityAttribute.EType.String,
-                IsIndexed: true,
-                IsImportant: true
-            });
-        }
-        if (!bruce.Structure.find(x => x.Key == "Location")) {
-            bruce.Structure.push({
-                Key: "Location",
-                Name: "Location",
-                Description: "Location data.",
-                Type: exports.EntityAttribute.EType.Structure,
-                Structure: [
-                    {
-                        Key: "latitude",
-                        Name: "Latitude",
-                        Type: exports.EntityAttribute.EType.Double,
-                        IsIndexed: true,
-                        IsImportant: false
-                    },
-                    {
-                        Key: "longitude",
-                        Name: "Longitude",
-                        Type: exports.EntityAttribute.EType.Double,
-                        IsIndexed: true,
-                        IsImportant: false
-                    },
-                    {
-                        Key: "altitude",
-                        Name: "Altitude",
-                        Type: exports.EntityAttribute.EType.Double,
-                        IsIndexed: true,
-                        IsImportant: false
-                    }
-                ]
-            });
-        }
-        if (!bruce.Structure.find(x => x.Key == "Boundaries")) {
-            bruce.Structure.push({
-                Key: "Boundaries",
-                Name: "Boundaries",
-                Description: "Boundaries data.",
-                Type: exports.EntityAttribute.EType.Structure,
-                Structure: [
-                    {
-                        Key: "minLongitude",
-                        Name: "Min Longitude",
-                        Type: exports.EntityAttribute.EType.Double,
-                        IsIndexed: true,
-                        IsImportant: false
-                    },
-                    {
-                        Key: "maxLongitude",
-                        Name: "Max Longitude",
-                        Type: exports.EntityAttribute.EType.Double,
-                        IsIndexed: true,
-                        IsImportant: false
-                    },
-                    {
-                        Key: "minLatitude",
-                        Name: "Min Latitude",
-                        Type: exports.EntityAttribute.EType.Double,
-                        IsIndexed: true,
-                        IsImportant: false
-                    },
-                    {
-                        Key: "maxLatitude",
-                        Name: "Max Latitude",
-                        Type: exports.EntityAttribute.EType.Double,
-                        IsIndexed: true,
-                        IsImportant: false
-                    },
-                    {
-                        Key: "minAltitude",
-                        Name: "Min Altitude",
-                        Type: exports.EntityAttribute.EType.Double,
-                        IsIndexed: true,
-                        IsImportant: false
-                    },
-                    {
-                        Key: "maxAltitude",
-                        Name: "Max Altitude",
-                        Type: exports.EntityAttribute.EType.Double,
-                        IsIndexed: true,
-                        IsImportant: false
-                    }
-                ]
-            });
-        }
-        if (!bruce.Structure.find(x => x.Key == "Transform")) {
-            bruce.Structure.push({
-                Key: "Transform",
-                Name: "Transform",
-                Description: "Transform data.",
-                IsIndexed: true,
-                IsImportant: false,
-                Type: exports.EntityAttribute.EType.Structure,
-                Structure: [
-                    {
-                        Key: "heading",
-                        Name: "Heading",
-                        IsIndexed: true,
-                        IsImportant: false,
-                        Type: exports.EntityAttribute.EType.Double
-                    },
-                    {
-                        Key: "pitch",
-                        Name: "Pitch",
-                        IsIndexed: true,
-                        IsImportant: false,
-                        Type: exports.EntityAttribute.EType.Double
-                    },
-                    {
-                        Key: "roll",
-                        Name: "Roll",
-                        IsIndexed: true,
-                        IsImportant: false,
-                        Type: exports.EntityAttribute.EType.Double
-                    },
-                    {
-                        Key: "scale",
-                        Name: "Scale",
-                        IsIndexed: true,
-                        IsImportant: false,
-                        Type: exports.EntityAttribute.EType.Double
-                    }
-                ]
-            });
-        }
-        if (!bruce.Structure.find(x => x.Key == "VectorGeometry")) {
-            bruce.Structure.push({
-                Key: "VectorGeometry",
-                Name: "Geometry",
-                Description: "Geometry data.",
-                Type: exports.EntityAttribute.EType.Geometry,
-                IsIndexed: true,
-                IsImportant: false
-            });
-        }
-        // Filter out migrated/outdated ones.
-        // Removed from root and the internal structure.
-        const OUTDATED_INTERNAL = ["position", "geometry", "location", "boundaries", "transform"];
-        bruce.Structure = bruce.Structure.filter(a => !OUTDATED_INTERNAL.includes(a.Key));
-        type.DataSchema.Structure = type.DataSchema.Structure.filter(a => !OUTDATED_INTERNAL.includes(a.Key));
-    }
-
-    /**
-     * Utility to help with parsing and wrapping Nextspace paths.
-     */
-    (function (PathUtils) {
+        EntityAttribute.RemoveAttribute = RemoveAttribute;
         /**
-         * Parses a Bruce string path into an array of strings.
-         * Example of path: "\"location\"/\"latitude\"" or "location/latitude".
-         * @param str
-         * @returns
+         * Adds an attribute to a provided hierarchy of attributes.
+         * Eg: Use the path: ["Bruce", "ID"] to add the "ID" attribute.
+         * This will mutate the items array.
+         * This requires the path to be valid and for a parent attribute to exist.
+         * @param items
+         * @param path
+         * @param attribute
          */
-        function Parse(str) {
-            if (!(str === null || str === void 0 ? void 0 : str.length)) {
-                return [];
+        function AddAttribute(items, path, attribute) {
+            if (!items || !(path === null || path === void 0 ? void 0 : path.length)) {
+                return;
             }
-            const broken = str.split("/");
-            // Remove quotes from the first and last chars.
-            for (let i = 0; i < broken.length; i++) {
-                let piece = broken[i];
-                if (piece.startsWith("\"")) {
-                    piece = piece.substring(1);
+            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.
+                const index = items.findIndex((i) => i.Key === key);
+                if (index !== -1) {
+                    // Overwrite existing attribute if it already exists.
+                    items[index] = attribute;
                 }
-                if (piece.endsWith("\"")) {
-                    piece = piece.substring(0, piece.length - 1);
+                else {
+                    // Add new attribute if it doesn't exist.
+                    items.push(attribute);
                 }
-                broken[i] = piece;
+                return;
             }
-            return broken;
+            // If we're not at the end of the path, dig further.
+            let item = items.find((i) => i.Key === key);
+            if (!item) {
+                item = { Key: key, Structure: [] };
+                items.push(item);
+            }
+            if (!item.Structure) {
+                item.Structure = [];
+            }
+            AddAttribute(item.Structure, path.slice(1), attribute);
         }
-        PathUtils.Parse = Parse;
+        EntityAttribute.AddAttribute = AddAttribute;
+    })(exports.EntityAttribute || (exports.EntityAttribute = {}));
+
+    (function (EntityType) {
         /**
-         * Wraps an array of strings into a Nextspace string path.
-         * @param path
+         * Gets an entity type record.
+         * @param params
          * @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];
-                tmp += section;
-                if (i < path.length - 1) {
-                    tmp += "\"/\"";
+        function Get(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, entityTypeId: typeId, req: reqParams, expandLODs } = params;
+                if (!typeId) {
+                    throw ("Type ID is required.");
+                }
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                const key = GetCacheKey(typeId, expandLODs);
+                const cache = api.GetCacheItem(key, reqParams);
+                if (cache === null || cache === void 0 ? void 0 : cache.found) {
+                    return cache.data;
                 }
-            }
-            tmp += "\"";
-            return tmp;
+                const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const urlParams = new URLSearchParams();
+                        if (expandLODs) {
+                            urlParams.append("Expand", "LOD");
+                        }
+                        const url = `entitytype/${typeId}?${urlParams.toString()}`;
+                        const data = yield api.GET(url, exports.Api.PrepReqParams(reqParams));
+                        appendInternalAttrSchema(data);
+                        res({
+                            entityType: data
+                        });
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                }));
+                api.SetCacheItem({
+                    key,
+                    value: prom,
+                    req: reqParams
+                });
+                return prom;
+            });
         }
-        PathUtils.Wrap = Wrap;
+        EntityType.Get = Get;
         /**
-         * Parses a Nextspace legacy string path into an array of strings.
-         * @param str
-         * @returns
+         * Deletes an entity type record and all corresponding entities.
+         * @param params
          */
-        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[i];
-                if (piece.startsWith("\"")) {
-                    piece = piece.substring(1);
+        function Delete(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, entityTypeId: typeId, req: reqParams } = params;
+                if (!typeId) {
+                    throw ("Type ID is required.");
                 }
-                if (piece.endsWith("\"")) {
-                    piece = piece.substring(0, piece.length - 1);
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                broken[i] = piece;
-            }
-            return broken;
+                yield api.DELETE(`entitytype/${typeId}`, exports.Api.PrepReqParams(reqParams));
+                api.Cache.RemoveByStartsWith(GetCacheKey(typeId));
+                api.Cache.RemoveByStartsWith(GetListCacheKey());
+            });
         }
-        PathUtils.ParseLegacy = ParseLegacy;
-    })(exports.PathUtils || (exports.PathUtils = {}));
-
-    (function (EntityHistoricData) {
+        EntityType.Delete = Delete;
         /**
-         * Returns historic data for an array of Entity IDs.
-         * A maximum number of records will be returned per Entity ID, this information is returned in the response.
+         * Gets a list of entity types.
          * @param params
          * @returns
          */
         function GetList(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { entityIds, attrKey, dateTimeFrom, dateTimeTo, api, req } = params;
-                // Save time and just return a none response if no entity IDs are provided.
-                if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
-                    return {
-                        limitPerEntity: 0,
-                        recordsByIds: {}
-                    };
-                }
+                let { entityTypeIds, api, req: reqParams, parentTypeId, expandSettings, search, expandLODs } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                let attrKeyStr = null;
-                if (attrKey) {
-                    if (typeof attrKey != "string") {
-                        attrKeyStr = exports.PathUtils.Wrap(attrKey);
-                    }
-                    else {
-                        attrKeyStr = attrKey;
-                    }
+                const cache = api.GetCacheItem(GetListCacheKey({
+                    typeIds: entityTypeIds,
+                    parentTypeId,
+                    expandLODs,
+                    expandSettings,
+                    search
+                }), reqParams);
+                if (cache === null || cache === void 0 ? void 0 : cache.found) {
+                    return cache.data;
                 }
-                // If we have more than 100 Entity IDs we'll have to split the request to avoid a URL that is too long.
-                const MAX_IDS = 100;
-                // We will recursively call this function to get all the data.
-                // Then merge at the end and return.
-                if (entityIds.length > MAX_IDS) {
-                    const reqs = [];
-                    // Making the ID batches.
-                    // If this is too long we can end up in a loop.
-                    const splitEntityIds = [];
-                    for (let i = 0; i < entityIds.length; i += MAX_IDS) {
-                        const batchIds = entityIds.slice(i, i + MAX_IDS);
-                        // Detecting this early to avoid infinite loops.
-                        if (batchIds.length > MAX_IDS) {
-                            throw new Error("Nextspace Developer Error: EntityHistoricData.GetList() has too many Entity IDs. Please contact support.");
+                const req = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        // If we have an array of typeIds then we'll request in batches to avoid overflowing the URL.
+                        const BATCH_SIZE = 20;
+                        const reqs = [];
+                        if (entityTypeIds) {
+                            for (let i = 0; i < entityTypeIds.length; i += BATCH_SIZE) {
+                                const batch = entityTypeIds.slice(i, i + BATCH_SIZE);
+                                const urlParams = new URLSearchParams();
+                                for (const id of batch) {
+                                    urlParams.append("ID", id);
+                                }
+                                if (parentTypeId) {
+                                    urlParams.append("ParentTypeID", parentTypeId);
+                                }
+                                if (expandSettings && expandLODs) {
+                                    urlParams.append("Expand", "true");
+                                }
+                                else if (expandSettings) {
+                                    urlParams.append("Expand", "Schema");
+                                }
+                                else if (expandLODs) {
+                                    urlParams.append("Expand", "LOD");
+                                }
+                                if (search) {
+                                    urlParams.append("Search", search);
+                                }
+                                reqs.push(api.GET("entitytypes?" + urlParams.toString(), exports.Api.PrepReqParams(reqParams)));
+                            }
                         }
-                        splitEntityIds.push(batchIds);
-                    }
-                    for (const splitEntityId of splitEntityIds) {
-                        reqs.push(GetList({
-                            entityIds: splitEntityId,
-                            attrKey: attrKeyStr,
-                            dateTimeFrom: dateTimeFrom,
-                            dateTimeTo: dateTimeTo,
-                            api: api,
-                            req: req
-                        }));
-                    }
-                    const res = yield Promise.all(reqs);
-                    const recordsByIds = {};
-                    let limitPerEntity = 0;
-                    for (const r of res) {
-                        limitPerEntity = r.limitPerEntity;
-                        for (const entityId in r.recordsByIds) {
-                            recordsByIds[entityId] = r.recordsByIds[entityId];
+                        else {
+                            const urlParams = new URLSearchParams();
+                            if (parentTypeId) {
+                                urlParams.append("ParentTypeID", parentTypeId);
+                            }
+                            if (expandSettings && expandLODs) {
+                                urlParams.append("Expand", "true");
+                            }
+                            else if (expandSettings) {
+                                urlParams.append("Expand", "Schema");
+                            }
+                            else if (expandLODs) {
+                                urlParams.append("Expand", "LOD");
+                            }
+                            if (search) {
+                                urlParams.append("Search", search);
+                            }
+                            reqs.push(api.GET("entitytypes?" + urlParams.toString(), exports.Api.PrepReqParams(reqParams)));
+                        }
+                        const data = yield Promise.all(reqs);
+                        // Populate array, while checking for already added types.
+                        const types = [];
+                        for (const item of data) {
+                            for (const type of item.Items) {
+                                appendInternalAttrSchema(type);
+                                if (!types.find(x => x.ID == type.ID)) {
+                                    types.push(type);
+                                }
+                            }
                         }
+                        res({
+                            entityTypes: types
+                        });
                     }
-                    // Returning merged data.
-                    return {
-                        recordsByIds: recordsByIds,
-                        limitPerEntity: limitPerEntity
-                    };
+                    catch (e) {
+                        rej(e);
+                    }
+                }));
+                if (!parentTypeId) {
+                    api.SetCacheItem({
+                        key: GetListCacheKey({
+                            typeIds: entityTypeIds,
+                            parentTypeId,
+                            expandSettings,
+                            expandLODs,
+                            search
+                        }),
+                        value: req,
+                        req: reqParams,
+                        duration: 60 * 5 // 5 minutes.
+                    });
                 }
-                const cacheKey = GetListCacheKey(entityIds, attrKeyStr, dateTimeFrom, dateTimeTo);
-                const cached = api.GetCacheItem(cacheKey, req);
-                if (cached === null || cached === void 0 ? void 0 : cached.found) {
-                    return cached.data;
+                return req;
+            });
+        }
+        EntityType.GetList = GetList;
+        /**
+         * Updates or creates an entity type record.
+         * @param params
+         * @returns
+         */
+        function Update(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, entityType: data, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                const urlParams = new URLSearchParams();
-                for (const entityId of entityIds) {
-                    urlParams.append("entityId", entityId);
+                if (!data) {
+                    data = {};
                 }
-                if (attrKeyStr) {
-                    urlParams.append("attrKey", attrKeyStr);
+                if (!data.ID) {
+                    data.ID = exports.ObjectUtils.UId();
                 }
-                urlParams.append("dateTimeFrom", dateTimeFrom);
-                urlParams.append("dateTimeTo", dateTimeTo);
-                const prom = api.GET(`v1/entity/historicData?${urlParams.toString()}`, exports.Api.PrepReqParams(req));
-                api.SetCacheItem({
-                    key: cacheKey,
-                    value: prom,
-                    req: req,
-                    // Short cache. 30 seconds.
-                    duration: 30000
-                });
-                return prom;
+                if (!data.Name) {
+                    data.Name = data.ID;
+                }
+                // Will not append if we're not updating schema (not specified).
+                appendInternalAttrSchema(data);
+                const res = yield api.POST(`entitytype/${data.ID}`, data, exports.Api.PrepReqParams(reqParams));
+                api.Cache.RemoveByStartsWith(GetCacheKey(data.ID));
+                api.Cache.RemoveByStartsWith(GetListCacheKey());
+                // Useful to append afterwards as newly created Entity Types may have it missing.
+                // This makes our UI apps not have to check for default attribute existence.
+                appendInternalAttrSchema(res);
+                return {
+                    entityType: res
+                };
             });
         }
-        EntityHistoricData.GetList = GetList;
+        EntityType.Update = Update;
         /**
-         * Returns historic data statistics for an array of Entity IDs.
+         * Starts a re-index background action on a specified Entity Type.
+         * This will ensure searchable data follows the current schema version.
+         * This will also perform certain data cleanup so that the data is consistent.
          * @param params
          * @returns
          */
-        function GetStats(params) {
+        function ReIndex(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { entityIds, entityTypeId, api, req } = params;
-                // Save time and just return a none response if no entity IDs or type ID are provided.
-                if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length) && !entityTypeId) {
-                    return {
-                        stats: []
-                    };
-                }
+                let { api, entityTypeId: typeId, req, dataTransformId, reSaveAll } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                req = exports.Api.PrepReqParams(req);
-                const cacheKey = GetStatsCacheKey(entityIds, entityTypeId);
-                const cached = api.GetCacheItem(cacheKey, req);
-                if (cached === null || cached === void 0 ? void 0 : cached.found) {
-                    return cached.data;
+                const urlParams = new URLSearchParams();
+                if (dataTransformId) {
+                    urlParams.append("dataTransformID", String(dataTransformId));
                 }
-                const prom = yield api.POST("v1/entity/historicData/stats", {
-                    entityIds: entityIds,
-                    entityTypeId: entityTypeId
-                }, req);
-                api.SetCacheItem({
-                    key: cacheKey,
-                    value: prom,
-                    req: req,
-                    // Short cache. 60 seconds.
-                    duration: 60000
-                });
-                return prom;
+                if (reSaveAll) {
+                    urlParams.append("reSaveAll", "true");
+                }
+                let url = typeId ? `entityType/${typeId}/reindex` : "entities/reindex";
+                url += "?" + urlParams.toString();
+                req = exports.Api.PrepReqParams(req);
+                const res = yield api.POST(url, {}, req);
+                return {
+                    pendingActionId: res.PendingActionID
+                };
             });
         }
-        EntityHistoricData.GetStats = GetStats;
+        EntityType.ReIndex = ReIndex;
         /**
-         * Creates or updates historic data records.
-         * Please note that the expected input/output does not include internal fields found inside the "Bruce" attribute.
+         * Counts the total number of Entities in an Entity Type.
          * @param params
          * @returns
          */
-        function Update(params) {
-            var _a;
+        function Count(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { records, api, req } = params;
-                // Save time and just return a none response if no records are provided.
-                if (!(records === null || records === void 0 ? void 0 : records.length)) {
-                    return {
-                        records: []
-                    };
+                let { entityTypeId, api, req } = params;
+                if (!entityTypeId) {
+                    throw ("Type ID is required.");
                 }
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                const res = yield api.POST("v1/entity/historicData", {
-                    records: records
-                }, exports.Api.PrepReqParams(req));
-                // Kill cache for every unique attrKey.
-                let attrKeys = records.map(r => r.attrKey);
-                attrKeys = attrKeys.filter((v, i) => attrKeys.indexOf(v) === i);
-                for (const attrKey of attrKeys) {
-                    api.Cache.RemoveByContains(exports.Entity.GetHistoricContainsKey(attrKey));
-                }
-                // Kill any stats cache that includes any of the Entity IDs.
-                if ((_a = res.records) === null || _a === void 0 ? void 0 : _a.length) {
-                    const entityIds = res.records.map(r => r.entityId).filter((v, i) => v && res.records.indexOf(v) === i);
-                    ClearCacheByEntityIds(api, entityIds);
-                }
-                return res;
+                const url = `entityType/${entityTypeId}/entitiesCount`;
+                const { TotalEntities } = yield api.GET(url, exports.Api.PrepReqParams(req));
+                return TotalEntities;
+            });
+        }
+        EntityType.Count = Count;
+        /**
+         * Returns cache identifier for an entity type.
+         * Example: {
+         *     const api: BruceApi.Api = ...;
+         *     const key = GetCacheKey("abc");
+         *     api.Cache.Remove(key);
+         * }
+         * @param typeId
+         * @param expandLODs
+         * @returns
+         */
+        function GetCacheKey(typeId, expandLODs) {
+            let key = `${exports.Api.ECacheKey.EntityType}${exports.Api.ECacheKey.Id}${typeId}`;
+            if (expandLODs) {
+                key += "_LOD_" + expandLODs;
+            }
+            return key;
+        }
+        EntityType.GetCacheKey = GetCacheKey;
+        /**
+         * Returns cache identifier for a list of entity types.
+         * Example: {
+         *     const api: BruceApi.Api = ...;
+         *     const key = GetListCacheKey();
+         *     api.Cache.Remove(key);
+         * }
+         * @param typeIds
+         * @returns
+         */
+        function GetListCacheKey(params) {
+            if (!params) {
+                params = {};
+            }
+            let { typeIds, expandSettings, parentTypeId, expandLODs, search } = params;
+            let key = exports.Api.ECacheKey.EntityType;
+            if (!typeIds) {
+                typeIds = [];
+            }
+            key += (typeIds.length ? exports.Api.ECacheKey.Id : "") + typeIds.join(",");
+            if (parentTypeId) {
+                key += "_PARENT_" + parentTypeId;
+            }
+            if (!expandSettings) {
+                expandSettings = false;
+            }
+            if (!expandLODs) {
+                expandLODs = false;
+            }
+            key += "_SCHEMA_" + expandSettings;
+            key += "_LOD_" + expandLODs;
+            if (search) {
+                key += "_SEARCH_" + search;
+            }
+            return key;
+        }
+        EntityType.GetListCacheKey = GetListCacheKey;
+    })(exports.EntityType || (exports.EntityType = {}));
+    /**
+     * Adds expected internal structure items even if they aren't there.
+     * Our API should be including them but this is a safety net.
+     * @param type
+     */
+    function appendInternalAttrSchema(type) {
+        // Schema not loaded. We'll ignore.
+        if (type == null || type.DataSchema == null) {
+            return;
+        }
+        // Append internal attributes.
+        if (!type.DataSchema.Structure) {
+            type.DataSchema.Structure = [];
+        }
+        let bruce = type.DataSchema.Structure.find(a => a.Key == "Bruce");
+        if (!bruce) {
+            bruce = {
+                Key: "Bruce",
+                Name: "Bruce",
+                Description: "Nextspace internal attributes.",
+                Type: exports.EntityAttribute.EType.Structure,
+                Structure: [],
+                IsIndexed: true,
+                IsImportant: false
+            };
+            type.DataSchema.Structure.push(bruce);
+        }
+        if (!bruce.Structure) {
+            bruce.Structure = [];
+        }
+        // Append any missing internal attributes.
+        if (!bruce.Structure.find(x => x.Key == "ID")) {
+            bruce.Structure.push({
+                Key: "ID",
+                Name: "ID",
+                Description: "Unique identifier for the Entity.",
+                Type: exports.EntityAttribute.EType.String,
+                IsIndexed: true,
+                IsImportant: true
+            });
+        }
+        if (!bruce.Structure.find(x => x.Key == "Location")) {
+            bruce.Structure.push({
+                Key: "Location",
+                Name: "Location",
+                Description: "Location data.",
+                Type: exports.EntityAttribute.EType.Structure,
+                Structure: [
+                    {
+                        Key: "latitude",
+                        Name: "Latitude",
+                        Type: exports.EntityAttribute.EType.Double,
+                        IsIndexed: true,
+                        IsImportant: false
+                    },
+                    {
+                        Key: "longitude",
+                        Name: "Longitude",
+                        Type: exports.EntityAttribute.EType.Double,
+                        IsIndexed: true,
+                        IsImportant: false
+                    },
+                    {
+                        Key: "altitude",
+                        Name: "Altitude",
+                        Type: exports.EntityAttribute.EType.Double,
+                        IsIndexed: true,
+                        IsImportant: false
+                    }
+                ]
+            });
+        }
+        if (!bruce.Structure.find(x => x.Key == "Boundaries")) {
+            bruce.Structure.push({
+                Key: "Boundaries",
+                Name: "Boundaries",
+                Description: "Boundaries data.",
+                Type: exports.EntityAttribute.EType.Structure,
+                Structure: [
+                    {
+                        Key: "minLongitude",
+                        Name: "Min Longitude",
+                        Type: exports.EntityAttribute.EType.Double,
+                        IsIndexed: true,
+                        IsImportant: false
+                    },
+                    {
+                        Key: "maxLongitude",
+                        Name: "Max Longitude",
+                        Type: exports.EntityAttribute.EType.Double,
+                        IsIndexed: true,
+                        IsImportant: false
+                    },
+                    {
+                        Key: "minLatitude",
+                        Name: "Min Latitude",
+                        Type: exports.EntityAttribute.EType.Double,
+                        IsIndexed: true,
+                        IsImportant: false
+                    },
+                    {
+                        Key: "maxLatitude",
+                        Name: "Max Latitude",
+                        Type: exports.EntityAttribute.EType.Double,
+                        IsIndexed: true,
+                        IsImportant: false
+                    },
+                    {
+                        Key: "minAltitude",
+                        Name: "Min Altitude",
+                        Type: exports.EntityAttribute.EType.Double,
+                        IsIndexed: true,
+                        IsImportant: false
+                    },
+                    {
+                        Key: "maxAltitude",
+                        Name: "Max Altitude",
+                        Type: exports.EntityAttribute.EType.Double,
+                        IsIndexed: true,
+                        IsImportant: false
+                    }
+                ]
             });
         }
-        EntityHistoricData.Update = Update;
-        /**
-         * Deletes historic data records for an array of Entity IDs.
-         * This deletes all records within a provided key + range.
-         * @param params
-         * @returns
-         */
-        function Delete(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let { entityIds, attrKey, dateTimeFrom, dateTimeTo, api, req } = params;
-                if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
-                    return;
-                }
-                if (!api) {
-                    api = exports.ENVIRONMENT.Api().GetBruceApi();
-                }
-                if (!attrKey || !dateTimeFrom || !dateTimeTo) {
-                    throw new Error("Invalid parameters provided.");
-                }
-                if (typeof attrKey != "string") {
-                    attrKey = exports.PathUtils.Wrap(attrKey);
-                }
-                const urlParams = new URLSearchParams();
-                for (const entityId of entityIds) {
-                    urlParams.append("entityId", entityId);
-                }
-                urlParams.append("attrKey", attrKey);
-                urlParams.append("dateTimeFrom", dateTimeFrom);
-                urlParams.append("dateTimeTo", dateTimeTo);
-                yield api.DELETE(`v1/entity/historicData?${urlParams.toString()}`, exports.Api.PrepReqParams(req));
-                // Kill cache for all Entity cached Entity records related to the attrKey.
-                api.Cache.RemoveByContains(exports.Entity.GetHistoricContainsKey(attrKey));
-                // Kill any stats cache that includes any of the Entity IDs.
-                ClearCacheByEntityIds(api, entityIds);
+        if (!bruce.Structure.find(x => x.Key == "Transform")) {
+            bruce.Structure.push({
+                Key: "Transform",
+                Name: "Transform",
+                Description: "Transform data.",
+                IsIndexed: true,
+                IsImportant: false,
+                Type: exports.EntityAttribute.EType.Structure,
+                Structure: [
+                    {
+                        Key: "heading",
+                        Name: "Heading",
+                        IsIndexed: true,
+                        IsImportant: false,
+                        Type: exports.EntityAttribute.EType.Double
+                    },
+                    {
+                        Key: "pitch",
+                        Name: "Pitch",
+                        IsIndexed: true,
+                        IsImportant: false,
+                        Type: exports.EntityAttribute.EType.Double
+                    },
+                    {
+                        Key: "roll",
+                        Name: "Roll",
+                        IsIndexed: true,
+                        IsImportant: false,
+                        Type: exports.EntityAttribute.EType.Double
+                    },
+                    {
+                        Key: "scale",
+                        Name: "Scale",
+                        IsIndexed: true,
+                        IsImportant: false,
+                        Type: exports.EntityAttribute.EType.Double
+                    }
+                ]
             });
         }
-        EntityHistoricData.Delete = Delete;
-        function GetListCacheKey(entityIds, attrKey, dateTimeFrom, dateTimeTo) {
-            return exports.Api.ECacheKey.EntityHistoricDataRec + exports.Api.ECacheKey.Id + entityIds.join(",") + exports.Api.ECacheKey.Id + attrKey + exports.Api.ECacheKey.Id + dateTimeFrom + exports.Api.ECacheKey.Id + dateTimeTo;
-        }
-        EntityHistoricData.GetListCacheKey = GetListCacheKey;
-        function GetStatsCacheKey(entityIds, typeId) {
-            if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
-                entityIds = [];
-            }
-            if (!typeId) {
-                typeId = "";
-            }
-            return exports.Api.ECacheKey.EntityHistoricDataStats + exports.Api.ECacheKey.Id + typeId + exports.Api.ECacheKey.Id + entityIds.join(",");
-        }
-        EntityHistoricData.GetStatsCacheKey = GetStatsCacheKey;
-        function ClearCacheByEntityIds(api, entityIds) {
-            if (!api || !(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
-                return;
-            }
-            const REC_KEY_PREFIX = exports.Api.ECacheKey.EntityHistoricDataRec + exports.Api.ECacheKey.Id;
-            const STATS_KEY_PREFIX = exports.Api.ECacheKey.EntityHistoricDataStats + exports.Api.ECacheKey.Id;
-            api.Cache.RemoveByCallback((key) => {
-                let keyStr = String(key);
-                if (!keyStr.startsWith(STATS_KEY_PREFIX) && !keyStr.startsWith(REC_KEY_PREFIX)) {
-                    return false;
-                }
-                // Shorten to speed up the next step.
-                keyStr = keyStr.replace(STATS_KEY_PREFIX, "").replace(REC_KEY_PREFIX, "");
-                // Look for any matching Entity IDs.
-                for (let i = 0; i < entityIds.length; i++) {
-                    const entityId = entityIds[i];
-                    if (keyStr.includes(entityId)) {
-                        return true;
-                    }
-                }
-                return false;
+        if (!bruce.Structure.find(x => x.Key == "VectorGeometry")) {
+            bruce.Structure.push({
+                Key: "VectorGeometry",
+                Name: "Geometry",
+                Description: "Geometry data.",
+                Type: exports.EntityAttribute.EType.Geometry,
+                IsIndexed: true,
+                IsImportant: false
             });
         }
-        EntityHistoricData.ClearCacheByEntityIds = ClearCacheByEntityIds;
-    })(exports.EntityHistoricData || (exports.EntityHistoricData = {}));
+        // Filter out migrated/outdated ones.
+        // Removed from root and the internal structure.
+        const OUTDATED_INTERNAL = ["position", "geometry", "location", "boundaries", "transform"];
+        bruce.Structure = bruce.Structure.filter(a => !OUTDATED_INTERNAL.includes(a.Key));
+        type.DataSchema.Structure = type.DataSchema.Structure.filter(a => !OUTDATED_INTERNAL.includes(a.Key));
+    }
 
     (function (Entity) {
         let EOutlineKind;
@@ -3720,38 +3731,48 @@
                             }
                             expand += expandStr;
                         }
-                        if (expand) {
+                        if (expand === null || expand === void 0 ? void 0 : expand.length) {
                             urlParams.append("Expand", expand);
                         }
                         if (expandLODs) {
                             urlParams.append("LODType", "*");
                         }
                         if (entityTypeId) {
-                            urlParams.append("BruceEntityType", entityTypeId);
+                            urlParams.append("Type", entityTypeId);
                         }
                         if (historicKey) {
-                            urlParams.set("historicKey", historicKey);
+                            urlParams.set("HistoricKey", historicKey);
                         }
                         if (historicFrom) {
-                            urlParams.set("historicFrom", historicFrom);
+                            urlParams.set("HistoricFrom", historicFrom);
                         }
                         if (historicTo) {
-                            urlParams.set("historicTo", historicTo);
+                            urlParams.set("HistoricTo", historicTo);
                         }
                         if (historicPoint) {
-                            urlParams.set("historicPoint", historicPoint);
+                            urlParams.set("HistoricPoint", historicPoint);
                         }
                         if (schemaId) {
-                            urlParams.set("schema", schemaId);
+                            urlParams.set("Schema", schemaId);
                         }
                         if (scenario && String(scenario) != "0") {
                             urlParams.set("Scenario", String(scenario));
                         }
-                        urlParams.set("hasMigrated", String(Boolean(migrated)));
-                        const data = yield api.GET(`entity/${entityId}?${urlParams.toString()}`, exports.Api.PrepReqParams(reqParams));
-                        res({
-                            entity: data
-                        });
+                        // v3 endpoint.
+                        if (migrated) {
+                            const data = yield api.GET(`v3/entity/${entityId}?${urlParams.toString()}`, exports.Api.PrepReqParams(reqParams));
+                            res({
+                                entity: data
+                            });
+                        }
+                        // v1 endpoint.
+                        else {
+                            urlParams.set("hasMigrated", "false");
+                            const data = yield api.GET(`entity/${entityId}?${urlParams.toString()}`, exports.Api.PrepReqParams(reqParams));
+                            res({
+                                entity: data
+                            });
+                        }
                     }
                     catch (e) {
                         rej(e);
@@ -3866,6 +3887,14 @@
                         reqData["Expand"] = "comment";
                     }
                 }
+                if (expandSources) {
+                    if (reqData["Expand"]) {
+                        reqData["Expand"] += ",source";
+                    }
+                    else {
+                        reqData["Expand"] = "source";
+                    }
+                }
                 if (expandStr) {
                     if (reqData["Expand"]) {
                         reqData["Expand"] += `,${expandStr}`;
@@ -3877,33 +3906,38 @@
                 if (expandLODs) {
                     reqData["LODType"] = "*";
                 }
-                if (expandSources) {
-                    reqData["ExpandSources"] = true;
-                }
                 if (historicKey) {
-                    reqData["historicKey"] = historicKey;
+                    reqData["HistoricKey"] = historicKey;
                 }
                 if (historicFrom) {
-                    reqData["historicFrom"] = historicFrom;
+                    reqData["HistoricFrom"] = historicFrom;
                 }
                 if (historicTo) {
-                    reqData["historicTo"] = historicTo;
+                    reqData["HistoricTo"] = historicTo;
                 }
                 if (historicPoint) {
-                    reqData["historicPoint"] = historicPoint;
+                    reqData["HistoricPoint"] = historicPoint;
                 }
                 if (scenario) {
                     reqData["Scenario"] = scenario;
                 }
                 const urlParams = new URLSearchParams();
                 if (schemaId) {
-                    urlParams.set("schema", schemaId);
+                    urlParams.set("Schema", schemaId);
                 }
                 if (maxSearchTimeSec) {
                     urlParams.set("MaxSearchTimeSec", String(Math.ceil(maxSearchTimeSec)));
                 }
-                urlParams.set("hasMigrated", String(Boolean(migrated)));
-                const url = `entities?${urlParams.toString()}`;
+                let url = null;
+                // v3 endpoint.
+                if (migrated) {
+                    url = `v3/getEntities?${urlParams.toString()}`;
+                }
+                // v1 endpoint.
+                else {
+                    urlParams.set("hasMigrated", "false");
+                    url = `entities?${urlParams.toString()}`;
+                }
                 const reqs = [];
                 if (reqIds.length > 0) {
                     const req = api.POST(url, reqData, exports.Api.PrepReqParams(reqParams));
@@ -3964,7 +3998,7 @@
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                yield api.DELETE(`entity/${entityId}`, exports.Api.PrepReqParams(reqParams));
+                yield api.DELETE(`v3/entity/${entityId}`, exports.Api.PrepReqParams(reqParams));
                 api.Cache.RemoveByContains(GetContainsKey(entityId));
                 exports.EntityHistoricData.ClearCacheByEntityIds(api, [entityId]);
             });
@@ -3983,7 +4017,7 @@
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                yield api.POST("deleteEntities", {
+                yield api.POST("v3/deleteEntities", {
                     Items: entityIds
                 }, exports.Api.PrepReqParams(reqParams));
                 for (let i = 0; i < entityIds.length; i++) {
@@ -4000,18 +4034,20 @@
          * @returns
          */
         function Update(params) {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d, _e, _f, _g;
             return __awaiter(this, void 0, void 0, function* () {
                 let { api, entity: data, entities, override, req: reqParams, migrated } = params;
                 if (migrated == null || migrated == undefined) {
                     // Changed to default = true. 18th April 2025.
                     migrated = true;
                 }
-                // Bulk save.
+                // Bulk save. Always using a v3 endpoint as v1 did not have a bulk save.
                 if (entities === null || entities === void 0 ? void 0 : entities.length) {
                     // If the Entities don't have IDs, then they must have a Type ID.
                     for (let i = 0; i < entities.length; i++) {
                         const entity = entities[i];
+                        // If ID is missing then we can assume we're making a new record.
+                        // This means a type ID must be supplied.
                         if (!((_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID) && !((_b = entity.Bruce) === null || _b === void 0 ? void 0 : _b["EntityType.ID"])) {
                             throw ("Entity Type ID is required for new Entity records.");
                         }
@@ -4041,18 +4077,43 @@
                     if (!data && (entities === null || entities === void 0 ? void 0 : entities.length)) {
                         data = entities[0];
                     }
-                    if (!((_d = data === null || data === void 0 ? void 0 : data.Bruce) === null || _d === void 0 ? void 0 : _d["EntityType.ID"])) {
-                        throw ("Entity Type ID is required.");
+                    // If ID is missing then we can assume we're making a new record.
+                    // This means a type ID must be supplied.
+                    if (!((_d = data === null || data === void 0 ? void 0 : data.Bruce) === null || _d === void 0 ? void 0 : _d["EntityType.ID"]) && !((_e = data === null || data === void 0 ? void 0 : data.Bruce) === null || _e === void 0 ? void 0 : _e.ID)) {
+                        throw ("Entity Type ID is required for new records.");
                     }
                     if (!api) {
                         api = exports.ENVIRONMENT.Api().GetBruceApi();
                     }
-                    if (!((_e = data === null || data === void 0 ? void 0 : data.Bruce) === null || _e === void 0 ? void 0 : _e.ID)) {
-                        data.Bruce = Object.assign(Object.assign({}, data.Bruce), { ID: exports.ObjectUtils.UId() });
+                    /*
+                    Getting the API to always generate IDs when UI hasn't pre-generated them :)
+                    if (!data?.Bruce?.ID) {
+                        data.Bruce = {
+                            ...data.Bruce,
+                            ID: ObjectUtils.UId()
+                        };
+                    }
+                    */
+                    const entityId = (_f = data.Bruce) === null || _f === void 0 ? void 0 : _f.ID;
+                    const typeId = (_g = data.Bruce) === null || _g === void 0 ? void 0 : _g["EntityType.ID"];
+                    let reqUrl = null;
+                    // Create or update.
+                    // Though API also looks for ID in body...
+                    if (entityId) {
+                        reqUrl = migrated ? `v3/entity/${data.Bruce.ID}` : `entity/${data.Bruce.ID}`;
                     }
-                    let reqUrl = `entity/${data.Bruce.ID}/?dataoverride=${override}&BruceEntityType=${data.Bruce["EntityType.ID"]}`;
-                    if (migrated) {
-                        reqUrl += "&hasMigrated=true";
+                    else {
+                        reqUrl = migrated ? "v3/entity" : "entity";
+                    }
+                    // Override = Are we doing an update or replace?
+                    reqUrl += `?Override=${override}`;
+                    // Updating through a known type.
+                    if (typeId) {
+                        reqUrl += `&Type=${data.Bruce["EntityType.ID"]}`;
+                    }
+                    // Explicit in case API changes default logic for v1 endpoint.
+                    if (!migrated) {
+                        reqUrl += "&hasMigrated=false";
                     }
                     const res = yield api.POST(reqUrl, data, exports.Api.PrepReqParams(reqParams));
                     api.Cache.RemoveByContains(GetContainsKey(data.Bruce.ID));
@@ -4384,18 +4445,17 @@
                     OrderBy: filter.orderBy,
                     Filter: requestFilter,
                     LODType: filter.lodCategoryId,
-                    BruceEntityType: (!filter.entityTypeId ? null : filter.entityTypeId),
+                    Type: (!filter.entityTypeId ? null : filter.entityTypeId),
                     PageIndex: filter.pageIndex,
                     PageSize: filter.pageSize,
-                    historicKey: historicKey,
-                    historicFrom: historicFrom,
-                    historicTo: historicTo,
-                    historicPoint: historicPoint,
-                    ExpandSources: expandSources,
+                    HistoricKey: historicKey,
+                    HistoricFrom: historicFrom,
+                    HistoricTo: historicTo,
+                    HistoricPoint: historicPoint,
                     Scenario: scenario
                 };
-                if (expandLocation || expandRelations || expandImports || expandEntityType || expandComments || expandStr || expandAttachments) {
-                    let expand = "";
+                let expand = "";
+                {
                     if (expandLocation) {
                         expand += "location";
                     }
@@ -4415,7 +4475,7 @@
                         if (expand) {
                             expand += ",";
                         }
-                        expand += "EntityType";
+                        expand += "entityType";
                     }
                     if (expandComments) {
                         if (expand) {
@@ -4429,15 +4489,21 @@
                         }
                         expand += "attachment";
                     }
+                    if (expandSources) {
+                        if (expand) {
+                            expand += ",";
+                        }
+                        expand += "source";
+                    }
                     if (expandStr) {
                         if (expand) {
                             expand += ",";
                         }
                         expand += expandStr;
                     }
-                    if (expand) {
-                        body["Expand"] = expand;
-                    }
+                }
+                if (expand) {
+                    body["Expand"] = expand;
                 }
                 let totalCount;
                 let entities = [];
@@ -4462,8 +4528,8 @@
                     if (body.LODType) {
                         urlParams.set("LODType", body.LODType);
                     }
-                    if (body.BruceEntityType) {
-                        urlParams.set("BruceEntityType", typeof body.BruceEntityType == "string" ? body.BruceEntityType : body.BruceEntityType.join(","));
+                    if (body.Type) {
+                        urlParams.set("Type", typeof body.Type == "string" ? body.Type : body.Type.join(","));
                     }
                     if (body.PageIndex) {
                         urlParams.set("PageIndex", String(body.PageIndex));
@@ -4471,72 +4537,23 @@
                     if (body.PageSize) {
                         urlParams.set("PageSize", String(body.PageSize));
                     }
-                    let expand = "";
-                    if (expandRelations) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Relation";
-                    }
-                    if (expandLocation) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Location";
-                    }
-                    if (expandImports) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Import";
-                    }
-                    if (expandSources) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Source";
-                    }
-                    if (expandEntityType) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "EntityType";
-                    }
-                    if (expandComments) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Comment";
-                    }
-                    if (expandAttachments) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Attachment";
-                    }
-                    if (expandStr) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += expandStr;
-                    }
-                    if (expand.length) {
+                    if (expand === null || expand === void 0 ? void 0 : expand.length) {
                         urlParams.append("Expand", expand);
                     }
                     if (historicKey) {
-                        urlParams.set("historicKey", historicKey);
+                        urlParams.set("HistoricKey", historicKey);
                     }
                     if (historicFrom) {
-                        urlParams.set("historicFrom", historicFrom);
+                        urlParams.set("HistoricFrom", historicFrom);
                     }
                     if (historicTo) {
-                        urlParams.set("historicTo", historicTo);
+                        urlParams.set("HistoricTo", historicTo);
                     }
                     if (historicPoint) {
-                        urlParams.set("historicPoint", historicPoint);
+                        urlParams.set("HistoricPoint", historicPoint);
                     }
                     if (schemaId) {
-                        urlParams.set("schema", schemaId);
+                        urlParams.set("Schema", schemaId);
                     }
                     if (scenario && String(scenario) != "0") {
                         urlParams.set("Scenario", String(scenario));
@@ -4544,8 +4561,22 @@
                     if (maxSearchTimeSec) {
                         urlParams.set("MaxSearchTimeSec", String(Math.ceil(maxSearchTimeSec)));
                     }
-                    urlParams.set("hasMigrated", String(Boolean(migrated)));
-                    let url = analysis ? "entities/summary" : "entities";
+                    let url = null;
+                    // v3 endpoint.
+                    if (migrated) {
+                        url = analysis ? "v3/entities" : "v3/entities";
+                        if (analysis) {
+                            urlParams.delete("PageIndex");
+                            urlParams.delete("PageSize");
+                            urlParams.append("PageIndex", "-1");
+                            urlParams.append("PageSize", "-1");
+                        }
+                    }
+                    // v1 endpoint.
+                    else {
+                        urlParams.set("hasMigrated", "false");
+                        url = analysis ? "entities/summary" : "entities";
+                    }
                     url += "?" + urlParams.toString();
                     const urlStr = api.ConstructUrl({
                         cdn: !analysis && viaCdn,
@@ -4565,56 +4596,7 @@
                 }
                 else {
                     const urlParams = new URLSearchParams();
-                    let expand = "";
-                    if (expandRelations) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Relation";
-                    }
-                    if (expandLocation) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Location";
-                    }
-                    if (expandImports) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Import";
-                    }
-                    if (expandSources) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Source";
-                    }
-                    if (expandEntityType) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "EntityType";
-                    }
-                    if (expandComments) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Comment";
-                    }
-                    if (expandAttachments) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += "Attachment";
-                    }
-                    if (expandStr) {
-                        if (expand.length) {
-                            expand += ",";
-                        }
-                        expand += expandStr;
-                    }
-                    if (expand.length) {
+                    if (expand === null || expand === void 0 ? void 0 : expand.length) {
                         urlParams.append("Expand", expand);
                     }
                     if (schemaId) {
@@ -4623,8 +4605,20 @@
                     if (maxSearchTimeSec) {
                         urlParams.set("MaxSearchTimeSec", String(Math.ceil(maxSearchTimeSec)));
                     }
-                    urlParams.set("hasMigrated", String(Boolean(migrated)));
-                    let url = analysis ? "entities/summary" : "entities";
+                    let url = null;
+                    // v3 endpoint.
+                    if (migrated) {
+                        url = "v3/getEntities";
+                        if (analysis) {
+                            body.PageIndex = -1;
+                            body.PageSize = -1;
+                        }
+                    }
+                    // v1 endpoint.
+                    else {
+                        url = analysis ? "entities/summary" : "entities";
+                        urlParams.set("hasMigrated", "false");
+                    }
                     // Adding url params here because this will avoid making them encoded.
                     // Our API isn't decoding them properly so $expand is not being recognized.
                     url += "?" + urlParams.toString();
@@ -16721,7 +16715,7 @@
     }
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.0.6";
+    const VERSION = "7.0.8";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;