bruce-models 2.3.6 → 2.3.8

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

@@ -1,118 +1,118 @@
-import { Api } from "../api/api";
-import { BruceApi } from "../api/bruce-api";
-import { Bounds } from "../common/bounds";
-import { Geometry } from "../common/geometry";
-import { Transform } from "../common/transform";
-import { UTC } from "../common/utc";
-import { EntityType } from "./entity-type";
-import { IDictionary } from "../common/dictionary";
-import { Carto } from "../bruce-models";
-declare type _any = any;
-/**
- * Describes the "Entity" concept within Bruce.
- * 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 {
-    function GetCacheKey(entityId: string, entityTypeId?: string, expandLocation?: boolean): string;
-    interface IEntity extends _any {
-        Bruce: {
-            "CreatedBy.User.ID"?: string;
-            CreatedTime?: UTC.IUTC;
-            "EntityType.ID": string;
-            ID?: string;
-            "Layer.ID"?: number[];
-        };
-        location?: Carto.ICarto;
-        boundaries?: Bounds.IBounds;
-        transform?: Transform.ITransform;
-        position?: number[][];
-        geometry?: Geometry.IGeometry;
-        tilesetID?: string[];
-        worldPosition?: number[][];
-    }
-    function Get(params: {
-        api: BruceApi.Api;
-        entityId: string;
-        entityTypeId?: string;
-        expandLocation?: boolean;
-        req?: Api.IReqParams;
-    }): Promise<{
-        entity: IEntity;
-    }>;
-    function GetListByIds(params: {
-        api: BruceApi.Api;
-        entityIds: string[];
-        req?: Api.IReqParams;
-    }): Promise<{
-        entities: IEntity[];
-    }>;
-    function Delete(params: {
-        api: BruceApi.Api;
-        entityId: string;
-        req?: Api.IReqParams;
-    }): Promise<void>;
-    function DeleteList(params: {
-        api: BruceApi.Api;
-        entityIds: string[];
-        req?: Api.IReqParams;
-    }): Promise<void>;
-    function Update(params: {
-        api: BruceApi.Api;
-        entity: IEntity;
-        override: boolean;
-        req?: Api.IReqParams;
-    }): Promise<{
-        entity: IEntity;
-    }>;
-    function RemoveTag(params: {
-        entity: IEntity;
-        tagId: number;
-    }): void;
-    function AddTag(params: {
-        entity: IEntity;
-        tagId: number;
-    }): void;
-    function SetValue(params: {
-        entity: IEntity;
-        path: string[];
-        value: any;
-    }): void;
-    function GetValue(params: {
-        entity: IEntity;
-        path: string[];
-    }): any;
-    /**
-     * 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: {
-        entity: IEntity;
-        type: EntityType.IEntityType;
-        defaultToId?: boolean;
-    }): string;
-    interface IFilter {
-        orderBy?: any;
-        entityTypeId?: string;
-        layerIds?: number[];
-        bounds?: Bounds.IReqBounds;
-        pageSize?: number;
-        pageIndex?: number;
-        lodCategoryId?: string;
-        sortOrder?: Api.ESortOrder;
-        entityTypeConditions?: IDictionary<any>;
-    }
-    function GetList(params: {
-        api: BruceApi.Api;
-        filter: IFilter;
-        viaCdn?: boolean;
-        viaCdnCacheToken?: number | string;
-        req?: Api.IReqParams;
-    }): Promise<{
-        entities: IEntity[];
-    }>;
-}
-export {};
+import { Api } from "../api/api";
+import { BruceApi } from "../api/bruce-api";
+import { Bounds } from "../common/bounds";
+import { Geometry } from "../common/geometry";
+import { Transform } from "../common/transform";
+import { UTC } from "../common/utc";
+import { EntityType } from "./entity-type";
+import { IDictionary } from "../common/dictionary";
+import { Carto } from "../bruce-models";
+type _any = any;
+/**
+ * Describes the "Entity" concept within Bruce.
+ * 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 {
+    function GetCacheKey(entityId: string, entityTypeId?: string, expandLocation?: boolean): string;
+    interface IEntity extends _any {
+        Bruce: {
+            "CreatedBy.User.ID"?: string;
+            CreatedTime?: UTC.IUTC;
+            "EntityType.ID": string;
+            ID?: string;
+            "Layer.ID"?: number[];
+        };
+        location?: Carto.ICarto;
+        boundaries?: Bounds.IBounds;
+        transform?: Transform.ITransform;
+        position?: number[][];
+        geometry?: Geometry.IGeometry;
+        tilesetID?: string[];
+        worldPosition?: number[][];
+    }
+    function Get(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        entityTypeId?: string;
+        expandLocation?: boolean;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entity: IEntity;
+    }>;
+    function GetListByIds(params: {
+        api: BruceApi.Api;
+        entityIds: string[];
+        req?: Api.IReqParams;
+    }): Promise<{
+        entities: IEntity[];
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function DeleteList(params: {
+        api: BruceApi.Api;
+        entityIds: string[];
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Update(params: {
+        api: BruceApi.Api;
+        entity: IEntity;
+        override: boolean;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entity: IEntity;
+    }>;
+    function RemoveTag(params: {
+        entity: IEntity;
+        tagId: number;
+    }): void;
+    function AddTag(params: {
+        entity: IEntity;
+        tagId: number;
+    }): void;
+    function SetValue(params: {
+        entity: IEntity;
+        path: string[];
+        value: any;
+    }): void;
+    function GetValue(params: {
+        entity: IEntity;
+        path: string[];
+    }): any;
+    /**
+     * 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: {
+        entity: IEntity;
+        type: EntityType.IEntityType;
+        defaultToId?: boolean;
+    }): string;
+    interface IFilter {
+        orderBy?: any;
+        entityTypeId?: string;
+        layerIds?: number[];
+        bounds?: Bounds.IReqBounds;
+        pageSize?: number;
+        pageIndex?: number;
+        lodCategoryId?: string;
+        sortOrder?: Api.ESortOrder;
+        entityTypeConditions?: IDictionary<any>;
+    }
+    function GetList(params: {
+        api: BruceApi.Api;
+        filter: IFilter;
+        viaCdn?: boolean;
+        viaCdnCacheToken?: number | string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entities: IEntity[];
+    }>;
+}
+export {};

package/dist/types/entity/getters/batched-data-getter.d.ts

@@ -1,26 +1,26 @@
-import { BruceEvent } from "../../common/bruce-event";
-import { ViewMonitor } from "./view-monitor";
-/**
- * This is a batched "arbitrary data" getter.
- * You feed it an array of data, then it will emit that data in batches when the view changes.
- */
-export declare namespace BatchedDataGetter {
-    class Getter<T> {
-        private viewPort;
-        private viewPortRemoval;
-        private batchSize;
-        private viewRect;
-        private viewCenter;
-        private getterInterval;
-        private data;
-        private onUpdate;
-        get OnUpdate(): BruceEvent<T[]>;
-        constructor(data: T[], viewPort: ViewMonitor.IMonitor, batchSize: number);
-        Start(): void;
-        Dispose(): void;
-        private updateViewport;
-        private updateBounds;
-        private startGetterLoop;
-        private processBatch;
-    }
-}
+import { BruceEvent } from "../../common/bruce-event";
+import { ViewMonitor } from "./view-monitor";
+/**
+ * This is a batched "arbitrary data" getter.
+ * You feed it an array of data, then it will emit that data in batches when the view changes.
+ */
+export declare namespace BatchedDataGetter {
+    class Getter<T> {
+        private viewPort;
+        private viewPortRemoval;
+        private batchSize;
+        private viewRect;
+        private viewCenter;
+        private getterInterval;
+        private data;
+        private onUpdate;
+        get OnUpdate(): BruceEvent<T[]>;
+        constructor(data: T[], viewPort: ViewMonitor.IMonitor, batchSize: number);
+        Start(): void;
+        Dispose(): void;
+        private updateViewport;
+        private updateBounds;
+        private startGetterLoop;
+        private processBatch;
+    }
+}

