bruce-models 0.0.1

package/dist/types/file/client-file.d.ts

@@ -0,0 +1,56 @@
+import { BruceApi } from "../bruce-models";
+import { UTC } from "../common/utc";
+export declare namespace ClientFile {
+    function GetCacheKey(fileId: string): string;
+    interface IClientFile {
+        UploadedTimeUTC: UTC.IUTC;
+        FileExt: string;
+        ID: string;
+        MIMEType: string;
+        OriginalFileName: string;
+        OriginalLength: number;
+        "UploadedByUser.ID": string;
+        Purpose: string;
+    }
+    function Get(api: BruceApi, fileId: string): Promise<IClientFile>;
+    function Delete(api: BruceApi, fileIds: string[]): Promise<void>;
+    function Upload(api: BruceApi, file: Blob, onProgress?: (e: ProgressEvent) => void): Promise<IClientFile>;
+    namespace Filter {
+        namespace V1 {
+            enum EColumn {
+                ID = "id",
+                Name = "name",
+                DateTime = "datetime",
+                MIMEType = "mimeType",
+                Size = "size",
+                User = "user",
+                Extension = "extension"
+            }
+            enum ESortOrder {
+                ASC = "asc",
+                DEC = "desc"
+            }
+            enum ERowOperator {
+                AND = "AND",
+                OR = "OR"
+            }
+            interface IRow {
+                column: EColumn;
+                value: any;
+                valueOperator: string;
+                includes: boolean;
+                rowOperator: ERowOperator;
+                rows?: IRow[];
+            }
+            interface IFilter {
+                PageSize?: number;
+                PageIndex?: number;
+                OrderBy?: EColumn;
+                SortOrder?: ESortOrder;
+                Purpose?: string;
+                FilterRows?: IRow[];
+            }
+            function GetList(api: BruceApi, filter: IFilter): Promise<IClientFile[]>;
+        }
+    }
+}

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

@@ -0,0 +1,155 @@
+import { Cartes, EntityAttachmentType } from "../bruce-models";
+export declare namespace Markup {
+    interface IMarkup {
+        divs?: Element.Div.IDiv[];
+        vectors?: Element.Drawing.Drawing[];
+        cesiumObjects?: Element.Cesium.Cesium[];
+        width?: number;
+        height?: number;
+        defaultCameraPos?: any;
+    }
+    namespace Element {
+        namespace Div {
+            enum EType {
+                Default = "default",
+                Callout = "callout"
+            }
+            interface IDiv {
+                id: string;
+                type: EType;
+                contentRows: IRow[];
+                boxShadow?: IBoxShadow;
+                borderRadius?: number;
+                borderUsingPercent?: boolean;
+                borderColor?: string;
+                borderWidth?: number;
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+                screenWidth: number;
+                screenHeight: number;
+            }
+            interface IBoxShadow {
+                horizontal: number;
+                vertical: number;
+                blur: number;
+                spread: number;
+                color: string;
+            }
+            interface IRow {
+                element?: HTMLElement;
+                items: IRowItem[];
+                height: number;
+            }
+            enum EItemType {
+                Default = "DEFAULT",
+                Embed = "EMBED"
+            }
+            interface IRowItem {
+                text: string;
+                embedRaw?: string;
+                action?: ItemAction.IItemAction;
+                bgImage?: IRowItemImage;
+                backgroundColor?: string;
+                fontColor?: string;
+                fontSize?: number;
+                textAlign?: string;
+                verticalAlign?: string;
+                padding?: number;
+                textShadow?: ITextShadow;
+                contentType: EItemType;
+                width: number;
+            }
+            interface IRowItemImage {
+                FileID?: string;
+                UseEntityDefault?: boolean;
+            }
+            interface ITextShadow {
+                horizontal: number;
+                vertical: number;
+                blur: number;
+                color: string;
+            }
+            namespace ItemAction {
+                interface IActionLinkParams {
+                    URL?: string;
+                    bookmarkID?: string;
+                    openInNewTab?: boolean;
+                    closeMarkupOnOpen?: boolean;
+                }
+                interface IActionInfoViewParams {
+                }
+                interface IActionRelationParams {
+                }
+                interface IActionGalleryParams {
+                    documentType?: EntityAttachmentType.EType | string;
+                }
+                interface IItemAction {
+                    type: ItemAction.EType;
+                    params: IActionLinkParams | IActionInfoViewParams | IActionRelationParams | IActionGalleryParams;
+                }
+                enum EType {
+                    None = "NONE",
+                    OpenLink = "LINK",
+                    OpenInfoView = "INFOVIEW",
+                    OpenEntityGallery = "GALLERY",
+                    ToggleRelationships = "RELATIONSHIPS",
+                    Draggable = "DRAGABBLE",
+                    Close = "CLOSE",
+                    OpenBookmark = "BOOKMARK",
+                    OpenMarkup = "MARKUP"
+                }
+            }
+        }
+        namespace Drawing {
+            type Drawing = Line.ILine | Anchor.IAnchor | FreePaint.IPaint;
+            namespace Line {
+                interface ILine {
+                    headSides?: number;
+                    brushColor?: string;
+                    brushHead?: string;
+                    brushSize?: number;
+                    path?: string;
+                    pathType?: string;
+                    screenHeight?: number;
+                    screenWidth?: number;
+                    transform?: string;
+                    angled?: boolean;
+                    snaps?: Anchor.IAnchor[];
+                }
+            }
+            namespace Anchor {
+                interface IAnchor {
+                    id?: string;
+                    side?: number;
+                    snapPosition?: number;
+                    brushHead?: string;
+                    fill?: string;
+                    outlineFactor?: number;
+                    cartesian?: Cartes.ICartes3;
+                    screenPos?: Cartes.ICartes3;
+                    positionFromEntity?: boolean;
+                    stroke?: string;
+                    size?: number;
+                    head?: string;
+                }
+            }
+            namespace FreePaint {
+                interface IPaint {
+                    brushColor: string;
+                    brushHead: string;
+                    brushSize: string;
+                    path: string;
+                    pathType: string;
+                    screenHeight: number;
+                    screenWidth: number;
+                    transform: string;
+                }
+            }
+        }
+        namespace Cesium {
+            type Cesium = null;
+        }
+    }
+}

