bruce-models 3.1.9 → 3.2.1

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

@@ -2,17 +2,36 @@ import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { IDictionary } from "../common/dictionary";
 /**
- * Describes the "Entity Source" concept within Bruce.
- * An entity source is a record which links an arbitrary source id to a Bruce entity id.
- * For example an OSM building id to a Bruce entity id.
+ * Describes the "Entity Source" concept within Nextspace.
+ * An entity source is a record which links an arbitrary source id to a Nextspace entity id.
+ * For example an OSM building id to a Nextspace entity id.
  */
 export declare namespace EntitySource {
+    /**
+     * Returns cache identifier for an entity source record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey(1, "def");
+     *     api.Cache.Remove(key);
+     * }
+     * @param sourceId
+     * @param sourceKey
+     * @returns
+     */
     function GetCacheKey(sourceId: number, sourceKey: string): string;
+    /**
+     * Describes an entity source record.
+     */
     interface ISource {
-        "Entity.ID": string;
         "Source.ID": number;
+        "Entity.ID": string;
         "SourceRecord.Key": string;
     }
+    /**
+     * Returns an entity source record for the given source id and source key.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         api?: BruceApi.Api;
         sourceId: number;
@@ -21,6 +40,11 @@ export declare namespace EntitySource {
     }): Promise<{
         source: ISource;
     }>;
+    /**
+     * Returns a list of entity source records for the given source id and source keys.
+     * @param params
+     * @returns
+     */
     function GetListByKeys(params: {
         api?: BruceApi.Api;
         sourceId: number;
@@ -29,6 +53,11 @@ export declare namespace EntitySource {
     }): Promise<{
         sources: ISource[];
     }>;
+    /**
+     * Returns a mapping of entity source records for the given source id and source keys.
+     * @param params
+     * @returns
+     */
     function GetEntityIdsBySourceKeys(params: {
         api?: BruceApi.Api;
         sourceId: number;
@@ -37,6 +66,11 @@ export declare namespace EntitySource {
     }): Promise<{
         idMapping: IDictionary<string>;
     }>;
+    /**
+     * Creates a new entity source record.
+     * @param params
+     * @returns
+     */
     function CreateLink(params: {
         api?: BruceApi.Api;
         source: ISource;

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

@@ -1,13 +1,36 @@
 import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 /**
- * Describes the "Entity Tag" concept within Bruce.
+ * Describes the "Entity Tag" concept within Nextspace.
  * An entity tag is used to categorize an entity record.
  * Entity tags can be used in filters, or to restrict entity access.
  */
 export declare namespace EntityTag {
+    /**
+     * Returns cache identifier for an entity tag record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey(1);
+     *     api.Cache.Remove(key);
+     * }
+     * @param tagId
+     * @returns
+     */
     function GetCacheKey(tagId: number): string;
+    /**
+     * Returns cache identifier for a list of entity tags.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param entityTypeId
+     * @returns
+     */
     function GetListCacheKey(entityTypeId?: string): string;
+    /**
+     * Describes an entity tag record.
+     */
     interface ITag {
         ID: number;
         Name?: string;
@@ -17,6 +40,11 @@ export declare namespace EntityTag {
         Color?: string;
         "Parent.Layer.ID"?: number;
     }
+    /**
+     * Returns an entity tag record for the given tag id.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         api?: BruceApi.Api;
         tagId: number;
@@ -24,6 +52,11 @@ export declare namespace EntityTag {
     }): Promise<{
         tag: ITag;
     }>;
+    /**
+     * Returns a list of entity tag records for the given tag ids.
+     * @param params
+     * @returns
+     */
     function GetListByIds(params: {
         api?: BruceApi.Api;
         tagIds: number[];
@@ -31,6 +64,11 @@ export declare namespace EntityTag {
     }): Promise<{
         tags: ITag[];
     }>;
+    /**
+     * Returns a list of entity tag records.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         entityTypeId?: string;
@@ -38,11 +76,20 @@ export declare namespace EntityTag {
     }): Promise<{
         tags: ITag[];
     }>;
+    /**
+     * Deletes an entity tag record.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         tagId: number;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Creates or updates an entity tag record.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         tag: ITag;

package/dist/types/entity/entity-type-visual-settings.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Deprecated settings for entity types.
+ * We now store selection settings within project views.
+ */
 export declare namespace EntityTypeVisualSettings {
     enum EAction {
         LeftClick = "LeftClick.CustomForm.ID",

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

@@ -5,13 +5,35 @@ import { Entity } from "./entity";
 import { EntityAttribute } from "./entity-attribute";
 import { EntityTypeVisualSettings } from "./entity-type-visual-settings";
 /**
- * Describes the "Entity Type" concept within Bruce.
+ * Describes the "Entity Type" concept within Nextspace.
  * An entity type is an "expectation" of what data "should" look like in a particular entity record.
  * The schema is stencils onto entity data to filter out what we should display or search against.
  */
 export declare namespace EntityType {
+    /**
+     * Returns cache identifier for an entity type.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param typeId
+     * @returns
+     */
     function GetCacheKey(typeId: string): string;
+    /**
+     * Returns cache identifier for a list of entity types.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey();
+     *     api.Cache.Remove(key);
+     * }
+     * @returns
+     */
     function GetListCacheKey(): string;
+    /**
+     * Describes an entity type record.
+     */
     interface IType {
         ID?: string;
         IsDeleted?: boolean;
@@ -28,14 +50,19 @@ export declare namespace EntityType {
         DisplayNameAttributePath?: string;
         IsStrictSchema?: boolean;
         "DisplaySetting.ID"?: number;
+        "LastUpdate.Time"?: UTC.IUTC;
+        "Parent.EntityType.ID"?: string;
+        VisualSettings?: EntityTypeVisualSettings.ISettings;
         AuthoringSettings?: {
             enabledTools: string[];
             defaultTool: string;
         };
-        "LastUpdate.Time"?: UTC.IUTC;
-        "Parent.EntityType.ID"?: string;
-        VisualSettings?: EntityTypeVisualSettings.ISettings;
     }
+    /**
+     * Gets an entity type record.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         api?: BruceApi.Api;
         entityTypeId: string;
@@ -43,17 +70,31 @@ export declare namespace EntityType {
     }): Promise<{
         entityType: IType;
     }>;
+    /**
+     * Deletes an entity type record and all corresponding entities.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         entityTypeId: string;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Gets a list of entity types.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         req?: Api.IReqParams;
     }): Promise<{
         entityTypes: IType[];
     }>;
+    /**
+     * Updates or creates an entity type record.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         entityType: IType;

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

@@ -9,18 +9,41 @@ import { IDictionary } from "../common/dictionary";
 import { Carto } from "../bruce-models";
 type _any = any;
 /**
- * Describes the "Entity" concept within Bruce.
+ * Describes the "Entity" concept within Nextspace.
  * An entity is a JSON blob containing both internal data and user-defined data.
  * Entity records have many thinks linked to them through their UIDs such as links, files and relationships.
  */
 export declare namespace Entity {
+    /**
+     * Returns cache identifier for an entity record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey({...});
+     *     api.Cache.Remove(key);
+     * }
+     * @param params
+     * @returns
+     */
     function GetCacheKey(params: {
         entityId: string;
         entityTypeId?: string;
         expandLocation?: boolean;
         expandRelations?: boolean;
     }): string;
+    /**
+     * Returns cache identifier for an entity record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param entityId
+     * @returns
+     */
     function GetContainsKey(entityId: string): string;
+    /**
+     * Describes an entity record.
+     */
     interface IEntity extends _any {
         Bruce: {
             "CreatedBy.User.ID"?: string;
@@ -38,10 +61,19 @@ export declare namespace Entity {
         tilesetID?: string[];
         worldPosition?: number[][];
     }
+    /**
+     * Available if expandRelations=true.
+     * Describes a downstream relationship between the entity and another.
+     */
     interface IRelationData {
         "Other.Entity.ID": string;
         "RelationType.ID": string;
     }
+    /**
+     * Returns an entity record for the given entity id.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         api?: BruceApi.Api;
         entityId: string;
@@ -52,6 +84,11 @@ export declare namespace Entity {
     }): Promise<{
         entity: IEntity;
     }>;
+    /**
+     * Returns a list of entity records for the given entity ids.
+     * @param params
+     * @returns
+     */
     function GetListByIds(params: {
         api?: BruceApi.Api;
         entityIds: string[];
@@ -60,16 +97,29 @@ export declare namespace Entity {
     }): Promise<{
         entities: IEntity[];
     }>;
+    /**
+     * Deletes an entity record.
+     * @param params
+     */
     function Delete(params: {
         api?: BruceApi.Api;
         entityId: string;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Deletes a list of entity records.
+     * @param params
+     */
     function DeleteList(params: {
         api?: BruceApi.Api;
         entityIds: string[];
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Creates or updates an entity record.
+     * @param params
+     * @returns
+     */
     function Update(params: {
         api?: BruceApi.Api;
         entity: IEntity;
@@ -78,19 +128,36 @@ export declare namespace Entity {
     }): Promise<{
         entity: IEntity;
     }>;
+    /**
+     * Util to remove a tag from an entity.
+     * @param params
+     */
     function RemoveTag(params: {
         entity: IEntity;
         tagId: number;
     }): void;
+    /**
+     * Util to add a tag to an entity.
+     * @param params
+     */
     function AddTag(params: {
         entity: IEntity;
         tagId: number;
     }): void;
+    /**
+     * Util to set a value on an entity.
+     * @param params
+     */
     function SetValue(params: {
         entity: IEntity;
         path: string[];
         value: any;
     }): void;
+    /**
+     * Util to get a value from an entity.
+     * @param params
+     * @returns
+     */
     function GetValue(params: {
         entity: IEntity;
         path: string[];
@@ -98,8 +165,6 @@ export declare namespace Entity {
     /**
      * Calculates an entity's name based on attribute priority set in the type.
      * @param params
-     * If true, will return the entity ID if no name can be calculated.
-     * Otherwise it returns null.
      * @returns
      */
     function CalculateName(params: {
@@ -107,6 +172,22 @@ export declare namespace Entity {
         type: EntityType.IType;
         defaultToId?: boolean;
     }): string;
+    /**
+     * Calculates an entity name.
+     * This will request data if entity or type is not provided.
+     * @param params
+     * @returns
+     */
+    function CalculateNameAsync(params: {
+        entityId: string;
+        entity: IEntity;
+        typeId?: string;
+        type?: EntityType.IType;
+        defaultToId?: boolean;
+    }): Promise<string>;
+    /**
+     * Describes a filter for entity records.
+     */
     interface IFilter {
         orderBy?: any;
         entityTypeId?: string;
@@ -119,6 +200,11 @@ export declare namespace Entity {
         sortOrder?: Api.ESortOrder;
         entityTypeConditions?: IDictionary<any>;
     }
+    /**
+     * Returns a list of entity records for the given filter.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         filter: IFilter;

package/dist/types/environment.d.ts

@@ -10,7 +10,16 @@ interface IParams {
 export declare namespace ENVIRONMENT {
     let IS_SELF_MANAGED: boolean;
     let PARAMS: IParams;
+    /**
+     * Returns the ApiGetters instance.
+     * This is used to communicate with any Nextspace API instance.
+     * @returns
+     */
     function Api(): ApiGetters;
+    /**
+     * Resets the environment to the specified params.
+     * @param params
+     */
     function Reset(params?: IParams): void;
 }
 export {};

package/dist/types/import/imported-file.d.ts

@@ -1,27 +1,73 @@
 import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { ClientFile } from "../client-file/client-file";
+/**
+ * Imported file records are created when a file is imported into Nextspace.
+ * The associated file may be attached to the record.
+ */
 export declare namespace ImportedFile {
+    /**
+     * Returns cache identifier for a imported file record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey(1);
+     *     api.Cache.Remove(key);
+     * }
+     * @param fileId
+     * @returns
+     */
     function GetCacheKey(fileId: number): string;
+    /**
+     * Returns cache identifier for a imported file record.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param rootId
+     * @returns
+     */
     function GetCacheKeyByRootId(rootId: string): string;
+    /**
+     * Returns cache identifier for a list of imported files.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey("CAD", 0);
+     *     api.Cache.Remove(key);
+     * }
+     * @param type
+     * @param pageIndex
+     * @returns
+     */
     function GetListCacheKey(type: EFileType, pageIndex: number): string;
+    /**
+     * Describes an imported file record.
+     */
     interface IFile {
         ID: number;
-        "ClientFile.ID": string;
         "ImportedBy.User.ID": string;
         "Imported.DateTime": any;
-        "EntityType.ID": string;
-        "RootEntity.ID": string;
-        "Source.ID": number;
-        "PendingAction.ID": number;
-        NewEntitiesCount: number;
-        UpdatedEntitiesCount: number;
-        ClientFile: ClientFile.IFile;
+        "EntityType.ID"?: string;
+        "RootEntity.ID"?: string;
+        "Source.ID"?: number;
+        "PendingAction.ID"?: number;
+        NewEntitiesCount?: number;
+        UpdatedEntitiesCount?: number;
+        "ClientFile.ID"?: string;
+        ClientFile?: ClientFile.IFile;
     }
+    /**
+     * Known file types we can filter against.
+     */
     enum EFileType {
         CAD = "CAD",
         All = "All"
     }
+    /**
+     * Returns a list of imported files.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         fileType?: EFileType;
@@ -30,6 +76,11 @@ export declare namespace ImportedFile {
     }): Promise<{
         importedFiles: IFile[];
     }>;
+    /**
+     * Returns a list of imported files for a root entity.
+     * @param params
+     * @returns
+     */
     function GetListByRootId(params: {
         api?: BruceApi.Api;
         rootId: string;
@@ -37,6 +88,11 @@ export declare namespace ImportedFile {
     }): Promise<{
         importedFiles: IFile[];
     }>;
+    /**
+     * Returns an imported file record.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         api?: BruceApi.Api;
         importedFileId: number;

package/dist/types/internal/uploader.d.ts

@@ -1,11 +1,19 @@
 import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
+/**
+ * Utility for uploading files.
+ */
 export declare namespace Uploader {
     const MIN_LARGE_FILE_SIZE = 100000000;
     interface IProgress {
         percent: number;
         uploaded: boolean;
     }
+    /**
+     * Uploads a file to the server.
+     * @param params
+     * @returns
+     */
     function DoMultiPartUpload(params: {
         file: File;
         api?: BruceApi.Api;

package/dist/types/markup/markup.d.ts

@@ -1,8 +1,11 @@
 import { Cartes, EntityAttachmentType } from "../bruce-models";
 /**
- * Description of a "Markup" which is stored in custom-form or bookmark records.
+ * Description of a "Markup" which is stored in bookmark records.
  */
 export declare namespace Markup {
+    /**
+     * Describes a markup that is embedded in a bookmark.
+     */
     interface IMarkup {
         divs?: Div.IDiv[];
         vectors?: (Line.ILine | FreePaint.IPaint)[];
@@ -12,6 +15,9 @@ export declare namespace Markup {
         defaultCameraPos?: any;
         visible?: boolean;
     }
+    /**
+     * Base of all markup elements.
+     */
     interface IElement {
         id: string;
         name?: string;

package/dist/types/plugin/plugin.d.ts

@@ -3,8 +3,30 @@ import { BruceApi } from "../api/bruce-api";
 import { UTC } from "../common/utc";
 import { Uploader } from "../internal/uploader";
 export declare namespace Plugin {
+    /**
+     * Returns cache identifier for a plugin.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetCacheKey("abc");
+     *     api.Cache.Remove(key);
+     * }
+     * @param pluginId
+     * @returns
+     */
     function GetCacheKey(pluginId: string): string;
+    /**
+     * Returns cache identifier for a list of plugins.
+     * Example: {
+     *     const api: BruceApi.Api = ...;
+     *     const key = GetListCacheKey();
+     *     api.Cache.Remove(key);
+     * }
+     * @returns
+     */
     function GetListCacheKey(): string;
+    /**
+     * Describes a plugin record.
+     */
     interface IPlugin {
         ID: string;
         Name: string;
@@ -16,6 +38,11 @@ export declare namespace Plugin {
         "LastUpdated.Date": UTC.IUTC;
         "Created.Date": UTC.IUTC;
     }
+    /**
+     * Returns a plugin record.
+     * @param params
+     * @returns
+     */
     function Get(params: {
         api?: BruceApi.Api;
         pluginId: string;
@@ -23,12 +50,22 @@ export declare namespace Plugin {
     }): Promise<{
         plugin: IPlugin;
     }>;
+    /**
+     * Returns a list of plugins.
+     * @param params
+     * @returns
+     */
     function GetList(params: {
         api?: BruceApi.Api;
         req?: Api.IReqParams;
     }): Promise<{
         plugins: IPlugin[];
     }>;
+    /**
+     * Returns a URL to load a plugin.
+     * @param params
+     * @returns
+     */
     function GetLoadUrl(params: {
         api?: BruceApi.Api;
         pluginId: string;
@@ -36,11 +73,19 @@ export declare namespace Plugin {
     }): {
         indexFileUrl: string;
     };
+    /**
+     * Creates or updates a plugin.
+     * @param params
+     */
     function Update(params: {
         plugin: IPlugin;
         api?: BruceApi.Api;
         req?: Api.IReqParams;
     }): Promise<void>;
+    /**
+     * Deletes a plugin.
+     * @param params
+     */
     function Delete(params: {
         pluginId: string;
         api?: BruceApi.Api;