package/dist/types/entity/getters/entity-filter-getter.d.ts

@@ -1,61 +1,61 @@
-import { BruceApi } from "../../api/bruce-api";
-import { BruceEvent } from "../../common/bruce-event";
-import { IDictionary } from "../../common/dictionary";
-import { Entity } from "../entity";
-import { EntityGlobe } from "./entity-globe";
-import { ViewMonitor } from "./view-monitor";
-/**
- * This is a batched entity getter.
- * It will scan for entity records in a view-area and emit them in batches.
- * It will restart scanning if the camera moves.
- */
-export declare namespace EntityFilterGetter {
-    enum EStatus {
-        Scanning = "SCANNING",
-        Loading = "LOADING"
-    }
-    interface IStatusUpdate {
-        msg: EStatus;
-        revoking: boolean;
-    }
-    class Getter {
-        private onUpdate;
-        get OnUpdate(): BruceEvent<Entity.IEntity[]>;
-        LastStateUpdates: IDictionary<IStatusUpdate>;
-        private onStateUpdate;
-        get OnStateUpdate(): BruceEvent<IStatusUpdate>;
-        private onScanUpdate;
-        get OnScanUpdate(): BruceEvent<EntityGlobe.Cell[]>;
-        private api;
-        private viewPort;
-        private viewPortChangeRemoval;
-        private cells;
-        private registeredItems;
-        private getterLoopId;
-        private viaCdn;
-        private typeId;
-        private batchSize;
-        private tagIds;
-        private minHeight;
-        private maxHeight;
-        private attrFilter;
-        private viewRect;
-        private viewCenter;
-        constructor(api: BruceApi.Api, viewPort: ViewMonitor.IMonitor, typeId: string, batchSize?: number, attrFilter?: IDictionary<any>, viaCdn?: boolean);
-        /**
-         * Returns id that represents the combined menu item parameters.
-         * If integrity changes while a request is running, the request will not emit a response.
-         * @returns
-         */
-        private getIntegrityId;
-        private viewAreaSub;
-        private viewAreaDispose;
-        GetMenuItems(): string[];
-        IncludeMenuItem(menuItemId: string, layerIds: number[], minHeight: number, maxHeight: number): void;
-        ExcludeMenuItem(menuItemId: string): void;
-        private updateBounds;
-        private updateState;
-        private postStatus;
-        private startGetterLoop;
-    }
-}
+import { BruceApi } from "../../api/bruce-api";
+import { BruceEvent } from "../../common/bruce-event";
+import { IDictionary } from "../../common/dictionary";
+import { Entity } from "../entity";
+import { EntityGlobe } from "./entity-globe";
+import { ViewMonitor } from "./view-monitor";
+/**
+ * This is a batched entity getter.
+ * It will scan for entity records in a view-area and emit them in batches.
+ * It will restart scanning if the camera moves.
+ */
+export declare namespace EntityFilterGetter {
+    enum EStatus {
+        Scanning = "SCANNING",
+        Loading = "LOADING"
+    }
+    interface IStatusUpdate {
+        msg: EStatus;
+        revoking: boolean;
+    }
+    class Getter {
+        private onUpdate;
+        get OnUpdate(): BruceEvent<Entity.IEntity[]>;
+        LastStateUpdates: IDictionary<IStatusUpdate>;
+        private onStateUpdate;
+        get OnStateUpdate(): BruceEvent<IStatusUpdate>;
+        private onScanUpdate;
+        get OnScanUpdate(): BruceEvent<EntityGlobe.Cell[]>;
+        private api;
+        private viewPort;
+        private viewPortChangeRemoval;
+        private cells;
+        private registeredItems;
+        private getterLoopId;
+        private viaCdn;
+        private typeId;
+        private batchSize;
+        private tagIds;
+        private minHeight;
+        private maxHeight;
+        private attrFilter;
+        private viewRect;
+        private viewCenter;
+        constructor(api: BruceApi.Api, viewPort: ViewMonitor.IMonitor, typeId: string, batchSize?: number, attrFilter?: IDictionary<any>, viaCdn?: boolean);
+        /**
+         * Returns id that represents the combined menu item parameters.
+         * If integrity changes while a request is running, the request will not emit a response.
+         * @returns
+         */
+        private getIntegrityId;
+        private viewAreaSub;
+        private viewAreaDispose;
+        GetMenuItems(): string[];
+        IncludeMenuItem(menuItemId: string, layerIds: number[], minHeight: number, maxHeight: number): void;
+        ExcludeMenuItem(menuItemId: string): void;
+        private updateBounds;
+        private updateState;
+        private postStatus;
+        private startGetterLoop;
+    }
+}