package/dist/types/program-key/program-key.d.ts

@@ -0,0 +1,21 @@
+import { BruceApi } from "../api/bruce-api";
+declare type Id = ProgramKey.EProgramId | string;
+export declare namespace ProgramKey {
+    function GetCacheKey(programId: string): string;
+    function GetListCacheKey(): string;
+    enum EProgramId {
+        CesiumIon = "CesiumIon",
+        BingMaps = "BingMaps",
+        Mapbox = "Mapbox"
+    }
+    interface IKey {
+        ProgramId: Id;
+        Key: string;
+        IsAccessRestricted?: boolean;
+    }
+    function Get(api: BruceApi, programId: Id): Promise<IKey>;
+    function GetList(api: BruceApi): Promise<IKey[]>;
+    function Delete(api: BruceApi, programId: Id): Promise<void>;
+    function Update(api: BruceApi, data: IKey): Promise<IKey>;
+}
+export {};

package/dist/types/project/menu-item-zoom-control.d.ts

@@ -0,0 +1,18 @@
+import { Style } from "../bruce-models";
+export declare namespace MenuItemZoomControl {
+    enum EDisplayType {
+        Hidden = "hidden",
+        Point = "point",
+        Geometry = "geometry",
+        Model3D = "3d"
+    }
+    interface IItem {
+        MinZoom?: number;
+        MaxZoom?: number;
+        DisplayType?: EDisplayType;
+        StyleID?: number;
+        Style?: Style.IEntitySettings;
+        LODCategoryID?: string;
+        LODLevel?: number | string;
+    }
+}

package/dist/types/project/menu-item.d.ts

