bruce-models 0.0.1

package/dist/types/api/idm-api.d.ts

@@ -0,0 +1,13 @@
+import { AbstractApi } from "./abstract-api";
+import { Api } from "./api";
+export declare class IdmApi extends AbstractApi {
+    private baseUrl;
+    private env;
+    constructor(env?: Api.Env);
+    private setBaseUrl;
+    GetBaseUrl(): string;
+    GET(url: string, params?: Api.IReqParams): Promise<any>;
+    DELETE(url: string, params?: Api.IReqParams): Promise<any>;
+    POST(url: string, data: any, params?: Api.IReqParams): Promise<any>;
+    UPLOAD(url: string, blob: Blob, params?: Api.IUploadReqParams): Promise<any>;
+}

package/dist/types/bruce-models.d.ts

@@ -0,0 +1,59 @@
+export * from "./ann-document/ann-document";
+export * from "./api/abstract-api";
+export * from "./api/api";
+export * from "./api/bruce-api";
+export * from "./api/cam-api";
+export * from "./api/idm-api";
+export * from "./calculator/calculator";
+export * from "./common/bounds";
+export * from "./common/bruce-event";
+export * from "./common/cache";
+export * from "./common/camera";
+export * from "./common/cartes";
+export * from "./common/carto";
+export * from "./common/color";
+export * from "./common/delay-queue";
+export * from "./common/dictionary";
+export * from "./common/geometry";
+export * from "./common/transform";
+export * from "./common/utc";
+export * from "./entity/entity-attachment-type";
+export * from "./entity/entity-attachment";
+export * from "./entity/entity-comment";
+export * from "./entity/entity-link";
+export * from "./entity/entity-lod";
+export * from "./entity/entity-relation-type";
+export * from "./entity/entity-relation";
+export * from "./entity/entity-source";
+export * from "./entity/entity-tag";
+export * from "./entity/entity-type";
+export * from "./entity/entity";
+export * from "./entity/getters/view-monitor";
+export * from "./entity/getters/entity-globe";
+export * from "./entity/getters/entity-filter-getter";
+export * from "./file/client-file";
+export * from "./program-key/program-key";
+export * from "./project/menu-item-zoom-control";
+export * from "./project/menu-item";
+export * from "./project/project-view-bookmark";
+export * from "./project/project-view";
+export * from "./server/pending-action";
+export * from "./style/style";
+export * from "./tileset/tileset-cad";
+export * from "./tileset/tileset-entities-map-tiles";
+export * from "./tileset/tileset-entities";
+export * from "./tileset/tileset-ext-map-tiles";
+export * from "./tileset/tileset-ext-terrain-tiles";
+export * from "./tileset/tileset-map-tiles";
+export * from "./tileset/tileset-pointcloud";
+export * from "./tileset/tileset-terrain-tiles";
+export * from "./tileset/tileset";
+export * from "./ucs/ucs";
+export * from "./user/permission";
+export * from "./user/session";
+export * from "./user/user-group";
+export * from "./user/user";
+export * from "./util/encrypt-utils";
+export * from "./util/math-utils";
+export * from "./util/object-utils";
+export * from "./util/path-utils";

package/dist/types/calculator/calculator.d.ts

@@ -0,0 +1,38 @@
+import { Color } from "../common/color";
+import { Entity } from "../entity/entity";
+export declare namespace Calculator {
+    enum EValueType {
+        Color = 0,
+        Input = 1,
+        Gradient = 2,
+        Mapping = 3,
+        TagColor = 4,
+        RandomColor = 5
+    }
+    interface IMappingOption {
+        fieldValue: string;
+        appliedValue: string;
+    }
+    interface IMappingValue {
+        field: string;
+        values: IMappingOption[];
+    }
+    interface IGradientPoint {
+        position: number;
+        color: string;
+    }
+    interface IGradientValue {
+        field: string;
+        min: number;
+        max: number;
+        points: IGradientPoint[];
+    }
+    interface IField {
+        value: IGradientValue | IMappingValue | string | number;
+        type: EValueType;
+    }
+    function GetValue(fields: IField[], entity: Entity.IEntity, tags: any[]): string | number | Color.IColor;
+    function GetMappingValue(value: IMappingValue, entity: Entity.IEntity): string | number;
+    function GetGradientValue(value: IGradientValue, entity: Entity.IEntity): Color.IColor;
+    function GetInputValue(value: string, entity: Entity.IEntity): string | number;
+}