package/dist/types/entity/getters/entity-globe.d.ts

@@ -1,21 +1,21 @@
-import { Bounds } from "../../common/bounds";
-import { Carto } from "../../common/carto";
-/**
- * This is a helper for making entity requests based on a grid area.
- * It will return grid cells based on given view-area then will remember when stuff-
- * was fully-fetched for those cells to avoid making duplicate requests.
- */
-export declare namespace EntityGlobe {
-    class Cell {
-        Fetched: boolean;
-        IsFetched: () => boolean;
-        FetchPageIndex: number;
-        Boundaries: Bounds.IBounds;
-        Fetching: boolean;
-        GetBounds(): Bounds.IReqBounds;
-    }
-    class Grid {
-        private cells;
-        GetCellsForView(cameraPos: Carto.ICarto, viewRect: Bounds.IReqBounds): Cell[];
-    }
-}
+import { Bounds } from "../../common/bounds";
+import { Carto } from "../../common/carto";
+/**
+ * This is a helper for making entity requests based on a grid area.
+ * It will return grid cells based on given view-area then will remember when stuff-
+ * was fully-fetched for those cells to avoid making duplicate requests.
+ */
+export declare namespace EntityGlobe {
+    class Cell {
+        Fetched: boolean;
+        IsFetched: () => boolean;
+        FetchPageIndex: number;
+        Boundaries: Bounds.IBounds;
+        Fetching: boolean;
+        GetBounds(): Bounds.IReqBounds;
+    }
+    class Grid {
+        private cells;
+        GetCellsForView(cameraPos: Carto.ICarto, viewRect: Bounds.IReqBounds): Cell[];
+    }
+}