@@ -0,0 +1,103 @@
+import { Tileset } from "../tileset/tileset";
+import { MenuItemZoomControl } from "./menu-item-zoom-control";
+export declare namespace MenuItem {
+    enum EType {
+        None = "NONE",
+        BruceEntities = "BruceEntity",
+        BruceEntity = "SingleEntity",
+        Osm = "OSMBuildingsTileset",
+        CadTileset = "ModelTileset",
+        ArbTileset = "Cesium3DTileset",
+        Kml = "StaticKML",
+        EntitiesTileset = "EntitiesTileset",
+        EntitiesRaster = "RasterEntitiesTileset",
+        PointCloud = "PointCloudTileset"
+    }
+    interface ILegend {
+        model3d: boolean;
+        point: boolean;
+        polygon: boolean;
+        polylines: boolean;
+        tileset3d: boolean;
+    }
+    interface IItem {
+        id: string;
+        Caption: string;
+        Children?: IItem[];
+        Type: EType;
+        hideChildren?: boolean;
+        legend?: ILegend;
+        authoringEnabled?: boolean;
+        LabelColor?: string;
+        renderPriority?: number;
+    }
+    function CreateFromEntityId(entityId: string, typeId: string, styleId?: number): IItem;
+    function CreateFromTypeId(typeId: string, styleId?: number): IItem;
+    function CreateFromTilesetId(tilesetId: string, type: Tileset.EType): IItem;
+    namespace Item {
+        interface ITileset {
+            TilesetURL?: string;
+            ClientAccountID?: string;
+            TilesetID?: string;
+        }
+        interface IBruceEntities extends IItem {
+            BruceEntity: {
+                "EntityType.ID": string;
+            };
+            CameraZoomSettings: MenuItemZoomControl.IItem[];
+            showAllLayers: boolean;
+            showAllLayersExcludeBelow: boolean;
+            tagIds: number[];
+        }
+        interface IBruceEntity extends IItem {
+            BruceEntity: {
+                "EntityType.ID": string;
+                EntityId: string;
+            };
+            CameraZoomSettings: MenuItemZoomControl.IItem[];
+            showAllLayers: boolean;
+            showAllLayersExcludeBelow: boolean;
+            tagIds: number[];
+        }
+        interface IArbTileset extends IItem {
+            FlyTo: boolean;
+            BruceEntity?: {
+                "EntityType.ID"?: string;
+            };
+            tileset: ITileset;
+            StyleMapping: any[];
+            styleId: number;
+        }
+        interface ICadTileset extends IItem {
+            FlyTo: boolean;
+            tileset: ITileset;
+            StyleMapping?: any[];
+            styleId?: number;
+        }
+        interface IPointcloud extends IItem {
+            FlyTo: boolean;
+            tileset: ITileset;
+        }
+        interface IEntitiesRaster extends IItem {
+            tileset: ITileset;
+        }
+        interface IOsm extends IItem {
+            BruceEntity?: {
+                "EntityType.ID"?: string;
+                SourceId: string;
+            };
+            ghostLoading: boolean;
+        }
+        interface IKml extends IItem {
+            KML: {
+                ClientFile: {
+                    ID: string;
+                };
+            };
+        }
+        interface IEntitiesTileset extends IItem {
+            FlyTo: boolean;
+            tileset: ITileset;
+        }
+    }
+}

package/dist/types/project/project-view-bookmark.d.ts

@@ -0,0 +1,41 @@
+import { BruceApi } from "../api/bruce-api";
+import { Camera } from "../common/camera";
+import { UTC } from "../common/utc";
+import { Markup } from "../markup/markup";
+export declare namespace ProjectViewBookmark {
+    function GetCacheKey(viewId: string, bookmarkId: string): string;
+    function GetListCacheKey(): string;
+    interface IBookmarkSettings {
+        selectedItemIds?: string[];
+        order?: number;
+        hiddenEntityIds?: string[];
+        drawnRelationEntityIDs?: string[];
+        imagery?: any[];
+        terrain?: string;
+        globeColor?: string;
+        shadows?: boolean;
+        groundOcclusion?: boolean;
+        ambientOcclusion?: boolean;
+        markup?: Markup.IMarkup;
+        cameraFrustum?: Camera.EFrustum;
+        displayTimeline?: boolean;
+        timelineSettings?: any;
+    }
+    interface IBookmark {
+        ID?: string;
+        Camera?: any;
+        "Created.ByUser.ID"?: string;
+        "Created.Date"?: UTC.IUTC;
+        Note?: string;
+        Settings?: IBookmarkSettings;
+        Title?: string;
+        "UI.View.ID"?: string;
+        DisplayOrder?: number;
+        "Screenshot.ClientFile.ID"?: string;
+        "UI.SlideGroup.ID"?: number;
+    }
+    function Get(api: BruceApi, viewId: string, bookmarkId: string): Promise<IBookmark>;
+    function Delete(api: BruceApi, viewId: string, bookmarkId: string): Promise<void>;
+    function GetList(api: BruceApi, viewId: string): Promise<IBookmark[]>;
+    function Update(api: BruceApi, viewId: string, data: IBookmark): Promise<IBookmark>;
+}

package/dist/types/project/project-view-tile-source.d.ts

@@ -0,0 +1,26 @@
+export declare namespace ProjectViewTileSource {
+    interface ISource {
+        IsEnabled?: boolean;
+        IsDefault?: boolean;
+        Name: string;
+        Tooltip?: string;
+        IconUrl?: string;
+    }
+    interface IMapSource extends ISource {
+        SourceUrl?: string;
+        IonAssetID?: number;
+        MapBoxID?: string;
+        MapBoxUsername?: string;
+        ProgramKey?: string;
+        FileExtension?: string;
+        Minimum?: number;
+        Maximum?: number;
+        Type?: string;
+    }
+    interface ITerrainSource extends ISource {
+        RequestWaterMask?: boolean;
+        RequestVertexNormals?: boolean;
+    }
+    function MergeMapTemplateData(items: IMapSource[], addIfMissing: boolean): Promise<IMapSource[]>;
+    function MergeTerrainTemplateData(items: ITerrainSource[], addIfMissing: boolean): Promise<IMapSource[]>;
+}