package/dist/types/common/bounds.d.ts

@@ -0,0 +1,17 @@
+export declare namespace Bounds {
+    interface IBounds {
+        maxLatitude: number;
+        maxLongitude: number;
+        minLatitude: number;
+        minLongitude: number;
+        maxAltitude: number;
+        minAltitude: number;
+    }
+    interface IReqBounds {
+        south: number;
+        west: number;
+        north: number;
+        east: number;
+        alt?: number;
+    }
+}

package/dist/types/common/bruce-event.d.ts

@@ -0,0 +1,8 @@
+export declare class BruceEvent<TArgs> {
+    private _counter;
+    private callbacks;
+    Subscribe(callback: (data: TArgs) => void): (() => void);
+    Unsubscribe(id: number): void;
+    Trigger(data?: TArgs): void;
+    Clear(): void;
+}

package/dist/types/common/bruce-variable.d.ts

@@ -0,0 +1,4 @@
+import { Entity } from "../entity/entity";
+export declare namespace BruceVariable {
+    function SwapValues(str: string, data: Entity.IEntity, legacyParse?: boolean): string;
+}

package/dist/types/common/cache.d.ts

@@ -0,0 +1,13 @@
+declare type Key = string | number;
+export declare class CacheControl<T> {
+    private data;
+    Set(id: Key, data: T, duration?: number): void;
+    Get(id: Key): T;
+    Clear(): void;
+    Remove(id: Key): void;
+    RemoveByStartsWith(text: string): void;
+    RemoveByContains(text: string): void;
+    GetKeys(): string[];
+    GetValues(): T[];
+}
+export {};

package/dist/types/common/camera.d.ts

@@ -0,0 +1,6 @@
+export declare namespace Camera {
+    enum EFrustum {
+        Perspective = 0,
+        Orthographic = 1
+    }
+}

package/dist/types/common/cartes.d.ts

@@ -0,0 +1,11 @@
+export declare namespace Cartes {
+    interface ICartes2 {
+        x: number;
+        y: number;
+    }
+    interface ICartes3 extends ICartes2 {
+        z: number;
+    }
+    function ValidateCartes2(cartes: ICartes2): boolean;
+    function ValidateCartes3(cartes: ICartes3): boolean;
+}

package/dist/types/common/carto.d.ts

@@ -0,0 +1,8 @@
+export declare namespace Carto {
+    interface ICarto {
+        latitude: number;
+        longitude: number;
+        altitude: number;
+    }
+    function ValidateCarto(carto: ICarto): boolean;
+}

package/dist/types/common/color.d.ts

@@ -0,0 +1,19 @@
+export declare namespace Color {
+    interface IColor {
+        red: number;
+        green: number;
+        blue: number;
+        alpha: number;
+    }
+    enum EBlendMode {
+        HIGHLIGHT = 0,
+        REPLACE = 1,
+        MIX = 2
+    }
+    interface IBlendSettings {
+        blendMode?: EBlendMode;
+        blendPercent?: number;
+    }
+    function RandomColor(): IColor;
+    function ColorFromStr(str: string): IColor;
+}

package/dist/types/common/delay-queue.d.ts

@@ -0,0 +1,10 @@
+export declare class DelayQueue {
+    private callback;
+    delay: number;
+    private lastCallTime;
+    private delayTimeout;
+    constructor(callback: () => void, delay?: number);
+    Call(force?: boolean): void;
+    private doCall;
+    Dispose(): void;
+}

package/dist/types/common/dictionary.d.ts

@@ -0,0 +1,3 @@
+export interface IDictionary<T> {
+    [key: string]: T;
+}

package/dist/types/common/geometry.d.ts

@@ -0,0 +1,14 @@
+import { Carto } from "./carto";
+export declare namespace Geometry {
+    interface IGeometry {
+        Polygon?: any[];
+        MultiGeometry?: IGeometry[];
+        Point?: string;
+        LineString?: string;
+        MultiSurface?: string;
+    }
+    function LineStrFromPoints(points: Carto.ICarto[]): string;
+    function RemoveRepeatPoints(positions: Carto.ICarto[]): Carto.ICarto[];
+    function ParsePoints(data: string): Carto.ICarto[];
+    function ParseGeometry(geometry: any): IGeometry;
+}