package/dist/types/entity/getters/view-monitor.d.ts

@@ -1,13 +1,13 @@
-import { Bounds, BruceEvent, Carto } from "../../bruce-models";
-export declare namespace ViewMonitor {
-    interface IArea {
-        bounds: Bounds.IReqBounds;
-        target: Carto.ICarto;
-    }
-    interface IMonitor {
-        Updated(): BruceEvent<IArea>;
-        GetBounds(): Bounds.IReqBounds;
-        GetTarget(): Carto.ICarto;
-        DoUpdate(): void;
-    }
-}
+import { Bounds, BruceEvent, Carto } from "../../bruce-models";
+export declare namespace ViewMonitor {
+    interface IArea {
+        bounds: Bounds.IReqBounds;
+        target: Carto.ICarto;
+    }
+    interface IMonitor {
+        Updated(): BruceEvent<IArea>;
+        GetBounds(): Bounds.IReqBounds;
+        GetTarget(): Carto.ICarto;
+        DoUpdate(): void;
+    }
+}

package/dist/types/import/import-cad.d.ts

@@ -1,49 +1,49 @@
-import { Api } from "../api/api";
-import { BruceApi } from "../api/bruce-api";
-/**
- * TODO: The analysis result is currently a mix of multiple layers of legacy.
- * We will first decide what we want it to do and then describe just the needed portions of the existing implementation.
- */
-export declare namespace ImportCad {
-    interface IAnalyzeParams {
-        "TempFile.ID": string;
-        "OriginalIFCFile.Name": string;
-    }
-    interface IAnalyzeRes {
-        PendingActionID: number;
-    }
-    interface IImportParams {
-        "BRZFilePath"?: string;
-        "TempFile.ID": string;
-        "OriginalIFCFile.Name": string;
-        "IFCSettings": {
-            "ClassificationRules": {
-                "NewIFCStandard.Name": string;
-                "IFCStandard": string;
-                "IsExtendingAllowed": boolean;
-                "AllowAddingNewEntityTypes": boolean;
-                "AllowAddingNewAttributes": boolean;
-                "EntityTypesDerivedFromAttribute": string;
-            };
-        };
-    }
-    interface IImportRes {
-        PendingActionID: number;
-    }
-    function Analyze(params: {
-        api: BruceApi.Api;
-        fileAnalyze: IAnalyzeParams;
-        req?: Api.IReqParams;
-    }): Promise<IAnalyzeRes>;
-    function ImportEntities(params: {
-        api: BruceApi.Api;
-        fileImport: IImportParams;
-        req?: Api.IReqParams;
-    }): Promise<IImportRes>;
-    /**
-     * Parses the completed pending action result from running "ImportEntities".
-     * This will return the root entity's id if any is present.
-     * @param paResult
-     */
-    function ParseRootId(paResult: string | Object): string;
-}
+import { Api } from "../api/api";
+import { BruceApi } from "../api/bruce-api";
+/**
+ * TODO: The analysis result is currently a mix of multiple layers of legacy.
+ * We will first decide what we want it to do and then describe just the needed portions of the existing implementation.
+ */
+export declare namespace ImportCad {
+    interface IAnalyzeParams {
+        "TempFile.ID": string;
+        "OriginalIFCFile.Name": string;
+    }
+    interface IAnalyzeRes {
+        PendingActionID: number;
+    }
+    interface IImportParams {
+        "BRZFilePath"?: string;
+        "TempFile.ID": string;
+        "OriginalIFCFile.Name": string;
+        "IFCSettings": {
+            "ClassificationRules": {
+                "NewIFCStandard.Name": string;
+                "IFCStandard": string;
+                "IsExtendingAllowed": boolean;
+                "AllowAddingNewEntityTypes": boolean;
+                "AllowAddingNewAttributes": boolean;
+                "EntityTypesDerivedFromAttribute": string;
+            };
+        };
+    }
+    interface IImportRes {
+        PendingActionID: number;
+    }
+    function Analyze(params: {
+        api: BruceApi.Api;
+        fileAnalyze: IAnalyzeParams;
+        req?: Api.IReqParams;
+    }): Promise<IAnalyzeRes>;
+    function ImportEntities(params: {
+        api: BruceApi.Api;
+        fileImport: IImportParams;
+        req?: Api.IReqParams;
+    }): Promise<IImportRes>;
+    /**
+     * Parses the completed pending action result from running "ImportEntities".
+     * This will return the root entity's id if any is present.
+     * @param paResult
+     */
+    function ParseRootId(paResult: string | Object): string;
+}