package/dist/types/project/project-view.d.ts

@@ -0,0 +1,58 @@
+import { BruceApi } from "../api/bruce-api";
+import { UTC } from "../common/utc";
+import { MenuItem } from "./menu-item";
+import { ProjectViewTileSource } from "./project-view-tile-source";
+export declare namespace ProjectView {
+    function GetCacheKey(viewId: string): string;
+    function GetListCacheKey(): string;
+    interface IView {
+        ID: string;
+        Name: string;
+        Description: string;
+        Feature: string[];
+        "CreatedByUser.ID": string;
+        CreatedTime: UTC.IUTC;
+        Settings?: IViewSettings;
+        DefaultUISlideID: string;
+        CreatedByUIVersion: string;
+    }
+    interface IShadowSettings {
+        IsShadowEnabled: boolean;
+        IsShadowSoft: boolean;
+        ShadowSampleSize: number;
+    }
+    interface IViewSettings {
+        BookmarkTransitionSpeed: number;
+        Camera: any;
+        CameraFrustum: number;
+        CesiumMapSources: ProjectViewTileSource.IMapSource[];
+        CesiumTerrainSources: ProjectViewTileSource.ITerrainSource[];
+        ControlsSettings: any;
+        DefaultMapTiles: string;
+        DefaultTerrain: string;
+        DisplayTimeline: boolean;
+        GroundOcclusion: boolean;
+        Extensions: any;
+        GlobeColor: string;
+        SelectionHighlightColor?: string;
+        LayersMenu?: MenuItem.IItem[];
+        OASettings?: any;
+        LogoImage: any;
+        LegendImage: any;
+        IsRestricted: boolean;
+        IsLoginRequired: boolean;
+        TilesetBackfaceCulling: boolean;
+        TopPanelComponents?: string[];
+        LeftPanelComponents?: string[];
+        PostProcessFXAA?: boolean;
+        Shadows: boolean;
+        Shadow: {
+            StaticCamera: IShadowSettings;
+            MovingCamera: IShadowSettings;
+        };
+    }
+    function Get(api: BruceApi, viewId: string): Promise<IView>;
+    function GetList(api: BruceApi): Promise<IView[]>;
+    function Delete(api: BruceApi, viewId: string): Promise<void>;
+    function Update(api: BruceApi, data: IView): Promise<IView>;
+}

package/dist/types/server/pending-action.d.ts

@@ -0,0 +1,33 @@
+import { Api } from "../api/api";
+import { BruceApi, UTC } from "../bruce-models";
+export declare namespace PendingAction {
+    interface IAction {
+        ID: number;
+        "CreatedBy.Application": string;
+        "Created.Time": UTC.IUTC;
+        "CreatedByUser.ID": string;
+        Result: string;
+        Progress: number;
+        "Completed.Time": UTC.IUTC;
+        Description: string;
+        Status: EStatus;
+        lastUpdated: UTC.IUTC;
+    }
+    enum EStatus {
+        InProgress = "IN_PROGRESS",
+        Cancelled = "CANCELLED",
+        Complete = "COMPLETE",
+        Failed = "FAILED"
+    }
+    interface IMessage {
+        "PendingAction.ID": number;
+        ID: number;
+        "CreatedBy.Application": string;
+        "Created.Time": UTC.IUTC;
+        "Message.Type": string;
+        Message: string;
+    }
+    function Get(api: BruceApi, actionId: number): Promise<IAction>;
+    function GetRelevantList(api: BruceApi, stricter?: boolean): Promise<IAction[]>;
+    function GetMessages(api: BruceApi, actionId: number, order?: Api.ESortOrder, startIndex?: number, amount?: number): Promise<IMessage[]>;
+}

package/dist/types/style/style.d.ts

