bruce-models 3.2.0 → 3.2.2

package/dist/types/entity/entity-comment.d.ts

@@ -2,12 +2,38 @@ import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { UTC } from "../common/utc";
 /**
- * Describes the "Entity Comment" concept within Bruce.
+ * Describes the "Entity Comment" concept within Nextspace.
  * An entity comment is a user written message that is linked to an entity record.
+ *
+ * @deprecated: The Navigator now uses Entity records directly.
+ * a utility is being made to manage those records.
  */
 export declare namespace EntityComment {
+    /**
+     * Returns cache identifier for a comment by ID.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("123");
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetCacheKey(id: number): string;
+    /**
+     * Returns cache identifier for a list of comments for an entity.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param entityId
+     * @returns
+     */
     function GetListCacheKey(entityId: string): string;
+    /**
+     * Describes a comment record.
+     */
     interface IComment {
         Comment: string;
         "Created.ByUser.ID": string;
@@ -18,6 +44,11 @@ export declare namespace EntityComment {
         "TargetObject.ID": string;
         "TargetObject.Type": string;
     }
+    /**
+     * Creates or updates a comment.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         comment: IComment;
@@ -25,12 +56,21 @@ export declare namespace EntityComment {
     }): Promise<{
         comment: IComment;
     }>;
+    /**
+     * Deletes a comment.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         entityId: string;
         commentId: number;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Gets a list of comments for an entity.
+     * @param params
+     * @returns
+     */
     function GetListByEntityId(params: {
         api?: BruceApi.Api;
         entityId: string;

package/dist/types/entity/entity-coords.d.ts

@@ -3,33 +3,66 @@ import { BruceApi } from "../api/bruce-api";
 import { Carto } from "../common/carto";
 import { Transform } from "../common/transform";
 import { Entity } from "./entity";
+/**
+ * This is a utility to help calculate and manage UCS coordinates for entities.
+ */
 export declare namespace EntityCoords {
     const UCS_ENTITY_TYPE_ID = "Bruce_UCS_Type";
+    /**
+     * Returns cache identifier for a UCS by entity id.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("123");
+     *     api.Cache.Remove(key);
+     * }
+     * @param entityId
+     * @returns
+     */
     function GetCacheKey(entityId: string): string;
+    /**
+     * Describes a UCS record.
+     */
     interface IUcs {
         name: string;
-        location: Carto.ICarto;
         "Entity.ID": string;
+        location: Carto.ICarto;
         transform: Transform.ITransform;
     }
+    /**
+     * Describes an expanded entity record with UCS information.
+     */
     interface IEntityCoords extends Entity.IEntity {
         ucs?: IUcs;
     }
+    /**
+     * Params for shifting an entity to be relative to a point.
+     */
     interface IRelToPointParams {
         point: Carto.ICarto;
         test: boolean;
         name?: string;
     }
+    /**
+     * Params for shifting an entity to be relative to an EPSG.
+     */
     interface IRelToEpsgParams {
         epsg: number;
         test: boolean;
         name?: string;
     }
+    /**
+     * Params for shifting an entity to be relative to a UCS.
+     */
     interface IRelToUcsParams {
         ucsId: string;
         test: boolean;
         name?: boolean;
     }
+    /**
+     * Returns an entity's location with expanded UCS information.
+     * @param params
+     * @returns
+     */
     function GetEntityCoords(params: {
         api?: BruceApi.Api;
         rootEntityId: string;
@@ -37,6 +70,11 @@ export declare namespace EntityCoords {
     }): Promise<{
         coords: IEntityCoords;
     }>;
+    /**
+     * Returns coordinates for an entity when relative to a point.
+     * @param params
+     * @returns
+     */
     function EntityRelativeToPoint(params: {
         api?: BruceApi.Api;
         rootEntityId: string;
@@ -44,6 +82,11 @@ export declare namespace EntityCoords {
     } & IRelToPointParams): Promise<{
         coords: IEntityCoords;
     }>;
+    /**
+     * Returns coordinates for an entity when relative to an EPSG.
+     * @param params
+     * @returns
+     */
     function EntityRelativeToEpsg(params: {
         api?: BruceApi.Api;
         rootEntityId: string;
@@ -51,6 +94,11 @@ export declare namespace EntityCoords {
     } & IRelToEpsgParams): Promise<{
         coords: IEntityCoords;
     }>;
+    /**
+     * Returns coordinates for an entity when relative to a UCS.
+     * @param params
+     * @returns
+     */
     function EntityRelativeToUcs(params: {
         api?: BruceApi.Api;
         rootEntityId: string;
@@ -58,6 +106,11 @@ export declare namespace EntityCoords {
     } & IRelToUcsParams): Promise<{
         coords: IEntityCoords;
     }>;
+    /**
+     * Unlinks UCS coordinates from an entity.
+     * @param params
+     * @returns
+     */
     function UnlinkCoords(params: {
         api?: BruceApi.Api;
         rootEntityId: string;

package/dist/types/entity/entity-link.d.ts

@@ -1,18 +1,46 @@
 import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 /**
- * Describes the "Entity Link" concept within Bruce.
- * An entity link is a URL linked to an entity record.
+ * Describes the "Entity Link" concept within Nextspace.
+ * An entity link is an external URL linked to an entity record.
  */
 export declare namespace EntityLink {
+    /**
+     * Returns cache identifier for a link record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey(1);
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetCacheKey(id: number): string;
+    /**
+     * Returns cache identifier for a list of links for an entity.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param entityId
+     * @returns
+     */
     function GetListCacheKey(entityId: string): string;
+    /**
+     * Describes a link record.
+     */
     interface ILink {
         DisplayName: string;
         ID?: number;
         "Entity.ID": string;
         URL: string;
     }
+    /**
+     * Creates or updates a link record.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         link: ILink;
@@ -20,12 +48,21 @@ export declare namespace EntityLink {
     }): Promise<{
         link: ILink;
     }>;
+    /**
+     * Deletes a link record.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         entityId: string;
         linkId: number;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Returns a list of links for an entity.
+     * @param params
+     * @returns
+     */
     function GetListByEntityId(params: {
         api?: BruceApi.Api;
         entityId: string;

package/dist/types/entity/entity-lod-category.d.ts

@@ -1,19 +1,56 @@
 import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
+/**
+ * Describes the "Entity LOD Category" concept within Nextspace.
+ * An LOD category is a level of categorization for LODs.
+ * This is typically used to group LODs by their extension.
+ */
 export declare namespace EntityLodCategory {
+    /**
+     * Returns cache identifier for an entity lod category record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetCacheKey(id: string): string;
+    /**
+     * Returns cache identifier for a list of entity lod categories.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey();
+     *     api.Cache.Remove(key);
+     * }
+     * @returns
+     */
     function GetListCacheKey(): string;
+    /**
+     * Describes an entity lod category record.
+     */
     interface ICategory {
         Description?: string;
         Key: string;
         Name: string;
     }
+    /**
+     * Returns a list of entity lod categories.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         req?: Api.IReqParams;
     }): Promise<{
         categories: ICategory[];
     }>;
+    /**
+     * Returns an entity lod category record matching the specified id.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         api?: BruceApi.Api;
         categoryId: string;
@@ -21,11 +58,20 @@ export declare namespace EntityLodCategory {
     }): Promise<{
         category: ICategory;
     }>;
+    /**
+     * Deletes an entity lod category record matching the specified id.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         categoryId: string;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Creates or updates an entity lod category record.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         category: ICategory;

package/dist/types/entity/entity-lod.d.ts

@@ -2,15 +2,51 @@ import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { ClientFile } from "../client-file/client-file";
 /**
- * Describes the "Entity LOD" concept within Bruce.
+ * Describes the "Entity LOD" concept within Nextspace.
  * LOD stands for Level of Detail.
  * An lod record is a possible 2d/3d visualization of the entity record.
  * The most common kind is a GLB.
  */
 export declare namespace EntityLod {
+    /**
+     * Returns cache identifier for an entity lod record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param url
+     * @returns
+     */
     function GetCacheKey(url: string): string;
+    /**
+     * Returns cache identifier for a list of entity lods.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey("abc", "def");
+     *     api.Cache.Remove(key);
+     * }
+     * @param typeId
+     * @param group
+     * @returns
+     */
     function GetTypeListKey(typeId: string, group: string): string;
+    /**
+     * Returns cache identifier for a list of entity lods.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param entityId
+     * @returns
+     */
     function GetEntityListKey(entityId: string): string;
+    /**
+     * Describes an entity lod record.
+     * This is a 2d/3d visualization of the entity record.
+     * The most common kind is a GLB.
+     */
     interface ILod {
         ClientFile?: ClientFile.IFile;
         "ClientFile.ID": string;
@@ -19,11 +55,19 @@ export declare namespace EntityLod {
         Level: number;
         Group?: string;
     }
+    /**
+     * Describes an entity lod record update.
+     */
     interface IEntityLodUpdate {
         "ClientFile.ID": string;
         "LODCategory.Key": string;
         Level: number;
     }
+    /**
+     * Returns a url for an entity lod record file.
+     * @param params
+     * @returns
+     */
     function GetUrl(params: {
         api?: BruceApi.Api;
         entityId: string;
@@ -33,6 +77,11 @@ export declare namespace EntityLod {
     }): {
         url: string;
     };
+    /**
+     * Returns the client file id for an entity lod record file.
+     * @param params
+     * @returns
+     */
     function GetUrlFileId(params: {
         api?: BruceApi.Api;
         url: string;
@@ -40,6 +89,11 @@ export declare namespace EntityLod {
     }): Promise<{
         clientFileId: string;
     }>;
+    /**
+     * Returns lods for a specified filter.
+     * @param params
+     * @returns
+     */
     function GetLods(params: {
         api?: BruceApi.Api;
         filter: Filter.IListParams;
@@ -47,6 +101,11 @@ export declare namespace EntityLod {
     }): Promise<{
         lods: Filter.IListResItem[];
     }>;
+    /**
+     * Returns all lods for a specified entity.
+     * @param params
+     * @returns
+     */
     function GetEntityLods(params: {
         api?: BruceApi.Api;
         entityId: string;
@@ -66,11 +125,20 @@ export declare namespace EntityLod {
     }): Promise<{
         lods: ILod[];
     }>;
+    /**
+     * Updates an entity lod record.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         entityId: string;
         req?: Api.IReqParams;
     } & IEntityLodUpdate): Promise<void>;
+    /**
+     * Deletes an entity lod record.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         entityId: string;
@@ -78,6 +146,9 @@ export declare namespace EntityLod {
         level: number;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Describes a filter for getting entity lods.
+     */
     namespace Filter {
         interface IListParamsItem {
             "entityId": string;

package/dist/types/entity/entity-relation-type.d.ts

@@ -1,12 +1,34 @@
 import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 /**
- * Describes the "Entity Relationship Type" concept within Bruce.
+ * Describes the "Entity Relationship Type" concept within Nextspace.
  * A relationship type record describes the purpose of a relationship.
  */
 export declare namespace EntityRelationType {
+    /**
+     * Returns cache identifier for an entity relation type record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetCacheKey(id: string): string;
+    /**
+     * Returns cache identifier for a list of entity relation types.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey();
+     *     api.Cache.Remove(key);
+     * }
+     * @returns
+     */
     function GetListCacheKey(): string;
+    /**
+     * Describes an entity relation type record.
+     */
     interface IType {
         ID: string;
         ForwardName: string;
@@ -16,6 +38,11 @@ export declare namespace EntityRelationType {
         EntityDisplaySettingID?: string;
         "Relation.EntityType.ID"?: string;
     }
+    /**
+     * Gets a single entity relation type record.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         api?: BruceApi.Api;
         relationTypeId: string;
@@ -23,17 +50,31 @@ export declare namespace EntityRelationType {
     }): Promise<{
         relationType: IType;
     }>;
+    /**
+     * Deletes an entity relation type record.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         relationTypeId: string;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Gets a list of entity relation type records.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         req?: Api.IReqParams;
     }): Promise<{
         relationTypes: IType[];
     }>;
+    /**
+     * Creates or updates an entity relation type record.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         relationType: IType;

package/dist/types/entity/entity-relation.d.ts

@@ -2,14 +2,47 @@ import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { Entity } from "./entity";
 /**
- * Describes the "Entity Relationship" concept within Bruce.
+ * Describes the "Entity Relationship" concept within Nextspace.
  * An entity relationship is an arbitrary link between two entity records.
  * The relationship can have a "data entity" linked to it as well for the relationship to store arbitrary data about itself.
  */
 export declare namespace EntityRelation {
+    /**
+     * Returns cache identifier for an entity relation record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc", "def", "ghi");
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetCacheKey(entityA: string, entityB: string, typeId: string): string;
+    /**
+     * Returns cache identifier for a list of entity relations.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetEntityCacheKey(entityId: string): string;
+    /**
+     * Returns cache identifier for a list of entity relations.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc", {...});
+     *     api.Cache.Remove(key);
+     * }
+     * @param id
+     * @returns
+     */
     function GetListCacheKey(entityId: string, params: IListParams): string;
+    /**
+     * Describes an entity relation record.
+     */
     interface IRelation {
         "Principal.Entity.ID": string;
         "Related.Entity.ID": string;
@@ -24,11 +57,19 @@ export declare namespace EntityRelation {
         oneWayOnly?: boolean;
         loadEntityData?: boolean;
     }
+    /**
+     * Creates a new entity relation.
+     * @param params
+     */
     function Create(params: {
         api?: BruceApi.Api;
         relation: IRelation;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Deletes an entity relation.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         principalEntityId: string;
@@ -36,11 +77,21 @@ export declare namespace EntityRelation {
         relationTypeId: string;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Updates an entity relation.
+     * Eg: data entity ID was changed.
+     * @param params
+     */
     function Update(params: {
         api?: BruceApi.Api;
         relation: IRelation;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Returns a list of relationships for an entity.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         entityId: string;
@@ -49,6 +100,11 @@ export declare namespace EntityRelation {
     }): Promise<{
         relations: IRelation[];
     }>;
+    /**
+     * Returns an entity relationship by the data entity ID.
+     * @param params
+     * @returns
+     */
     function GetByDataEntityId(params: {
         api?: BruceApi.Api;
         entityId: string;