package/dist/types/import/import-csv.d.ts

@@ -1,31 +1,31 @@
-import { Api } from "../api/api";
-import { BruceApi } from "../api/bruce-api";
-export declare namespace ImportCsv {
-    interface IImportParams {
-        "TempFile.ID": string;
-        "CSVSettings": {
-            "IsTitleRow": boolean;
-            "Delimiter": string;
-            "IsRecordQuoted": boolean;
-            "Columns": string[];
-        };
-        "OriginalCSVFile.Name": string;
-        "ImportMode": string;
-        "EntityType.ID": string;
-        "TargetDataSchema": any;
-        "DataMapping": any;
-        "Layers": number[];
-        "SkipUnresolvedRows": boolean;
-        "DeleteNonupdatedEntities": boolean;
-        "Async": boolean;
-        "SkipFailedEntities": boolean;
-    }
-    interface IImportRes {
-        PendingActionID: number;
-    }
-    function ImportEntities(params: {
-        api: BruceApi.Api;
-        fileImport: IImportParams;
-        req?: Api.IReqParams;
-    }): Promise<IImportRes>;
-}
+import { Api } from "../api/api";
+import { BruceApi } from "../api/bruce-api";
+export declare namespace ImportCsv {
+    interface IImportParams {
+        "TempFile.ID": string;
+        "CSVSettings": {
+            "IsTitleRow": boolean;
+            "Delimiter": string;
+            "IsRecordQuoted": boolean;
+            "Columns": string[];
+        };
+        "OriginalCSVFile.Name": string;
+        "ImportMode": string;
+        "EntityType.ID": string;
+        "TargetDataSchema": any;
+        "DataMapping": any;
+        "Layers": number[];
+        "SkipUnresolvedRows": boolean;
+        "DeleteNonupdatedEntities": boolean;
+        "Async": boolean;
+        "SkipFailedEntities": boolean;
+    }
+    interface IImportRes {
+        PendingActionID: number;
+    }
+    function ImportEntities(params: {
+        api: BruceApi.Api;
+        fileImport: IImportParams;
+        req?: Api.IReqParams;
+    }): Promise<IImportRes>;
+}