@@ -0,0 +1,32 @@
+import { BruceApi } from "../bruce-models";
+export declare namespace Style {
+    function GetCacheKey(id: number): string;
+    function GetListCacheKey(): string;
+    enum EType {
+        Entity = "ENTITY",
+        EntityRelationship = "ENTITY_RELATIONSHIP"
+    }
+    interface IEntitySettings {
+        pointStyle?: any;
+        polygonStyle?: any;
+        polylineStyle?: any;
+        modelStyle?: any;
+    }
+    interface IRelationSettings {
+        lineColor?: any;
+        lineWidth?: any;
+        heightDistanceRatio?: any;
+        duration?: any;
+    }
+    type Settings = IEntitySettings | IRelationSettings;
+    interface IStyle {
+        ID: number;
+        Name: string;
+        Settings: Settings;
+        Type: EType;
+    }
+    function GetList(api: BruceApi): Promise<IStyle[]>;
+    function Get(api: BruceApi, id: number): Promise<IStyle>;
+    function Update(api: BruceApi, data: IStyle): Promise<IStyle>;
+    function Delete(api: BruceApi, id: number): Promise<void>;
+}

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

@@ -0,0 +1,20 @@
+import { Tileset } from "../bruce-models";
+import { Carto } from "../common/carto";
+export declare namespace TilesetCad {
+    interface ISettings {
+        rootEntityId: string;
+        entityTypeId: string;
+        styleId?: number;
+        lodKey?: string;
+        movePivot?: Tileset.EPivot;
+        ucsId?: number;
+        epsg?: number;
+        thumbFileId?: string;
+        location?: Carto.ICarto;
+        offset?: any;
+        transform?: Tileset.ITransform;
+        doubleSided?: boolean;
+        b3dmFileSize?: number;
+        maximumScreenSpaceError?: number;
+    }
+}

package/dist/types/tileset/tileset-entities-map-tiles.d.ts

@@ -0,0 +1,18 @@
+import { Bounds } from "../common/bounds";
+export declare namespace TilesetEntitiesMapTiles {
+    enum ETileSize {
+        IMG_256 = 256,
+        IMG_512 = 512,
+        IMG_1024 = 1024,
+        IMG_2048 = 2048
+    }
+    interface ISettings {
+        imageSize: ETileSize;
+        levelMin: number;
+        levelMax: number;
+        entityTypeId: string;
+        styleId: number;
+        filter: any;
+        boundaries: Bounds.IBounds;
+    }
+}

package/dist/types/tileset/tileset-entities.d.ts

@@ -0,0 +1,14 @@
+import { Bounds } from "../bruce-models";
+export declare namespace TilesetEntities {
+    interface ISettings {
+        zoomControl?: any[];
+        boundaries?: Bounds.IBounds;
+        filter?: any;
+        altitudeRefType?: string;
+        terrainSource?: string;
+        terrainUri?: string;
+        doubleSided?: boolean;
+        entityTypeId?: string;
+        styleId?: number;
+    }
+}

package/dist/types/tileset/tileset-ext-map-tiles.d.ts

@@ -0,0 +1,17 @@
+export declare namespace TilesetExtMapTiles {
+    enum EType {
+        TileMapImagery = "TileMapImagery",
+        OpenStreetMapImagery = "OpenStreetMapImagery",
+        MapBoxImagery = "MapBoxImagery",
+        CesiumIon = "CesiumIon"
+    }
+    interface ISettings {
+        url?: string;
+        mapType?: EType;
+        sourceExt?: string;
+        ionId?: number;
+        mapBoxStyleId?: string;
+        mapBoxAccount?: string;
+        mapBoxKey?: string;
+    }
+}

package/dist/types/tileset/tileset-ext-terrain-tiles.d.ts

@@ -0,0 +1,6 @@
+export declare namespace TilesetExtTerrainTiles {
+    interface ISettings {
+        requestVertexNormals?: boolean;
+        url?: string;
+    }
+}

package/dist/types/tileset/tileset-map-tiles.d.ts

@@ -0,0 +1,8 @@
+export declare namespace TilesetMapTiles {
+    interface ISettings {
+        sourceFileId: string;
+        imageSize: number;
+        levelMin: number;
+        levelMax: number;
+    }
+}

package/dist/types/tileset/tileset-pointcloud.d.ts

@@ -0,0 +1,15 @@
+import { Tileset } from "../bruce-models";
+import { Carto } from "../common/carto";
+export declare namespace TilesetPointcloud {
+    interface ISettings {
+        sourceFileIds: string[];
+        location: Carto.ICarto;
+        transform: Tileset.ITransform;
+        pntFileSize?: number;
+        epsg?: number;
+        attenuation?: boolean;
+        attenuationMax?: number;
+        movePivot?: Tileset.EPivot;
+        maximumScreenSpaceError?: number;
+    }
+}

package/dist/types/tileset/tileset-terrain-tiles.d.ts

@@ -0,0 +1,6 @@
+export declare namespace TilesetTerrainTiles {
+    interface ISettings {
+        sourceFileId?: string;
+        startLevel?: number;
+    }
+}