bruce-models 1.3.7 → 1.3.9

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

@@ -5,8 +5,8 @@ import { Cartes, EntityAttachmentType } from "../bruce-models";
 export declare namespace Markup {
     interface IMarkup {
         divs?: Div.IDiv[];
-        vectors?: Drawing.Drawing[];
-        cesiumObjects?: Entity3d.Entity3d[];
+        vectors?: (Line.ILine | FreePaint.IPaint)[];
+        cesiumObjects?: (Polygon.IPolygon | Polyline.IPolyline | Circle.ICircle | Walkscore.IWalkscore)[];
         width?: number;
         height?: number;
         defaultCameraPos?: any;
@@ -109,116 +109,115 @@ export declare namespace Markup {
         }
         const DEFAULT: IDiv;
     }
-    namespace Drawing {
-        type Drawing = Line.ILine | Line.IAnchor | FreePaint.IPaint;
-        enum EHeadStyle {
+    namespace Line {
+        enum ELineHead {
             None = "NONE",
             Circle = "CIRCLE",
             Arrow = "ARROW"
         }
-        namespace Line {
-            interface ILine extends IElement {
-                pathType: "LINE";
-                path: string;
-                transform: string;
-                snaps: IAnchor[];
-                brushColor?: string;
-                brushSize?: number;
-                angled?: boolean;
-                brushHead?: EHeadStyle;
-                outlineColor?: string;
-            }
-            enum EAnchorDivSide {
-                TopLeft = 0,
-                TopRight = 1,
-                BottomLeft = 2,
-                BottomRight = 3,
-                Center = 4,
-                CenterLeft = 5,
-                CenterRight = 6,
-                CenterTop = 7,
-                CenterBottom = 8
-            }
-            enum EAnchorLineSide {
-                Start = 0,
-                End = 1
-            }
-            interface IAnchor {
-                id?: string;
-                snapPosition?: EAnchorDivSide;
-                side?: EAnchorLineSide;
-                brushHead?: EHeadStyle;
-                fill?: string;
-                size?: number;
-                outlineFactor?: number;
-                stroke?: string;
-                cartesian?: Cartes.ICartes3;
-                screenPos?: Cartes.ICartes2;
-                positionFromEntity?: boolean;
-            }
-            const DEFAULT: ILine;
-        }
-        namespace FreePaint {
-            interface IPaint extends IElement {
-                pathType: "PLAIN";
-                path: string;
-                transform: string;
-                brushColor?: string;
-                brushSize?: number;
-                brushHead?: EHeadStyle;
-                outlineColor?: string;
-            }
-            const DEFAULT: IPaint;
-        }
+        interface ILine extends IElement {
+            pathType: "LINE";
+            path: string;
+            transform: string;
+            snaps: IAnchor[];
+            brushColor?: string;
+            brushSize?: number;
+            angled?: boolean;
+            brushHead?: ELineHead;
+            outlineColor?: string;
+        }
+        enum EAnchorDivSide {
+            TopLeft = 0,
+            TopRight = 1,
+            BottomLeft = 2,
+            BottomRight = 3,
+            Center = 4,
+            CenterLeft = 5,
+            CenterRight = 6,
+            CenterTop = 7,
+            CenterBottom = 8
+        }
+        enum EAnchorLineSide {
+            Start = 0,
+            End = 1
+        }
+        interface IAnchor {
+            id?: string;
+            snapPosition?: EAnchorDivSide;
+            side?: EAnchorLineSide;
+            brushHead?: ELineHead;
+            fill?: string;
+            size?: number;
+            outlineFactor?: number;
+            stroke?: string;
+            cartesian?: Cartes.ICartes3;
+            screenPos?: Cartes.ICartes2;
+            positionFromEntity?: boolean;
+        }
+        const DEFAULT: ILine;
     }
-    namespace Entity3d {
-        type Entity3d = Polygon.IPolygon | Polyline.IPolyline | Circle.ICircle | Walkscore.IWalkscore;
-        namespace Polygon {
-            enum EClassificationType {
-                Both = "BOTH",
-                Terrain = "TERRAIN"
-            }
-            interface IPolygon extends IElement {
-                type: "POLYGON";
-                positions: Cartes.ICartes3[];
-                color?: string;
-                outlineColor?: string;
-                outlineWidth?: number;
-                extrudedHeight?: number;
-                classificationType?: EClassificationType;
-                smoothen?: number;
-            }
-            const DEFAULT: IPolygon;
-        }
-        namespace Polyline {
-            interface IPolyline extends IElement {
-                type: "POLYLINE";
-                positions: Cartes.ICartes3[];
-                color?: string;
-                outlineWidth?: number;
-                smoothen?: number;
-            }
-            const DEFAULT: IPolyline;
-        }
-        namespace Circle {
-            interface ICircle extends IElement {
-                type: "CIRCLE";
-                position: Cartes.ICartes3;
-                radius: number;
-                color?: string;
-                outlineWidth?: number;
-                extrudedHeight?: number;
-                outlineExtrusion?: number;
-                outlineColor?: string;
-            }
-            const DEFAULT: ICircle;
+    namespace FreePaint {
+        enum EPaintHead {
+            None = "NONE",
+            Circle = "CIRCLE",
+            Arrow = "ARROW"
         }
-        namespace Walkscore {
-            interface IWalkscore extends IElement {
-                type: "WALKSCORE";
-                cartesian: Cartes.ICartes3;
-                details: number;
-            }
+        interface IPaint extends IElement {
+            pathType: "PLAIN";
+            path: string;
+            transform: string;
+            brushColor?: string;
+            brushSize?: number;
+            brushHead?: EPaintHead;
+            outlineColor?: string;
+        }
+        const DEFAULT: IPaint;
+    }
+    namespace Polygon {
+        enum EClassificationType {
+            Both = "BOTH",
+            Terrain = "TERRAIN"
+        }
+        interface IPolygon extends IElement {
+            type: "POLYGON";
+            positions: Cartes.ICartes3[];
+            color?: string;
+            outlineColor?: string;
+            outlineWidth?: number;
+            extrudedHeight?: number;
+            classificationType?: EClassificationType;
+            smoothen?: number;
+        }
+        const DEFAULT: IPolygon;
+    }
+    namespace Polyline {
+        interface IPolyline extends IElement {
+            type: "POLYLINE";
+            positions: Cartes.ICartes3[];
+            color?: string;
+            outlineWidth?: number;
+            smoothen?: number;
+        }
+        const DEFAULT: IPolyline;
+    }
+    namespace Circle {
+        interface ICircle extends IElement {
+            type: "CIRCLE";
+            position: Cartes.ICartes3;
+            radius: number;
+            color?: string;
+            outlineWidth?: number;
+            extrudedHeight?: number;
+            outlineExtrusion?: number;
+            outlineColor?: string;
+        }
+        const DEFAULT: ICircle;
+    }
+    namespace Walkscore {
+        interface IWalkscore extends IElement {
+            type: "WALKSCORE";
+            cartesian: Cartes.ICartes3;
+            details: number;
         }
     }
 }

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

@@ -18,9 +18,30 @@ export declare namespace ProgramKey {
         Key: string;
         IsAccessRestricted?: boolean;
     }
-    function Get(api: BruceApi.Api, programId: Id, reqParams?: Api.IReqParams): Promise<IKey>;
-    function GetList(api: BruceApi.Api, reqParams?: Api.IReqParams): Promise<IKey[]>;
-    function Delete(api: BruceApi.Api, programId: Id, reqParams?: Api.IReqParams): Promise<void>;
-    function Update(api: BruceApi.Api, data: IKey, reqParams?: Api.IReqParams): Promise<IKey>;
+    function Get(params: {
+        api: BruceApi.Api;
+        programId: Id;
+        req?: Api.IReqParams;
+    }): Promise<{
+        programKey: IKey;
+    }>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        req?: Api.IReqParams;
+    }): Promise<{
+        programKeys: IKey[];
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        programId: Id;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Update(params: {
+        api: BruceApi.Api;
+        programKey: IKey;
+        req?: Api.IReqParams;
+    }): Promise<{
+        programKey: IKey;
+    }>;
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { IDictionary } from "../bruce-models";
 import { Entity } from "../entity/entity";
 import { Tileset } from "../tileset/tileset";
 import { ZoomControl } from "./zoom-control";
@@ -51,7 +52,7 @@ export declare namespace MenuItem {
         interface IBruceEntities extends IItem {
             BruceEntity: {
                 "EntityType.ID": string;
-                Filter?: Entity.Filter.V1.AttrFilter;
+                Filter?: IDictionary<string>;
             };
             CameraZoomSettings: ZoomControl.IItem[];
             showAllLayers: boolean;

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

@@ -14,7 +14,7 @@ export declare namespace ProjectViewBookmark {
     function GetCacheKey(viewId: string, bookmarkId: string): string;
     function GetListCacheKey(viewId: string): string;
     const DEFAULT_DATA_VERSION = 1;
-    interface IBookmarkMeta {
+    interface IBaseBookmark {
         ID?: string;
         Title?: string;
         Note?: string;
@@ -24,13 +24,21 @@ export declare namespace ProjectViewBookmark {
         "Created.Date"?: UTC.IUTC;
         "UI.SlideGroup.ID"?: number;
         DataVersion: number;
+        DisplayOrder?: number;
+        Settings?: IBaseSettings;
     }
-    type Bookmark = V1.IBookmark | V2.IBookmark;
-    namespace V1 {
+    /**
+     * These are the base settings expected in any bookmark data-version.
+     * The only exception is data-version = 1 which is our deprecated legacy format.
+     */
+    interface IBaseSettings {
+        menuItemIds?: string[];
+    }
+    type Bookmark = LegacyNavigator.IBookmark | Navigator.IBookmark | IBaseBookmark;
+    namespace LegacyNavigator {
         const DATA_VERSION = 1;
-        interface IBookmark extends IBookmarkMeta {
+        interface IBookmark extends IBaseBookmark {
             Camera?: ICamera;
-            DisplayOrder?: number;
             Settings?: ISettings;
         }
         interface IBookmarkImagery {
@@ -42,7 +50,7 @@ export declare namespace ProjectViewBookmark {
             brightness: number;
             alpha: number;
         }
-        interface ISettings {
+        interface ISettings extends IBaseSettings {
             selectedItemIds?: string[];
             order?: number;
             hiddenEntityIds?: string[];
@@ -74,15 +82,13 @@ export declare namespace ProjectViewBookmark {
             roll: number;
         }
     }
-    namespace V2 {
+    namespace Navigator {
         const DATA_VERSION = 2;
-        interface IBookmark extends IBookmarkMeta {
+        interface IBookmark extends IBaseBookmark {
             Camera?: ICamera;
-            DisplayOrder?: number;
             Settings?: ISettings;
         }
-        interface ISettings {
-            menuItemIds?: string[];
+        interface ISettings extends IBaseSettings {
             groundOcclusion?: boolean;
             imagery?: ProjectViewTile.IBookmarkImagery[];
             terrain?: ProjectViewTile.IBookmarkTerrain;
@@ -128,9 +134,39 @@ export declare namespace ProjectViewBookmark {
             cameraFrustum?: Camera.EFrustum;
         }
     }
-    function Get(api: BruceApi.Api, viewId: string, bookmarkId: string, reqParams?: Api.IReqParams): Promise<Bookmark>;
-    function Delete(api: BruceApi.Api, viewId: string, bookmarkId: string, reqParams?: Api.IReqParams): Promise<void>;
-    function GetList(api: BruceApi.Api, viewId: string, reqParams?: Api.IReqParams): Promise<Bookmark[]>;
-    function Update(api: BruceApi.Api, viewId: string, data: Bookmark, reqParams?: Api.IReqParams): Promise<Bookmark>;
-    function SetOrder(api: BruceApi.Api, viewId: string, bookmarkIds: string[], reqParams?: Api.IReqParams): Promise<void>;
+    function Get(params: {
+        api: BruceApi.Api;
+        viewId: string;
+        bookmarkId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        bookmark: Bookmark;
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        viewId: string;
+        bookmarkId: string;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        viewId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        bookmarks: Bookmark[];
+    }>;
+    function Update(params: {
+        api: BruceApi.Api;
+        viewId: string;
+        bookmark: Bookmark;
+        req?: Api.IReqParams;
+    }): Promise<{
+        bookmark: Bookmark;
+    }>;
+    function SetOrder(params: {
+        api: BruceApi.Api;
+        viewId: string;
+        bookmarkIds: string[];
+        req?: Api.IReqParams;
+    }): Promise<void>;
 }

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

@@ -29,6 +29,20 @@ export declare namespace ProjectViewLegacyTile {
         RequestWaterMask?: boolean;
         RequestVertexNormals?: boolean;
     }
-    function MergeMapTemplateData(getter: BruceApi.IGetter, items: IMapSource[], addIfMissing: boolean, reqParams?: Api.IReqParams): Promise<IMapSource[]>;
-    function MergeTerrainTemplateData(getter: BruceApi.IGetter, items: ITerrainSource[], addIfMissing: boolean, reqParams?: Api.IReqParams): Promise<IMapSource[]>;
+    function MergeMapTemplateData(params: {
+        getter: BruceApi.IGetter;
+        sources: IMapSource[];
+        addIfMissing: boolean;
+        req?: Api.IReqParams;
+    }): Promise<{
+        sources: IMapSource[];
+    }>;
+    function MergeTerrainTemplateData(params: {
+        getter: BruceApi.IGetter;
+        sources: ITerrainSource[];
+        addIfMissing: boolean;
+        req?: Api.IReqParams;
+    }): Promise<{
+        sources: ITerrainSource[];
+    }>;
 }

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

@@ -14,7 +14,7 @@ export declare namespace ProjectView {
     function GetCacheKey(viewId: string): string;
     function GetListCacheKey(): string;
     const DEFAULT_DATA_VERSION = 1;
-    interface IViewMeta {
+    interface IBaseView {
         ID?: string;
         Name: string;
         Description?: string;
@@ -25,16 +25,26 @@ export declare namespace ProjectView {
         CreatedByUIVersion?: string;
         DataVersion: number;
         SupportEmail?: string;
+        Settings?: IBaseSettings;
     }
-    type View = V1.IView | V2.IView;
-    namespace V1 {
+    /**
+     * These are the base settings expected in any project view data-version.
+     * The only exception is data-version = 1 which is our deprecated legacy format.
+     */
+    interface IBaseSettings {
+        menuItems?: MenuItem.IItem[];
+        IsLoginRequired?: boolean;
+        IsRestricted?: boolean;
+    }
+    type View = LegacyNavigator.IView | Navigator.IView | IBaseView;
+    namespace LegacyNavigator {
         const DATA_VERSION = 1;
         interface IShadowSettings {
             IsShadowEnabled: boolean;
             IsShadowSoft: boolean;
             ShadowSampleSize: number;
         }
-        interface ISettings {
+        interface ISettings extends IBaseSettings {
             BookmarkTransitionSpeed: number;
             Camera: any;
             CameraFrustum: number;
@@ -52,8 +62,6 @@ export declare namespace ProjectView {
             OASettings?: any;
             LogoImage: any;
             LegendImage: any;
-            IsRestricted: boolean;
-            IsLoginRequired: boolean;
             TilesetBackfaceCulling: boolean;
             TopPanelComponents?: string[];
             LeftPanelComponents?: string[];
@@ -64,21 +72,20 @@ export declare namespace ProjectView {
                 MovingCamera: IShadowSettings;
             };
         }
-        interface IView extends IViewMeta {
+        interface IView extends IBaseView {
             Settings: ISettings;
         }
     }
-    namespace V2 {
+    namespace Navigator {
         const DATA_VERSION = 2;
-        interface ISettings {
-            contact?: IContact;
-            menuItems?: MenuItem.IItem[];
+        interface ISettings extends IBaseSettings {
             imageries?: ProjectViewTile.IViewImagery[];
             terrains?: ProjectViewTile.IViewTerrain[];
             defaults?: {
-                camera?: ProjectViewBookmark.V2.ICamera;
-                settings?: ProjectViewBookmark.V2.ISettings;
+                camera?: ProjectViewBookmark.Navigator.ICamera;
+                settings?: ProjectViewBookmark.Navigator.ISettings;
             };
+            contact?: IContact;
         }
         /**
          * Describes how to present contact information to the users.
@@ -88,12 +95,33 @@ export declare namespace ProjectView {
             description?: string;
             icon?: string;
         }
-        interface IView extends IViewMeta {
+        interface IView extends IBaseView {
             Settings: ISettings;
         }
     }
-    function Get(api: BruceApi.Api, viewId: string, reqParams?: Api.IReqParams): Promise<View>;
-    function GetList(api: BruceApi.Api, reqParams?: Api.IReqParams): Promise<View[]>;
-    function Delete(api: BruceApi.Api, viewId: string, reqParams?: Api.IReqParams): Promise<void>;
-    function Update(api: BruceApi.Api, data: View, reqParams?: Api.IReqParams): Promise<View>;
+    function Get(params: {
+        api: BruceApi.Api;
+        viewId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        view: View;
+    }>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        req?: Api.IReqParams;
+    }): Promise<{
+        views: View[];
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        viewId: string;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Update(params: {
+        api: BruceApi.Api;
+        view: View;
+        req?: Api.IReqParams;
+    }): Promise<{
+        view: View;
+    }>;
 }

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

@@ -32,7 +32,28 @@ export declare namespace PendingAction {
         "Message.Type": string;
         Message: string;
     }
-    function Get(api: BruceApi.Api, actionId: number, reqParams?: Api.IReqParams): Promise<IAction>;
-    function GetRelevantList(api: BruceApi.Api, stricter?: boolean, reqParams?: Api.IReqParams): Promise<IAction[]>;
-    function GetMessages(api: BruceApi.Api, actionId: number, order?: Api.ESortOrder, startIndex?: number, amount?: number, reqParams?: Api.IReqParams): Promise<IMessage[]>;
+    function Get(params: {
+        api: BruceApi.Api;
+        actionId: number;
+        req?: Api.IReqParams;
+    }): Promise<{
+        action: IAction;
+    }>;
+    function GetRelevantList(params: {
+        api: BruceApi.Api;
+        stricter?: boolean;
+        reqParams?: Api.IReqParams;
+    }): Promise<{
+        actions: IAction[];
+    }>;
+    function GetMessages(params: {
+        api: BruceApi.Api;
+        actionId: number;
+        order?: Api.ESortOrder;
+        startIndex?: number;
+        amount?: number;
+        req?: Api.IReqParams;
+    }): Promise<{
+        messages: IMessage[];
+    }>;
 }

package/dist/types/server/task.d.ts

@@ -18,6 +18,19 @@ export declare namespace Task {
     enum ETaskPurpose {
         BackupRestore = "BackupRestore"
     }
-    function Get(api: GlobalApi.Api, id: number, reqParams?: Api.IReqParams): Promise<ITask>;
-    function GetList(api: GlobalApi.Api, accountId?: string, type?: ETaskPurpose, reqParams?: Api.IReqParams): Promise<ITask[]>;
+    function Get(params: {
+        api: GlobalApi.Api;
+        taskId: number;
+        req?: Api.IReqParams;
+    }): Promise<{
+        task: ITask;
+    }>;
+    function GetList(params: {
+        api: GlobalApi.Api;
+        accountId?: string;
+        type?: ETaskPurpose;
+        req?: Api.IReqParams;
+    }): Promise<{
+        tasks: ITask[];
+    }>;
 }

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

@@ -79,8 +79,29 @@ export declare namespace Style {
         Settings: Settings;
         Type: EType;
     }
-    function GetList(api: BruceApi.Api, reqParams?: Api.IReqParams): Promise<IStyle[]>;
-    function Get(api: BruceApi.Api, id: number, reqParams?: Api.IReqParams): Promise<IStyle>;
-    function Update(api: BruceApi.Api, data: IStyle, reqParams?: Api.IReqParams): Promise<IStyle>;
-    function Delete(api: BruceApi.Api, id: number, reqParams?: Api.IReqParams): Promise<void>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        req?: Api.IReqParams;
+    }): Promise<{
+        styles: IStyle[];
+    }>;
+    function Get(params: {
+        api: BruceApi.Api;
+        styleId: number;
+        req?: Api.IReqParams;
+    }): Promise<{
+        style: IStyle;
+    }>;
+    function Update(params: {
+        api: BruceApi.Api;
+        style: IStyle;
+        req?: Api.IReqParams;
+    }): Promise<{
+        style: IStyle;
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        styleId: number;
+        req?: Api.IReqParams;
+    }): Promise<void>;
 }