bruce-models 0.8.4 → 0.8.6

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

@@ -6,7 +6,7 @@ export declare namespace Markup {
     interface IMarkup {
         divs?: Element.Div.IDiv[];
         vectors?: Element.Drawing.Drawing[];
-        cesiumObjects?: Element.Cesium.Cesium[];
+        cesiumObjects?: Element.Entity3d.Entity3d[];
         width?: number;
         height?: number;
         defaultCameraPos?: any;
@@ -19,7 +19,7 @@ export declare namespace Markup {
             }
             interface IDiv {
                 id: string;
-                type: EType;
+                type?: EType;
                 contentRows: IRow[];
                 boxShadow?: IBoxShadow;
                 borderRadius?: number;
@@ -30,8 +30,8 @@ export declare namespace Markup {
                 y: number;
                 width: number;
                 height: number;
-                screenWidth: number;
-                screenHeight: number;
+                screenWidth?: number;
+                screenHeight?: number;
             }
             interface IBoxShadow {
                 horizontal: number;
@@ -77,10 +77,12 @@ export declare namespace Markup {
             namespace ItemAction {
                 interface IActionLinkParams {
                     URL?: string;
-                    bookmarkID?: string;
                     openInNewTab?: boolean;
                     closeMarkupOnOpen?: boolean;
                 }
+                interface IActionBookmarkParams {
+                    bookmarkID?: string;
+                }
                 interface IActionInfoViewParams {
                 }
                 interface IActionRelationParams {
@@ -100,59 +102,121 @@ export declare namespace Markup {
                     ToggleRelationships = "RELATIONSHIPS",
                     Draggable = "DRAGABBLE",
                     Close = "CLOSE",
-                    OpenBookmark = "BOOKMARK",
-                    OpenMarkup = "MARKUP"
+                    OpenBookmark = "BOOKMARK"
                 }
             }
         }
         namespace Drawing {
-            type Drawing = Line.ILine | Anchor.IAnchor | FreePaint.IPaint;
+            type Drawing = Line.ILine | Line.IAnchor | FreePaint.IPaint;
             namespace Line {
                 interface ILine {
-                    headSides?: number;
+                    pathType: "LINE";
+                    path: string;
+                    transform: string;
+                    snaps: IAnchor[];
                     brushColor?: string;
-                    brushHead?: string;
                     brushSize?: number;
-                    path?: string;
-                    pathType?: string;
+                    angled?: boolean;
                     screenHeight?: number;
                     screenWidth?: number;
-                    transform?: string;
-                    angled?: boolean;
-                    snaps?: Anchor.IAnchor[];
+                    brushHead?: EAnchorHeadStyle;
+                }
+                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
+                }
+                enum EAnchorHeadStyle {
+                    None = "NONE",
+                    Circle = "CIRCLE",
+                    Arrow = "ARROW"
                 }
-            }
-            namespace Anchor {
                 interface IAnchor {
                     id?: string;
-                    side?: number;
-                    snapPosition?: number;
-                    brushHead?: string;
+                    snapPosition?: EAnchorDivSide;
+                    side?: EAnchorLineSide;
+                    brushHead?: EAnchorHeadStyle;
                     fill?: string;
+                    size?: number;
                     outlineFactor?: number;
+                    stroke?: string;
                     cartesian?: Cartes.ICartes3;
                     screenPos?: Cartes.ICartes3;
                     positionFromEntity?: boolean;
-                    stroke?: string;
-                    size?: number;
-                    head?: string;
                 }
+                const DEFAULT: ILine;
             }
             namespace FreePaint {
                 interface IPaint {
-                    brushColor: string;
-                    brushHead: string;
-                    brushSize: string;
+                    pathType: "PLAIN";
                     path: string;
-                    pathType: string;
-                    screenHeight: number;
-                    screenWidth: number;
                     transform: string;
+                    brushColor?: string;
+                    brushSize?: number;
+                    screenHeight?: number;
+                    screenWidth?: number;
                 }
+                const DEFAULT: IPaint;
             }
         }
-        namespace Cesium {
-            type Cesium = null;
+        namespace Entity3d {
+            type Entity3d = Polygon.IPolygon | Polyline.IPolyline | Circle.ICircle | Walkscore.Walkscore;
+            namespace Polygon {
+                enum EClassificationType {
+                    Both = "BOTH",
+                    Terrain = "TERRAIN"
+                }
+                interface IPolygon {
+                    id: any;
+                    positions: Cartes.ICartes3[];
+                    color?: string;
+                    outlineColor?: string;
+                    outlineWidth?: number;
+                    extrudedHeight?: number;
+                    classificationType?: EClassificationType;
+                    smoothen?: number;
+                }
+                const DEFAULT: IPolygon;
+            }
+            namespace Polyline {
+                interface IPolyline {
+                    id: string;
+                    positions: Cartes.ICartes3[];
+                    color?: string;
+                    outlineWidth?: number;
+                    smoothen?: number;
+                }
+                const DEFAULT: IPolyline;
+            }
+            namespace Circle {
+                interface ICircle {
+                    id: string;
+                    position: Cartes.ICartes3;
+                    radius: number;
+                    color?: string;
+                    outlineWidth?: number;
+                    extrudedHeight?: number;
+                    outlineExtrusion?: number;
+                }
+                const DEFAULT: ICircle;
+            }
+            namespace Walkscore {
+                interface Walkscore {
+                    id: string;
+                    cartesian: Cartes.ICartes3;
+                    details: number;
+                }
+            }
         }
     }
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 declare type Id = ProgramKey.EProgramId | string;
 /**
@@ -17,9 +18,9 @@ export declare namespace ProgramKey {
         Key: string;
         IsAccessRestricted?: boolean;
     }
-    function Get(api: BruceApi.Api, programId: Id): Promise<IKey>;
-    function GetList(api: BruceApi.Api): Promise<IKey[]>;
-    function Delete(api: BruceApi.Api, programId: Id): Promise<void>;
-    function Update(api: BruceApi.Api, data: IKey): Promise<IKey>;
+    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>;
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { Camera } from "../common/camera";
 import { UTC } from "../common/utc";
@@ -98,9 +99,9 @@ export declare namespace ProjectViewBookmark {
             cameraFrustum?: Camera.EFrustum;
         }
     }
-    function Get(api: BruceApi.Api, viewId: string, bookmarkId: string): Promise<Bookmark>;
-    function Delete(api: BruceApi.Api, viewId: string, bookmarkId: string): Promise<void>;
-    function GetList(api: BruceApi.Api, viewId: string): Promise<Bookmark[]>;
-    function Update(api: BruceApi.Api, viewId: string, data: Bookmark): Promise<Bookmark>;
-    function SetOrder(api: BruceApi.Api, viewId: string, bookmarkIds: string[]): Promise<void>;
+    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>;
 }

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

@@ -1,4 +1,5 @@
 import { BruceApi } from "../api/bruce-api";
+import { Api } from "../api/api";
 /**
  * Describes a terrain or map source that are found in project view records.
  * This is a concept we want to trash as we're moving towards storing tileset ids instead.
@@ -28,6 +29,6 @@ export declare namespace ProjectViewLegacyTile {
         RequestWaterMask?: boolean;
         RequestVertexNormals?: boolean;
     }
-    function MergeMapTemplateData(getter: BruceApi.IGetter, items: IMapSource[], addIfMissing: boolean): Promise<IMapSource[]>;
-    function MergeTerrainTemplateData(getter: BruceApi.IGetter, items: ITerrainSource[], addIfMissing: boolean): Promise<IMapSource[]>;
+    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[]>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { UTC } from "../common/utc";
 import { MenuItem } from "./menu-item";
@@ -81,8 +82,8 @@ export declare namespace ProjectView {
             Settings: ISettings;
         }
     }
-    function Get(api: BruceApi.Api, viewId: string): Promise<View>;
-    function GetList(api: BruceApi.Api): Promise<View[]>;
-    function Delete(api: BruceApi.Api, viewId: string): Promise<void>;
-    function Update(api: BruceApi.Api, data: View): Promise<View>;
+    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>;
 }

package/dist/types/server/message-broker.d.ts

@@ -1,6 +1,6 @@
 import { Api } from "../api/api";
 export declare namespace MessageBroker {
-    export enum Action {
+    export enum EAction {
         SUBSCRIBE = "subscribe",
         SUBSCRIBE_SHADOW = "subscribeShadow",
         UNSUBSCRIBE = "unsubscribe",
@@ -8,7 +8,7 @@ export declare namespace MessageBroker {
         GET_TOPIC_SUBSCRIBERS = "getTopicSubscribers"
     }
     /** Events types any component may get from server */
-    export enum Event {
+    export enum EEvent {
         SAVED = "saved",
         UPDATED = "updated",
         DELETED = "deleted",
@@ -17,49 +17,49 @@ export declare namespace MessageBroker {
         USERS_UPDATE = "usersUpdate"
     }
     interface IMessageBase {
-        action: Action;
+        action: EAction;
         topic: string;
     }
     interface IBroadcastMessage extends IMessageBase {
-        action: Action.BROADCAST;
-        event: Event;
+        action: EAction.BROADCAST;
+        event: EEvent;
         user: string;
     }
     export type SubscribeMessage = IMessageBase & {
-        action: Action.SUBSCRIBE | Action.SUBSCRIBE_SHADOW;
+        action: EAction.SUBSCRIBE | EAction.SUBSCRIBE_SHADOW;
         user: string;
     };
     export type UnsubscribeMessage = IMessageBase & {
-        action: Action.UNSUBSCRIBE;
+        action: EAction.UNSUBSCRIBE;
     };
     export type GetTopicSubscribersMessage = IMessageBase & {
-        action: Action.GET_TOPIC_SUBSCRIBERS;
+        action: EAction.GET_TOPIC_SUBSCRIBERS;
     };
     export type BroadcastMessageSaved = IBroadcastMessage & {
-        event: Event.SAVED;
+        event: EEvent.SAVED;
     };
     export type BroadcastMessageUpdated = IBroadcastMessage & {
-        event: Event.UPDATED;
+        event: EEvent.UPDATED;
     };
     export type BroadcastMessageDeleted = IBroadcastMessage & {
-        event: Event.DELETED;
+        event: EEvent.DELETED;
     };
     export type BroadcastMessageEditionStarted = IBroadcastMessage & {
-        event: Event.EDIT_STARTED;
+        event: EEvent.EDIT_STARTED;
     };
     export type BroadcastMessageEditionFinished = IBroadcastMessage & {
-        event: Event.EDIT_FINISHED;
+        event: EEvent.EDIT_FINISHED;
     };
     export type BroadcastMessageUsersUpdate = IBroadcastMessage & {
-        event: Event.USERS_UPDATE;
+        event: EEvent.USERS_UPDATE;
         data: string[];
     };
     export interface OutgoingMessageBase {
         topic: string;
-        event?: Event;
+        event?: EEvent;
     }
     export type OutgoingBroadcastMessage = IMessageBase & {
-        action: Action.BROADCAST;
+        action: EAction.BROADCAST;
         time: number;
     };
     export type IncomingMessage = BroadcastMessageSaved | BroadcastMessageUpdated | BroadcastMessageDeleted | BroadcastMessageEditionStarted | BroadcastMessageEditionFinished | BroadcastMessageUsersUpdate;
@@ -68,41 +68,60 @@ export declare namespace MessageBroker {
         time: number;
     };
     export interface IBroker {
-        subscribe: (topic: string, callback: (msg: IncomingMessage) => void) => void;
-        subscribeShadow: (topic: string, callback: (msg: IncomingMessage) => void) => void;
-        unsubscribe: (topic: string, callback: (msg: IncomingMessage) => void) => void;
-        sendBroadcastMessage: (msg: OutgoingMessageBase) => void;
-        connected: boolean;
+        Subscribe: (topic: string, callback: (msg: IncomingMessage) => void) => void;
+        SubscribeShadow: (topic: string, callback: (msg: IncomingMessage) => void) => void;
+        Unsubscribe: (topic: string, callback: (msg: IncomingMessage) => void) => void;
+        SendBroadcastMessage: (msg: OutgoingMessageBase) => void;
+        IsConnected: boolean;
     }
-    /** Communicates with a server message broker */
+    /**
+     * Communicates with a server message broker.
+     */
     export class WebSocketBroker implements IBroker {
         private uri;
-        private env;
+        private env?;
         private subscriptions;
         private ws;
         private reconnects;
         private maxReconnects;
         private user;
-        constructor(uri: string, env: Api.Env);
+        constructor(uri: string, env?: Api.Env);
         private connect;
         private formatApiUri;
-        setUser(user: string): void;
+        SetUser(user: string): void;
         private onOpen;
         private onClose;
         private onMessage;
         private onError;
         private addSubscriber;
-        /** Send message to server */
+        /**
+         * Send message to server.
+         * @param msg
+         * @returns
+         */
         private sendMessage;
-        get connected(): boolean;
-        /** Add a subscriber to a topic */
-        subscribe(topic: string, callback: (msg: IncomingMessage) => void, action?: Action): void;
-        /** Add a shadow subscriber to a topic */
-        subscribeShadow(topic: string, callback: (msg: IncomingMessage) => void): void;
-        /** Remove a subscriber from a topic */
-        unsubscribe(topic: string, callback: (msg: IncomingMessage) => void): void;
-        sendBroadcastMessage(msg: OutgoingMessageBase): void;
-        requestTopicUsers(topic: string, callback: (msg: IncomingMessage) => void): void;
+        get IsConnected(): boolean;
+        /**
+         * Add a subscriber to a topic.
+         * @param topic
+         * @param callback
+         * @param action
+         */
+        Subscribe(topic: string, callback: (msg: IncomingMessage) => void, action?: EAction): void;
+        /**
+         * Add a shadow subscriber to a topic.
+         * @param topic
+         * @param callback
+         */
+        SubscribeShadow(topic: string, callback: (msg: IncomingMessage) => void): void;
+        /**
+         * Remove a subscriber from a topic.
+         * @param topic
+         * @param callback
+         */
+        Unsubscribe(topic: string, callback: (msg: IncomingMessage) => void): void;
+        SendBroadcastMessage(msg: OutgoingMessageBase): void;
+        RequestTopicUsers(topic: string, callback: (msg: IncomingMessage) => void): void;
     }
     export {};
 }

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

@@ -32,7 +32,7 @@ export declare namespace PendingAction {
         "Message.Type": string;
         Message: string;
     }
-    function Get(api: BruceApi.Api, actionId: number): Promise<IAction>;
-    function GetRelevantList(api: BruceApi.Api, stricter?: boolean): Promise<IAction[]>;
-    function GetMessages(api: BruceApi.Api, actionId: number, order?: Api.ESortOrder, startIndex?: number, amount?: number): Promise<IMessage[]>;
+    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[]>;
 }

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

@@ -1,4 +1,4 @@
-import { GlobalApi } from "../bruce-models";
+import { Api, GlobalApi } from "../bruce-models";
 export declare namespace Task {
     interface ITask {
         account: string;
@@ -18,6 +18,6 @@ export declare namespace Task {
     enum ETaskPurpose {
         BackupRestore = "BackupRestore"
     }
-    function Get(api: GlobalApi.Api, id: number): Promise<ITask>;
-    function GetList(api: GlobalApi.Api, accountId?: string, type?: ETaskPurpose): Promise<ITask[]>;
+    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[]>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi, Calculator } from "../bruce-models";
 /**
  * Describes the "Style" concept within Bruce.
@@ -78,8 +79,8 @@ export declare namespace Style {
         Settings: Settings;
         Type: EType;
     }
-    function GetList(api: BruceApi.Api): Promise<IStyle[]>;
-    function Get(api: BruceApi.Api, id: number): Promise<IStyle>;
-    function Update(api: BruceApi.Api, data: IStyle): Promise<IStyle>;
-    function Delete(api: BruceApi.Api, id: number): Promise<void>;
+    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>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { UTC } from "../common/utc";
 import { TilesetPointcloud } from "./tileset-pointcloud";
@@ -51,18 +52,18 @@ export declare namespace Tileset {
         Weight = "weight",
         UCS = "ucs"
     }
-    function Get(api: BruceApi.Api, tilesetId: string, loadFiles?: boolean): Promise<ITileset>;
-    function GetList(api: BruceApi.Api): Promise<ITileset[]>;
-    function Delete(api: BruceApi.Api, tilesetId: string): Promise<void>;
-    function Update(api: BruceApi.Api, data: ITileset): Promise<ITileset>;
-    function UploadFile(api: BruceApi.Api, tilesetId: string, file: Blob, onProgress?: (e: ProgressEvent) => void): Promise<void>;
-    function DeleteFile(api: BruceApi.Api, tilesetId: string, file: string): Promise<void>;
-    function UploadSrcFile(api: BruceApi.Api, tilesetId: string, file: Blob, onProgress?: (e: ProgressEvent) => void): Promise<void>;
-    function DeleteSrcFile(api: BruceApi.Api, tilesetId: string, file: string): Promise<void>;
+    function Get(api: BruceApi.Api, tilesetId: string, loadFiles?: boolean, reqParams?: Api.IReqParams): Promise<ITileset>;
+    function GetList(api: BruceApi.Api, reqParams?: Api.IReqParams): Promise<ITileset[]>;
+    function Delete(api: BruceApi.Api, tilesetId: string, reqParams?: Api.IReqParams): Promise<void>;
+    function Update(api: BruceApi.Api, data: ITileset, reqParams?: Api.IReqParams): Promise<ITileset>;
+    function UploadFile(api: BruceApi.Api, tilesetId: string, file: Blob, reqParams?: Api.IUploadReqParams): Promise<void>;
+    function DeleteFile(api: BruceApi.Api, tilesetId: string, file: string, reqParams?: Api.IReqParams): Promise<void>;
+    function UploadSrcFile(api: BruceApi.Api, tilesetId: string, file: Blob, reqParams?: Api.IUploadReqParams): Promise<void>;
+    function DeleteSrcFile(api: BruceApi.Api, tilesetId: string, file: string, reqParams?: Api.IReqParams): Promise<void>;
     function GetFileUrl(api: BruceApi.Api, tilesetId: string, file: string): string;
     function GetSrcFileUrl(api: BruceApi.Api, tilesetId: string, file: string): string;
     function GetPublicFileUrl(api: BruceApi.Api, tilesetId: string, file: string): string;
-    function Generate(api: BruceApi.Api, tilesetId: string): Promise<number>;
+    function Generate(api: BruceApi.Api, tilesetId: string, reqParams?: Api.IReqParams): Promise<number>;
     namespace Publish {
         function GetCacheKey(accountId: string, tilesetId?: string): string;
         interface IPublish {
@@ -74,9 +75,9 @@ export declare namespace Tileset {
             IsPublic: boolean;
             "EnabledFor.ClientAccount.ID"?: string[];
         }
-        function Update(api: GlobalApi.Api, data: IPublish): Promise<IPublish>;
-        function Get(api: GlobalApi.Api, accountId: string, tilesetId: string): Promise<IPublish>;
-        function GetList(api: GlobalApi.Api, accountId: string): Promise<IPublish[]>;
+        function Update(api: GlobalApi.Api, data: IPublish, reqParams?: Api.IReqParams): Promise<IPublish>;
+        function Get(api: GlobalApi.Api, accountId: string, tilesetId: string, reqParams?: Api.IReqParams): Promise<IPublish>;
+        function GetList(api: GlobalApi.Api, accountId: string, reqParams?: Api.IReqParams): Promise<IPublish[]>;
     }
 }
 export {};

package/dist/types/user/session.d.ts

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { IdmApi } from "../api/idm-api";
 import { UTC } from "../common/utc";
 import { Permission } from "./permission";
@@ -26,9 +27,9 @@ export declare namespace Session {
         EnabledFeatures?: Permission.Perm[];
         UserGroups?: string[];
     }
-    function Get(api: IdmApi.Api, sessionId: string): Promise<ISession>;
-    function Login(api: IdmApi.Api, username: string, password: string, accountId?: string): Promise<ISession>;
-    function Logout(api: IdmApi.Api): Promise<void>;
+    function Get(api: IdmApi.Api, sessionId: string, reqParams?: Api.IReqParams): Promise<ISession>;
+    function Login(api: IdmApi.Api, username: string, password: string, accountId?: string, reqParams?: Api.IReqParams): Promise<ISession>;
+    function Logout(api: IdmApi.Api, reqParams?: Api.IReqParams): Promise<void>;
     function IsPermEnabled(session: ISession, accountId: string, perm: string): boolean;
     function IsSuperPermEnabled(session: ISession, perm: string): boolean;
     function IsAccountAdmin(session: ISession, accountId: string): boolean;

package/dist/types/user/user-group.d.ts

@@ -1,4 +1,4 @@
-import { IdmApi, Permission } from "../bruce-models";
+import { Api, IdmApi, Permission } from "../bruce-models";
 import { User } from "./user";
 /**
  * Describes the "User Group" concept within Bruce.
@@ -11,10 +11,10 @@ export declare namespace UserGroup {
         "ID": string;
         "Name"?: string;
     }
-    function GetByName(api: IdmApi.Api, accountId: string, name: string): Promise<IGroup>;
-    function GetUsers(api: IdmApi.Api, accountId: string, id: string): Promise<User.IUser[]>;
-    function GetListByPerm(api: IdmApi.Api, accountId: string, perm: Permission.Perm): Promise<IGroup[]>;
-    function GetList(api: IdmApi.Api, accountId: string): Promise<IGroup[]>;
-    function Delete(api: IdmApi.Api, accountId: string, id: string): Promise<void>;
-    function Update(api: IdmApi.Api, data: IGroup): Promise<IGroup>;
+    function GetByName(api: IdmApi.Api, accountId: string, name: string, reqParams?: Api.IReqParams): Promise<IGroup>;
+    function GetUsers(api: IdmApi.Api, accountId: string, id: string, reqParams?: Api.IReqParams): Promise<User.IUser[]>;
+    function GetListByPerm(api: IdmApi.Api, accountId: string, perm: Permission.Perm, reqParams?: Api.IReqParams): Promise<IGroup[]>;
+    function GetList(api: IdmApi.Api, accountId: string, reqParams?: Api.IReqParams): Promise<IGroup[]>;
+    function Delete(api: IdmApi.Api, accountId: string, id: string, reqParams?: Api.IReqParams): Promise<void>;
+    function Update(api: IdmApi.Api, data: IGroup, reqParams?: Api.IReqParams): Promise<IGroup>;
 }

package/dist/types/user/user.d.ts

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { IdmApi } from "../api/idm-api";
 import { UserGroup } from "./user-group";
 /**
@@ -33,27 +34,27 @@ export declare namespace User {
         "UserGroup.ID"?: string[];
         "UserGroups"?: UserGroup.IGroup[];
     }
-    function Get(api: IdmApi.Api, id: string, accountId?: string): Promise<IUser>;
-    function Update(api: IdmApi.Api, data: IUser): Promise<IUser>;
-    function GetUsernameAvailable(api: IdmApi.Api, username: string): Promise<boolean>;
+    function Get(api: IdmApi.Api, id: string, accountId?: string, reqParams?: Api.IReqParams): Promise<IUser>;
+    function Update(api: IdmApi.Api, data: IUser, reqParams?: Api.IReqParams): Promise<IUser>;
+    function GetUsernameAvailable(api: IdmApi.Api, username: string, reqParams?: Api.IReqParams): Promise<boolean>;
     namespace LoginUser {
         function GetListCacheKey(accountId: string): string;
-        function GetByEmail(api: IdmApi.Api, email: string, accountId?: string): Promise<IUser>;
-        function GetList(api: IdmApi.Api, accountId: string, exclusive?: boolean): Promise<IUser[]>;
+        function GetByEmail(api: IdmApi.Api, email: string, accountId?: string, reqParams?: Api.IReqParams): Promise<IUser>;
+        function GetList(api: IdmApi.Api, accountId: string, exclusive?: boolean, reqParams?: Api.IReqParams): Promise<IUser[]>;
         /**
          * Sends a signup email to the specified email address.
          * @param api
          * @param email
          * @returns
          */
-        function Signup(api: IdmApi.Api, email: string): Promise<void>;
+        function Signup(api: IdmApi.Api, email: string, reqParams?: Api.IReqParams): Promise<void>;
         /**
          * Sends a new signup email using a previous one's expired code.
          * @param api
          * @param expiredCode
          * @returns
          */
-        function SignupResend(api: IdmApi.Api, expiredCode: string): Promise<void>;
+        function SignupResend(api: IdmApi.Api, expiredCode: string, reqParams?: Api.IReqParams): Promise<void>;
         /**
          * Completes signup using user data and a signup code.
          * @param api
@@ -62,7 +63,7 @@ export declare namespace User {
          * @param accountId
          * @returns
          */
-        function SignupComplete(api: IdmApi.Api, code: string, data: IUser, accountId?: string): Promise<IUser>;
+        function SignupComplete(api: IdmApi.Api, code: string, data: IUser, accountId?: string, reqParams?: Api.IReqParams): Promise<IUser>;
         /**
          * Sends a password reset email to the specified email address.
          * @param api
@@ -70,7 +71,7 @@ export declare namespace User {
          * @param email
          * @returns user id associated with provided email.
          */
-        function ForgotPassword(api: IdmApi.Api, accountId: string, email: string): Promise<string>;
+        function ForgotPassword(api: IdmApi.Api, accountId: string, email: string, reqParams?: Api.IReqParams): Promise<string>;
         /**
          * Completes password reset using a password reset code and new password.
          * @param api
@@ -79,12 +80,12 @@ export declare namespace User {
          * @param password
          * @returns
          */
-        function ForgotPasswordComplete(api: IdmApi.Api, code: string, userId: string, password: string): Promise<IUser>;
+        function ForgotPasswordComplete(api: IdmApi.Api, code: string, userId: string, password: string, reqParams?: Api.IReqParams): Promise<IUser>;
     }
     namespace AccessToken {
         function GetListCacheKey(accountId: string): string;
-        function GetList(api: IdmApi.Api, accountId: string): Promise<IUser[]>;
-        function Delete(api: IdmApi.Api, id: string): Promise<void>;
-        function Create(api: IdmApi.Api, data: IUser): Promise<IUser>;
+        function GetList(api: IdmApi.Api, accountId: string, reqParams?: Api.IReqParams): Promise<IUser[]>;
+        function Delete(api: IdmApi.Api, id: string, reqParams?: Api.IReqParams): Promise<void>;
+        function Create(api: IdmApi.Api, data: IUser, reqParams?: Api.IReqParams): Promise<IUser>;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bruce-models",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "",
   "keywords": [],
   "main": "dist/bruce-models.umd.js",