package/dist/types/common/transform.d.ts

@@ -0,0 +1,8 @@
+export declare namespace Transform {
+    interface ITransform {
+        heading: number;
+        pitch: number;
+        roll: number;
+        scale: number;
+    }
+}

package/dist/types/common/utc.d.ts

@@ -0,0 +1,26 @@
+export declare namespace UTC {
+    enum EMonth {
+        January = 1,
+        February = 2,
+        March = 3,
+        April = 4,
+        May = 5,
+        June = 6,
+        July = 7,
+        August = 8,
+        September = 9,
+        October = 10,
+        November = 11,
+        December = 12
+    }
+    interface IUTC {
+        d: number;
+        hh: number;
+        m: EMonth | number;
+        mm: number;
+        ss: number;
+        y: number;
+    }
+    function ToDate(utc: IUTC): Date;
+    function FromDate(date: Date): IUTC;
+}

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

@@ -0,0 +1,22 @@
+import { BruceApi } from "../api/bruce-api";
+declare type Type = EntityAttachmentType.EType | string;
+export declare namespace EntityAttachmentType {
+    function GetCacheKey(id: Type): string;
+    function GetListCacheKey(): string;
+    interface IType {
+        Description: string;
+        ID: string | EType;
+        Name: string;
+    }
+    enum EType {
+        Photo = "photo",
+        Document = "document",
+        Video = "video",
+        Drawing = "drawing",
+        Model = "model"
+    }
+    function Delete(api: BruceApi, id: Type): Promise<void>;
+    function Update(api: BruceApi, data: IType): Promise<IType>;
+    function GetList(api: BruceApi): Promise<IType[]>;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { BruceApi } from "../bruce-models";
+import { ClientFile } from "../file/client-file";
+import { EntityAttachmentType } from "./entity-attachment-type";
+declare type Type = EntityAttachmentType.EType | string;
+export declare namespace EntityAttachment {
+    function GetCacheKey(entityId: string, typeId: Type, fileId: string): string;
+    function GetListCacheKey(entityId: string): string;
+    interface IAttachment {
+        ClientFile: ClientFile.IClientFile;
+        Group: string;
+        "ClientFile.ID": string;
+        DisplayOrder: number;
+        "Entity.ID": string;
+        "EntityAttachmentType.ID": Type;
+    }
+    function Update(api: BruceApi, data: IAttachment): Promise<IAttachment>;
+    function UpdateOrder(api: BruceApi, entityId: string, typeId: Type, fileIds: string[]): Promise<void>;
+    function Delete(api: BruceApi, data: IAttachment): Promise<void>;
+    function DeleteByFileIds(api: BruceApi, entityId: string, typeId: Type, fileIds: string[]): Promise<void>;
+    function GetListByEntityId(api: BruceApi, entityId: string): Promise<IAttachment[]>;
+    function Upload(api: BruceApi, file: Blob, entityId: string, typeId: Type, onProgress?: (e: ProgressEvent) => void): Promise<IAttachment>;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { BruceApi, UTC } from "../bruce-models";
+export declare namespace EntityComment {
+    function GetCacheKey(id: number): string;
+    function GetListCacheKey(entityId: string): string;
+    interface IComment {
+        Comment: string;
+        "Created.ByUser.ID": string;
+        "Created.Date": UTC.IUTC;
+        ID: number;
+        RepliesCount: number;
+        "ReplyTo.Comment.ID": number;
+        "TargetObject.ID": string;
+        "TargetObject.Type": string;
+    }
+    function Update(api: BruceApi, data: IComment): Promise<IComment>;
+    function Delete(api: BruceApi, entityId: string, commentId: number): Promise<void>;
+    function GetListByEntityId(api: BruceApi, entityId: string): Promise<IComment[]>;
+}

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

@@ -0,0 +1,14 @@
+import { BruceApi } from "../bruce-models";
+export declare namespace EntityLink {
+    function GetCacheKey(id: number): string;
+    function GetListCacheKey(entityId: string): string;
+    interface ILink {
+        DisplayName: string;
+        ID?: number;
+        "Entity.ID": string;
+        URL: string;
+    }
+    function Update(api: BruceApi, data: ILink): Promise<ILink>;
+    function Delete(api: BruceApi, entityId: string, linkId: number): Promise<void>;
+    function GetListByEntityId(api: BruceApi, entityId: string): Promise<ILink[]>;
+}

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

@@ -0,0 +1,31 @@
+import { BruceApi } from "../bruce-models";
+export declare namespace EntityLod {
+    function GetCacheKey(url: string): string;
+    interface ILod {
+        "ClientFile.ID": string;
+        "Entity.ID": string;
+        "LODCategory.Key": string;
+        Level: number;
+    }
+    function GetUrl(api: BruceApi, entityId: string, categoryId: string, level: number, strict?: boolean): string;
+    function GetUrlFileId(api: BruceApi, url: string): Promise<string>;
+    function GetLods(api: BruceApi, params: Filter.IListParams): Promise<Filter.IListResItem[]>;
+    namespace Filter {
+        interface IListParamsItem {
+            "entityId": string;
+            "categoryId": string;
+            "group"?: string;
+            "level"?: number;
+        }
+        interface IListParams {
+            "strict": boolean;
+            "externalSources": boolean;
+            "Items": IListParamsItem[];
+        }
+        interface IListResItem {
+            clientFileId: string;
+            entityId: string;
+            accountId: string;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { BruceApi } from "../api/bruce-api";
+export declare namespace EntityRelationType {
+    function GetCacheKey(id: string): string;
+    function GetListCacheKey(): string;
+    interface IType {
+        ID: string;
+        ForwardName: string;
+        ReverseName: string;
+        Name: string;
+        FlipDisplayDirection?: boolean;
+        EntityDisplaySettingID?: string;
+        "Relation.EntityType.ID"?: string;
+    }
+    function Get(api: BruceApi, typeId: string): Promise<IType>;
+    function Delete(api: BruceApi, typeId: string): Promise<void>;
+    function GetList(api: BruceApi): Promise<IType[]>;
+    function Update(api: BruceApi, data: IType): Promise<IType>;
+}

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

@@ -0,0 +1,24 @@
+import { BruceApi } from "../api/bruce-api";
+import { Entity } from "./entity";
+export declare namespace EntityRelation {
+    function GetCacheKey(entityA: string, entityB: string, typeId: string): string;
+    function GetEntityCacheKey(entityId: string): string;
+    function GetListCacheKey(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 {
+        typeId?: string;
+        oneWayOnly?: boolean;
+        loadEntityData?: boolean;
+    }
+    function Update(api: BruceApi, data: IRelation): Promise<IRelation>;
+    function GetList(api: BruceApi, entityId: string, params: IListParams): Promise<IRelation[]>;
+    function GetByDataEntityId(api: BruceApi, entityId: string): Promise<IRelation>;
+}

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

@@ -0,0 +1,12 @@
+import { BruceApi, IDictionary } from "../bruce-models";
+export declare namespace EntitySource {
+    function GetCacheKey(sourceId: number, sourceKey: string): string;
+    interface ISource {
+        "Entity.ID": string;
+        "Source.ID": number;
+        "SourceRecord.Key": string;
+    }
+    function Get(api: BruceApi, sourceId: number, sourceKey: string): Promise<ISource>;
+    function GetListByKeys(api: BruceApi, sourceId: number, sourceKeys: string[]): Promise<ISource[]>;
+    function GetEntityIdsBySourceKeys(api: BruceApi, sourceId: number, sourceKeys: string[]): Promise<IDictionary<string>>;
+}

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

@@ -0,0 +1,18 @@
+import { BruceApi } from "../api/bruce-api";
+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;
+    }
+    function Get(api: BruceApi, tagId: number): Promise<ITag>;
+    function GetListByIds(api: BruceApi, tagIds: number[]): Promise<ITag[]>;
+    function GetList(api: BruceApi, entityTypeId?: string): Promise<ITag[]>;
+    function Delete(api: BruceApi, tagId: number): Promise<void>;
+    function Update(api: BruceApi, data: ITag): Promise<ITag>;
+}

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

@@ -0,0 +1,48 @@
+import { BruceApi } from "../api/bruce-api";
+import { UTC } from "../bruce-models";
+export declare namespace EntityType {
+    function GetCacheKey(typeId: string): string;
+    function GetListCacheKey(): string;
+    interface IEntityType {
+        ID?: string;
+        IsDeleted?: boolean;
+        Name: string;
+        Description?: string;
+        Data?: any;
+        DataSchema?: IAttribute;
+        DisplayNameAttributePath?: string;
+        "DisplaySetting.ID"?: number;
+        AuthoringSettings?: {
+            enabledTools: string[];
+            defaultTool: string;
+        };
+        "LastUpdate.Time"?: UTC.IUTC;
+        "Parent.EntityType.ID"?: string;
+    }
+    interface IAttribute {
+        Key: string;
+        Name?: string;
+        Type?: EAttributeType;
+        Size?: number;
+        IsIndexed?: boolean;
+        IsArray?: boolean;
+        IsImportant?: boolean;
+        Description?: string;
+        Structure?: IAttribute[];
+        IsFamilyAttribute?: boolean;
+        IsFamilyAttributeDefault?: boolean;
+        Sources?: string[];
+    }
+    enum EAttributeType {
+        String = "String",
+        Double = "Double",
+        Integer = "Integer",
+        Datetime = "Datetime",
+        Structure = "Structure",
+        Geometry = "Geometry"
+    }
+    function Get(api: BruceApi, typeId: string): Promise<IEntityType>;
+    function Delete(api: BruceApi, typeId: string): Promise<void>;
+    function GetList(api: BruceApi): Promise<IEntityType[]>;
+    function Update(api: BruceApi, data: IEntityType): Promise<IEntityType>;
+}

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

@@ -0,0 +1,51 @@
+import { Api } from "../api/api";
+import { BruceApi } from "../api/bruce-api";
+import { Bounds } from "../common/bounds";
+import { Carto } from "../common/carto";
+import { Geometry } from "../common/geometry";
+import { Transform } from "../common/transform";
+import { UTC } from "../common/utc";
+import { IDictionary } from "../bruce-models";
+declare type _any = any;
+export declare namespace Entity {
+    function GetCacheKey(entityId: string): 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;
+    }
+    function Get(api: BruceApi, entityId: string): Promise<IEntity>;
+    function GetListByIds(api: BruceApi, entityIds: string[]): Promise<IEntity[]>;
+    function Delete(api: BruceApi, entityId: string): Promise<void>;
+    function Update(api: BruceApi, data: IEntity, override: boolean): Promise<IEntity>;
+    function RemoveTag(data: IEntity, tagId: number): void;
+    function AddTag(data: IEntity, tagId: number): void;
+    function SetValue(data: IEntity, path: string[], value: any): void;
+    function GetValue(data: IEntity, path: string[]): any;
+    namespace Filter {
+        namespace V1 {
+            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(api: BruceApi, filter: IFilter): Promise<IEntity[]>;
+        }
+    }
+}
+export {};

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

@@ -0,0 +1,46 @@
+import { BruceApi } from "../../api/bruce-api";
+import { BruceEvent } from "../../common/bruce-event";
+import { IDictionary } from "../../common/dictionary";
+import { Entity } from "../entity";
+import { ViewMonitor } from "./view-monitor";
+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 api;
+        private viewPort;
+        private viewPortChangeRemoval;
+        private cells;
+        private registeredItems;
+        private getterLoopId;
+        private typeId;
+        private batchSize;
+        private tagIds;
+        private minHeight;
+        private maxHeight;
+        private attrFilter;
+        private viewRect;
+        private viewCenter;
+        constructor(api: BruceApi, viewPort: ViewMonitor.IMonitor, typeId: string, batchSize: number, attrFilter: IDictionary<any>);
+        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

@@ -0,0 +1,15 @@
+import { Bounds } from "../../bruce-models";
+declare class Cell {
+    Fetched: boolean;
+    IsFetched: () => boolean;
+    FetchPageIndex: number;
+    Boundaries: Bounds.IBounds;
+    GetBounds(): Bounds.IReqBounds;
+}
+export declare namespace EntityGlobe {
+    class Grid {
+        private cells;
+        GetCellsForView(viewRect: Bounds.IReqBounds): Cell[];
+    }
+}
+export {};

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

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