bruce-models 2.3.6 → 2.3.8

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

@@ -1,59 +1,59 @@
-import { Api } from "../api/api";
-import { BruceApi } from "../api/bruce-api";
-import { Entity } from "./entity";
-/**
- * Describes the "Entity Relationship" concept within Bruce.
- * 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 {
-    function GetCacheKey(entityA: string, entityB: string, typeId: string): string;
-    function GetEntityCacheKey(entityId: string): string;
-    function GetListCacheKey(entityId: string, params: IListParams): string;
-    interface IRelation {
-        "Principal.Entity.ID": string;
-        "Related.Entity.ID": string;
-        RelatedEntity?: Entity.IEntity;
-        PrincipalEntity?: Entity.IEntity;
-        "Relation.Type.ID": string;
-        RelationType?: any;
-        "Data.Entity.ID"?: string;
-    }
-    interface IListParams {
-        relationTypeId?: string;
-        oneWayOnly?: boolean;
-        loadEntityData?: boolean;
-    }
-    function Create(params: {
-        api: BruceApi.Api;
-        relation: IRelation;
-        req?: Api.IReqParams;
-    }): Promise<void>;
-    function Delete(params: {
-        api: BruceApi.Api;
-        principalEntityId: string;
-        relatedEntityId: string;
-        relationTypeId: string;
-        req?: Api.IReqParams;
-    }): Promise<void>;
-    function Update(params: {
-        api: BruceApi.Api;
-        relation: IRelation;
-        req?: Api.IReqParams;
-    }): Promise<void>;
-    function GetList(params: {
-        api: BruceApi.Api;
-        entityId: string;
-        filter: IListParams;
-        req?: Api.IReqParams;
-    }): Promise<{
-        relations: IRelation[];
-    }>;
-    function GetByDataEntityId(params: {
-        api: BruceApi.Api;
-        entityId: string;
-        req?: Api.IReqParams;
-    }): Promise<{
-        relation: IRelation;
-    }>;
-}
+import { Api } from "../api/api";
+import { BruceApi } from "../api/bruce-api";
+import { Entity } from "./entity";
+/**
+ * Describes the "Entity Relationship" concept within Bruce.
+ * 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 {
+    function GetCacheKey(entityA: string, entityB: string, typeId: string): string;
+    function GetEntityCacheKey(entityId: string): string;
+    function GetListCacheKey(entityId: string, params: IListParams): string;
+    interface IRelation {
+        "Principal.Entity.ID": string;
+        "Related.Entity.ID": string;
+        RelatedEntity?: Entity.IEntity;
+        PrincipalEntity?: Entity.IEntity;
+        "Relation.Type.ID": string;
+        RelationType?: any;
+        "Data.Entity.ID"?: string;
+    }
+    interface IListParams {
+        relationTypeId?: string;
+        oneWayOnly?: boolean;
+        loadEntityData?: boolean;
+    }
+    function Create(params: {
+        api: BruceApi.Api;
+        relation: IRelation;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        principalEntityId: string;
+        relatedEntityId: string;
+        relationTypeId: string;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Update(params: {
+        api: BruceApi.Api;
+        relation: IRelation;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        filter: IListParams;
+        req?: Api.IReqParams;
+    }): Promise<{
+        relations: IRelation[];
+    }>;
+    function GetByDataEntityId(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        relation: IRelation;
+    }>;
+}

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

@@ -1,45 +1,45 @@
-import { Api } from "../api/api";
-import { BruceApi, IDictionary } from "../bruce-models";
-/**
- * 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.
- */
-export declare namespace EntitySource {
-    function GetCacheKey(sourceId: number, sourceKey: string): string;
-    interface ISource {
-        "Entity.ID": string;
-        "Source.ID": number;
-        "SourceRecord.Key": string;
-    }
-    function Get(params: {
-        api: BruceApi.Api;
-        sourceId: number;
-        sourceKey: string;
-        req?: Api.IReqParams;
-    }): Promise<{
-        source: ISource;
-    }>;
-    function GetListByKeys(params: {
-        api: BruceApi.Api;
-        sourceId: number;
-        sourceKeys: string[];
-        req?: Api.IReqParams;
-    }): Promise<{
-        sources: ISource[];
-    }>;
-    function GetEntityIdsBySourceKeys(params: {
-        api: BruceApi.Api;
-        sourceId: number;
-        sourceKeys: string[];
-        req?: Api.IReqParams;
-    }): Promise<{
-        idMapping: IDictionary<string>;
-    }>;
-    function CreateLink(params: {
-        api: BruceApi.Api;
-        source: ISource;
-    }): Promise<{
-        source: ISource;
-    }>;
-}
+import { Api } from "../api/api";
+import { BruceApi, IDictionary } from "../bruce-models";
+/**
+ * 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.
+ */
+export declare namespace EntitySource {
+    function GetCacheKey(sourceId: number, sourceKey: string): string;
+    interface ISource {
+        "Entity.ID": string;
+        "Source.ID": number;
+        "SourceRecord.Key": string;
+    }
+    function Get(params: {
+        api: BruceApi.Api;
+        sourceId: number;
+        sourceKey: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        source: ISource;
+    }>;
+    function GetListByKeys(params: {
+        api: BruceApi.Api;
+        sourceId: number;
+        sourceKeys: string[];
+        req?: Api.IReqParams;
+    }): Promise<{
+        sources: ISource[];
+    }>;
+    function GetEntityIdsBySourceKeys(params: {
+        api: BruceApi.Api;
+        sourceId: number;
+        sourceKeys: string[];
+        req?: Api.IReqParams;
+    }): Promise<{
+        idMapping: IDictionary<string>;
+    }>;
+    function CreateLink(params: {
+        api: BruceApi.Api;
+        source: ISource;
+    }): Promise<{
+        source: ISource;
+    }>;
+}

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

@@ -1,53 +1,53 @@
-import { Api } from "../api/api";
-import { BruceApi } from "../api/bruce-api";
-/**
- * Describes the "Entity Tag" concept within Bruce.
- * 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 {
-    function GetCacheKey(tagId: number): string;
-    function GetListCacheKey(entityTypeId?: string): string;
-    interface ITag {
-        ID: number;
-        Name?: string;
-        Description?: string;
-        IsAccessRestricted?: boolean;
-        "EntityType.ID"?: string;
-        Color?: string;
-        "Parent.Layer.ID"?: number;
-    }
-    function Get(params: {
-        api: BruceApi.Api;
-        tagId: number;
-        req?: Api.IReqParams;
-    }): Promise<{
-        tag: ITag;
-    }>;
-    function GetListByIds(params: {
-        api: BruceApi.Api;
-        tagIds: number[];
-        req?: Api.IReqParams;
-    }): Promise<{
-        tags: ITag[];
-    }>;
-    function GetList(params: {
-        api: BruceApi.Api;
-        entityTypeId?: string;
-        req?: Api.IReqParams;
-    }): Promise<{
-        tags: ITag[];
-    }>;
-    function Delete(params: {
-        api: BruceApi.Api;
-        tagId: number;
-        req?: Api.IReqParams;
-    }): Promise<void>;
-    function Update(params: {
-        api: BruceApi.Api;
-        tag: ITag;
-        req?: Api.IReqParams;
-    }): Promise<{
-        tag: ITag;
-    }>;
-}
+import { Api } from "../api/api";
+import { BruceApi } from "../api/bruce-api";
+/**
+ * Describes the "Entity Tag" concept within Bruce.
+ * 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 {
+    function GetCacheKey(tagId: number): string;
+    function GetListCacheKey(entityTypeId?: string): string;
+    interface ITag {
+        ID: number;
+        Name?: string;
+        Description?: string;
+        IsAccessRestricted?: boolean;
+        "EntityType.ID"?: string;
+        Color?: string;
+        "Parent.Layer.ID"?: number;
+    }
+    function Get(params: {
+        api: BruceApi.Api;
+        tagId: number;
+        req?: Api.IReqParams;
+    }): Promise<{
+        tag: ITag;
+    }>;
+    function GetListByIds(params: {
+        api: BruceApi.Api;
+        tagIds: number[];
+        req?: Api.IReqParams;
+    }): Promise<{
+        tags: ITag[];
+    }>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        entityTypeId?: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        tags: ITag[];
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        tagId: number;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Update(params: {
+        api: BruceApi.Api;
+        tag: ITag;
+        req?: Api.IReqParams;
+    }): Promise<{
+        tag: ITag;
+    }>;
+}

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

@@ -1,16 +1,16 @@
-export declare namespace EntityTypeVisualSettings {
-    enum EAction {
-        LeftClick = "LeftClick.CustomForm.ID",
-        RightClick = "RightClick.CustomForm.ID",
-        DoubleClick = "DoubleClick.CustomForm.ID",
-        MouseHover = "MouseHover.CustomForm.ID"
-    }
-    interface ISettings {
-        CustomForms?: {
-            [EAction.LeftClick]?: number;
-            [EAction.RightClick]?: number;
-            [EAction.MouseHover]?: number;
-            [EAction.DoubleClick]?: number;
-        };
-    }
-}
+export declare namespace EntityTypeVisualSettings {
+    enum EAction {
+        LeftClick = "LeftClick.CustomForm.ID",
+        RightClick = "RightClick.CustomForm.ID",
+        DoubleClick = "DoubleClick.CustomForm.ID",
+        MouseHover = "MouseHover.CustomForm.ID"
+    }
+    interface ISettings {
+        CustomForms?: {
+            [EAction.LeftClick]?: number;
+            [EAction.RightClick]?: number;
+            [EAction.MouseHover]?: number;
+            [EAction.DoubleClick]?: number;
+        };
+    }
+}

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

@@ -1,63 +1,63 @@
-import { Api } from "../api/api";
-import { BruceApi } from "../api/bruce-api";
-import { UTC } from "../common/utc";
-import { Entity } from "./entity";
-import { EntityAttribute } from "./entity-attribute";
-import { EntityTypeVisualSettings } from "./entity-type-visual-settings";
-/**
- * Describes the "Entity Type" concept within Bruce.
- * 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 {
-    function GetCacheKey(typeId: string): string;
-    function GetListCacheKey(): string;
-    interface IEntityType {
-        ID?: string;
-        IsDeleted?: boolean;
-        Name: string;
-        Description?: string;
-        Data?: Entity.IEntity;
-        DataSchema?: {
-            Key: "root";
-            Name?: "Root";
-            Structure: EntityAttribute.IAttribute[];
-            Type: EntityAttribute.EType.Structure;
-        };
-        DisplayNameAttributePath?: string;
-        IsStrictSchema?: boolean;
-        "DisplaySetting.ID"?: number;
-        AuthoringSettings?: {
-            enabledTools: string[];
-            defaultTool: string;
-        };
-        "LastUpdate.Time"?: UTC.IUTC;
-        "Parent.EntityType.ID"?: string;
-        VisualSettings?: EntityTypeVisualSettings.ISettings;
-    }
-    function Get(params: {
-        api: BruceApi.Api;
-        entityTypeId: string;
-        req?: Api.IReqParams;
-    }): Promise<{
-        entityType: IEntityType;
-    }>;
-    function Delete(params: {
-        api: BruceApi.Api;
-        entityTypeId: string;
-        req?: Api.IReqParams;
-    }): Promise<void>;
-    function GetList(params: {
-        api: BruceApi.Api;
-        req?: Api.IReqParams;
-    }): Promise<{
-        entityTypes: IEntityType[];
-    }>;
-    function Update(params: {
-        api: BruceApi.Api;
-        entityType: IEntityType;
-        req?: Api.IReqParams;
-    }): Promise<{
-        entityType: IEntityType;
-    }>;
-}
+import { Api } from "../api/api";
+import { BruceApi } from "../api/bruce-api";
+import { UTC } from "../common/utc";
+import { Entity } from "./entity";
+import { EntityAttribute } from "./entity-attribute";
+import { EntityTypeVisualSettings } from "./entity-type-visual-settings";
+/**
+ * Describes the "Entity Type" concept within Bruce.
+ * 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 {
+    function GetCacheKey(typeId: string): string;
+    function GetListCacheKey(): string;
+    interface IEntityType {
+        ID?: string;
+        IsDeleted?: boolean;
+        Name: string;
+        Description?: string;
+        Data?: Entity.IEntity;
+        DataSchema?: {
+            Key: "root";
+            Name?: "Root";
+            Structure: EntityAttribute.IAttribute[];
+            Type: EntityAttribute.EType.Structure;
+        };
+        DisplayNameAttributePath?: string;
+        IsStrictSchema?: boolean;
+        "DisplaySetting.ID"?: number;
+        AuthoringSettings?: {
+            enabledTools: string[];
+            defaultTool: string;
+        };
+        "LastUpdate.Time"?: UTC.IUTC;
+        "Parent.EntityType.ID"?: string;
+        VisualSettings?: EntityTypeVisualSettings.ISettings;
+    }
+    function Get(params: {
+        api: BruceApi.Api;
+        entityTypeId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entityType: IEntityType;
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        entityTypeId: string;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entityTypes: IEntityType[];
+    }>;
+    function Update(params: {
+        api: BruceApi.Api;
+        entityType: IEntityType;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entityType: IEntityType;
+    }>;
+}