bruce-models 0.8.4 → 0.8.6

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

@@ -1,5 +1,6 @@
 export * from "./ann-document/ann-document";
 export * from "./custom-form/custom-form";
+export * from "./custom-form/custom-form-content";
 export * from "./api/abstract-api";
 export * from "./api/api";
 export * from "./api/bruce-api";
@@ -71,3 +72,4 @@ export * from "./import/import-csv";
 export * from "./import/import-json";
 export * from "./import/import-kml";
 export * from "./import/imported-file";
+export * from "./markup/markup";

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

@@ -44,6 +44,14 @@ export declare namespace Calculator {
      * @returns
      */
     function GetValue(fields: IField[], entity: Entity.IEntity, tags: any[]): string | number | Color.IColor;
+    /**
+     * Calculates the value of arbitrary field options with assumption that desired result is a color.
+     * Will return null if a color is not found.
+     * @param fields
+     * @param entity
+     * @param tags
+     */
+    function GetColor(fields: IField[], entity: Entity.IEntity, tags: any[]): 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/client-file/client-file.d.ts

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../bruce-models";
 import { UTC } from "../common/utc";
 /**
@@ -18,9 +19,9 @@ export declare namespace ClientFile {
     }
     function GetUrl(api: BruceApi.Api, fileId: string): string;
     function GetUrlWithExt(api: BruceApi.Api, file: IClientFile): string;
-    function Get(api: BruceApi.Api, fileId: string): Promise<IClientFile>;
-    function Delete(api: BruceApi.Api, fileIds: string[]): Promise<void>;
-    function Upload(api: BruceApi.Api, file: Blob, purpose?: string, onProgress?: (e: ProgressEvent) => void): Promise<IClientFile>;
+    function Get(api: BruceApi.Api, fileId: string, reqParams?: Api.IReqParams): Promise<IClientFile>;
+    function Delete(api: BruceApi.Api, fileIds: string[], reqParams?: Api.IReqParams): Promise<void>;
+    function Upload(api: BruceApi.Api, file: Blob, purpose?: string, reqParams?: Api.IUploadReqParams): Promise<IClientFile>;
     namespace Filter {
         namespace V1 {
             enum EColumn {
@@ -56,7 +57,7 @@ export declare namespace ClientFile {
                 Purpose?: string;
                 FilterRows?: IRow[];
             }
-            function GetList(api: BruceApi.Api, filter: IFilter): Promise<IClientFile[]>;
+            function GetList(api: BruceApi.Api, filter: IFilter, reqParams?: Api.IReqParams): Promise<IClientFile[]>;
         }
     }
     namespace Processor {
@@ -69,6 +70,6 @@ export declare namespace ClientFile {
             GLB = ".glb",
             SKP = ".skp"
         }
-        function ConvertFormat(api: BruceApi.Api, clientFileId: string, ext: EConvertExt | string): Promise<IResult>;
+        function ConvertFormat(api: BruceApi.Api, clientFileId: string, ext: EConvertExt | string, reqParams?: Api.IReqParams): Promise<IResult>;
     }
 }

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

@@ -5,6 +5,13 @@ declare type Key = string | number;
 export declare class CacheControl<T> {
     private data;
     Disabled: boolean;
+    private cleanerInterval;
+    private maxCleanIdle;
+    /**
+     * @param id
+     * @param data
+     * @param duration seconds to keep the data in cache. -1 for infinite.
+     */
     Set(id: Key, data: T, duration?: number): void;
     Get(id: Key): T;
     Clear(): void;
@@ -13,5 +20,7 @@ export declare class CacheControl<T> {
     RemoveByContains(text: string): void;
     GetKeys(): string[];
     GetValues(): T[];
+    private startCleaning;
+    private stopCleaning;
 }
 export {};

package/dist/types/custom-form/custom-form-content.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Describes content of a GENERIC type custom form.
+ * The alternative type is MARKUP (Markup.IMarkup).
+ */
+export declare namespace CustomFormContent {
+    enum ECellType {
+        StaticText = 0,
+        DataValue = 1,
+        StaticPicture = 2,
+        SubSection = 3,
+        ButtonMore = 4,
+        EntityPhoto = 5,
+        EmbeddedMedia = 6,
+        Chart = 7
+    }
+    enum EFlowDirection {
+        Vertically = "v",
+        Horizontally = "h"
+    }
+    interface ISection extends ICell {
+        Heading?: {
+            Icon?: string;
+            Caption?: string;
+        };
+        Direction?: EFlowDirection;
+        Entries?: CellContent.Content[];
+    }
+    interface IContent {
+        Size?: {
+            Width: number;
+            Height: number;
+        };
+        Sections?: ISection[];
+    }
+    interface ICell {
+        Type?: ECellType;
+        Style?: {
+            BackgroundColor?: string;
+            TextColor?: string;
+        };
+    }
+    namespace CellContent {
+        type Content = IStatic | IDataValue | IStaticImage | IMoreButton | IEntityPhoto | IEmbeddedMedia | IChart;
+        interface IStatic extends ICell {
+            Text?: string;
+        }
+        interface IDataValue extends ICell {
+            LabelIcon?: string;
+            LabelText?: string;
+            ValuePath?: string;
+        }
+        interface IStaticImage extends ICell {
+            ImageUrl?: string;
+        }
+        interface IMoreButton extends ICell {
+            ReferredCustomFormID?: number;
+        }
+        interface IEntityPhoto extends ICell {
+        }
+        interface IEmbeddedMedia {
+            HTML?: string;
+        }
+        interface IChart extends ICell {
+            chartData?: any;
+        }
+    }
+}

package/dist/types/custom-form/custom-form.d.ts

@@ -1,5 +1,7 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { Markup } from "../markup/markup";
+import { CustomFormContent } from "./custom-form-content";
 /**
  * Describes the "Custom Form" concept within Bruce.
  * Custom forms are dynamic dialogs that get populated with Entity data.
@@ -11,15 +13,15 @@ export declare namespace CustomForm {
         ID?: number;
         "EntityType.ID"?: string;
         Name?: string;
-        Settings?: any | Markup.IMarkup;
+        Settings?: CustomFormContent.IContent | Markup.IMarkup;
         Type?: EType;
     }
     enum EType {
         Form = "GENERIC",
         Markup = "MARKUP"
     }
-    function Get(api: BruceApi.Api, id: number): Promise<IForm>;
-    function Delete(api: BruceApi.Api, id: number): Promise<void>;
-    function GetList(api: BruceApi.Api, typeId: string): Promise<IForm[]>;
-    function Update(api: BruceApi.Api, data: IForm): Promise<IForm>;
+    function Get(api: BruceApi.Api, id: number, reqParams?: Api.IReqParams): Promise<IForm>;
+    function Delete(api: BruceApi.Api, id: number, reqParams?: Api.IReqParams): Promise<void>;
+    function GetList(api: BruceApi.Api, typeId: string, reqParams?: Api.IReqParams): Promise<IForm[]>;
+    function Update(api: BruceApi.Api, data: IForm, reqParams?: Api.IReqParams): Promise<IForm>;
 }

package/dist/types/data-lab/data-lab.d.ts

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { Entity as E } from "../entity/entity";
 export declare namespace DataLab {
@@ -15,6 +16,6 @@ export declare namespace DataLab {
         PrimaryEntityID?: string;
     }
     namespace Entity {
-        function GetList(api: BruceApi.Api, query: IQuery, key?: EReqKey, skip?: number, load?: number): Promise<E.IEntity[]>;
+        function GetList(api: BruceApi.Api, query: IQuery, key?: EReqKey, skip?: number, load?: number, reqParams?: Api.IReqParams): Promise<E.IEntity[]>;
     }
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 declare type Type = EntityAttachmentType.EType | string;
 /**
@@ -16,8 +17,8 @@ export declare namespace EntityAttachmentType {
         Photo = "photo",
         Document = "document"
     }
-    function Delete(api: BruceApi.Api, id: Type): Promise<void>;
-    function Update(api: BruceApi.Api, data: IType): Promise<IType>;
-    function GetList(api: BruceApi.Api): Promise<IType[]>;
+    function Delete(api: BruceApi.Api, id: Type, reqParams?: Api.IReqParams): Promise<void>;
+    function Update(api: BruceApi.Api, data: IType, reqParams?: Api.IReqParams): Promise<IType>;
+    function GetList(api: BruceApi.Api, reqParams?: Api.IReqParams): Promise<IType[]>;
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../bruce-models";
 import { ClientFile } from "../client-file/client-file";
 import { EntityAttachmentType } from "./entity-attachment-type";
@@ -18,11 +19,11 @@ export declare namespace EntityAttachment {
         "Entity.ID": string;
         "EntityAttachmentType.ID": Type;
     }
-    function Update(api: BruceApi.Api, data: IAttachment): Promise<IAttachment>;
-    function UpdateOrder(api: BruceApi.Api, entityId: string, typeId: Type, fileIds: string[]): Promise<void>;
-    function Delete(api: BruceApi.Api, data: IAttachment): Promise<void>;
-    function DeleteByFileIds(api: BruceApi.Api, entityId: string, typeId: Type, fileIds: string[]): Promise<void>;
-    function GetListByEntityId(api: BruceApi.Api, entityId: string): Promise<IAttachment[]>;
-    function Upload(api: BruceApi.Api, file: Blob, entityId: string, typeId: Type, onProgress?: (e: ProgressEvent) => void): Promise<IAttachment>;
+    function Update(api: BruceApi.Api, data: IAttachment, reqParams?: Api.IReqParams): Promise<IAttachment>;
+    function UpdateOrder(api: BruceApi.Api, entityId: string, typeId: Type, fileIds: string[], reqParams?: Api.IReqParams): Promise<void>;
+    function Delete(api: BruceApi.Api, data: IAttachment, reqParams?: Api.IReqParams): Promise<void>;
+    function DeleteByFileIds(api: BruceApi.Api, entityId: string, typeId: Type, fileIds: string[], reqParams?: Api.IReqParams): Promise<void>;
+    function GetListByEntityId(api: BruceApi.Api, entityId: string, reqParams?: Api.IReqParams): Promise<IAttachment[]>;
+    function Upload(api: BruceApi.Api, file: Blob, entityId: string, typeId: Type, reqParams?: Api.IUploadReqParams): Promise<IAttachment>;
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi, UTC } from "../bruce-models";
 /**
  * Describes the "Entity Comment" concept within Bruce.
@@ -16,7 +17,7 @@ export declare namespace EntityComment {
         "TargetObject.ID": string;
         "TargetObject.Type": string;
     }
-    function Update(api: BruceApi.Api, data: IComment): Promise<IComment>;
-    function Delete(api: BruceApi.Api, entityId: string, commentId: number): Promise<void>;
-    function GetListByEntityId(api: BruceApi.Api, entityId: string): Promise<IComment[]>;
+    function Update(api: BruceApi.Api, data: IComment, reqParams?: Api.IReqParams): Promise<IComment>;
+    function Delete(api: BruceApi.Api, entityId: string, commentId: number, reqParams?: Api.IReqParams): Promise<void>;
+    function GetListByEntityId(api: BruceApi.Api, entityId: string, reqParams?: Api.IReqParams): Promise<IComment[]>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { Carto } from "../common/carto";
 import { Transform } from "../common/transform";
@@ -29,9 +30,9 @@ export declare namespace EntityCoords {
         test: boolean;
         name?: boolean;
     }
-    function GetEntityCoords(api: BruceApi.Api, entityId: string): Promise<IEntityCoords>;
-    function EntityRelativeToPoint(api: BruceApi.Api, entityId: string, params: IRelToPointParams): Promise<IEntityCoords>;
-    function EntityRelativeToEpsg(api: BruceApi.Api, entityId: string, params: IRelToEpsgParams): Promise<IEntityCoords>;
-    function EntityRelativeToUcs(api: BruceApi.Api, entityId: string, params: IRelToUcsParams): Promise<IEntityCoords>;
-    function UnlinkCoords(api: BruceApi.Api, entityId: string): Promise<void>;
+    function GetEntityCoords(api: BruceApi.Api, entityId: string, reqParams?: Api.IReqParams): Promise<IEntityCoords>;
+    function EntityRelativeToPoint(api: BruceApi.Api, entityId: string, params: IRelToPointParams, reqParams?: Api.IReqParams): Promise<IEntityCoords>;
+    function EntityRelativeToEpsg(api: BruceApi.Api, entityId: string, params: IRelToEpsgParams, reqParams?: Api.IReqParams): Promise<IEntityCoords>;
+    function EntityRelativeToUcs(api: BruceApi.Api, entityId: string, params: IRelToUcsParams, reqParams?: Api.IReqParams): Promise<IEntityCoords>;
+    function UnlinkCoords(api: BruceApi.Api, entityId: string, reqParams?: Api.IReqParams): Promise<void>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../bruce-models";
 /**
  * Describes the "Entity Link" concept within Bruce.
@@ -12,7 +13,7 @@ export declare namespace EntityLink {
         "Entity.ID": string;
         URL: string;
     }
-    function Update(api: BruceApi.Api, data: ILink): Promise<ILink>;
-    function Delete(api: BruceApi.Api, entityId: string, linkId: number): Promise<void>;
-    function GetListByEntityId(api: BruceApi.Api, entityId: string): Promise<ILink[]>;
+    function Update(api: BruceApi.Api, data: ILink, reqParams?: Api.IReqParams): Promise<ILink>;
+    function Delete(api: BruceApi.Api, entityId: string, linkId: number, reqParams?: Api.IReqParams): Promise<void>;
+    function GetListByEntityId(api: BruceApi.Api, entityId: string, reqParams?: Api.IReqParams): Promise<ILink[]>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { ClientFile } from "../client-file/client-file";
 /**
@@ -23,16 +24,17 @@ export declare namespace EntityLod {
         Level: number;
     }
     function GetUrl(api: BruceApi.Api, entityId: string, categoryId: string, level: number, strict?: boolean): string;
-    function GetUrlFileId(api: BruceApi.Api, url: string): Promise<string>;
-    function GetLods(api: BruceApi.Api, params: Filter.IListParams): Promise<Filter.IListResItem[]>;
+    function GetUrlFileId(api: BruceApi.Api, url: string, reqParams?: Api.IReqParams): Promise<string>;
+    function GetLods(api: BruceApi.Api, params: Filter.IListParams, reqParams?: Api.IReqParams): Promise<Filter.IListResItem[]>;
     /**
      * Returns lods for a specified entity type.
      * @param api
      * @param typeId
      * @param group default is "DEFAULT".
+     * @param reqParams
      */
-    function GetTypeLods(api: BruceApi.Api, typeId: string, group?: string): Promise<ILod[]>;
-    function Update(api: BruceApi.Api, entityId: string, params: IEntityLodUpdate): Promise<void>;
+    function GetTypeLods(api: BruceApi.Api, typeId: string, group?: string, reqParams?: Api.IReqParams): Promise<ILod[]>;
+    function Update(api: BruceApi.Api, entityId: string, params: IEntityLodUpdate, reqParams?: Api.IReqParams): Promise<void>;
     namespace Filter {
         interface IListParamsItem {
             "entityId": string;

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 /**
  * Describes the "Entity Relationship Type" concept within Bruce.
@@ -15,8 +16,8 @@ export declare namespace EntityRelationType {
         EntityDisplaySettingID?: string;
         "Relation.EntityType.ID"?: string;
     }
-    function Get(api: BruceApi.Api, typeId: string): Promise<IType>;
-    function Delete(api: BruceApi.Api, typeId: string): Promise<void>;
-    function GetList(api: BruceApi.Api): Promise<IType[]>;
-    function Update(api: BruceApi.Api, data: IType): Promise<IType>;
+    function Get(api: BruceApi.Api, typeId: string, reqParams?: Api.IReqParams): Promise<IType>;
+    function Delete(api: BruceApi.Api, typeId: string, reqParams?: Api.IReqParams): Promise<void>;
+    function GetList(api: BruceApi.Api, reqParams?: Api.IReqParams): Promise<IType[]>;
+    function Update(api: BruceApi.Api, data: IType, reqParams?: Api.IReqParams): Promise<IType>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { Entity } from "./entity";
 /**
@@ -23,8 +24,8 @@ export declare namespace EntityRelation {
         oneWayOnly?: boolean;
         loadEntityData?: boolean;
     }
-    function Create(api: BruceApi.Api, data: IRelation): Promise<void>;
-    function Update(api: BruceApi.Api, data: IRelation): Promise<IRelation>;
-    function GetList(api: BruceApi.Api, entityId: string, params: IListParams): Promise<IRelation[]>;
-    function GetByDataEntityId(api: BruceApi.Api, entityId: string): Promise<IRelation>;
+    function Create(api: BruceApi.Api, data: IRelation, reqParams?: Api.IReqParams): Promise<void>;
+    function Update(api: BruceApi.Api, data: IRelation, reqParams?: Api.IReqParams): Promise<IRelation>;
+    function GetList(api: BruceApi.Api, entityId: string, params: IListParams, reqParams?: Api.IReqParams): Promise<IRelation[]>;
+    function GetByDataEntityId(api: BruceApi.Api, entityId: string, reqParams?: Api.IReqParams): Promise<IRelation>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi, IDictionary } from "../bruce-models";
 /**
  * Describes the "Entity Source" concept within Bruce.
@@ -11,7 +12,7 @@ export declare namespace EntitySource {
         "Source.ID": number;
         "SourceRecord.Key": string;
     }
-    function Get(api: BruceApi.Api, sourceId: number, sourceKey: string): Promise<ISource>;
-    function GetListByKeys(api: BruceApi.Api, sourceId: number, sourceKeys: string[]): Promise<ISource[]>;
-    function GetEntityIdsBySourceKeys(api: BruceApi.Api, sourceId: number, sourceKeys: string[]): Promise<IDictionary<string>>;
+    function Get(api: BruceApi.Api, sourceId: number, sourceKey: string, reqParams?: Api.IReqParams): Promise<ISource>;
+    function GetListByKeys(api: BruceApi.Api, sourceId: number, sourceKeys: string[], reqParams?: Api.IReqParams): Promise<ISource[]>;
+    function GetEntityIdsBySourceKeys(api: BruceApi.Api, sourceId: number, sourceKeys: string[], reqParams?: Api.IReqParams): Promise<IDictionary<string>>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 /**
  * Describes the "Entity Tag" concept within Bruce.
@@ -15,9 +16,9 @@ export declare namespace EntityTag {
         "EntityType.ID"?: string;
         Color?: string;
     }
-    function Get(api: BruceApi.Api, tagId: number): Promise<ITag>;
-    function GetListByIds(api: BruceApi.Api, tagIds: number[]): Promise<ITag[]>;
-    function GetList(api: BruceApi.Api, entityTypeId?: string): Promise<ITag[]>;
-    function Delete(api: BruceApi.Api, tagId: number): Promise<void>;
-    function Update(api: BruceApi.Api, data: ITag): Promise<ITag>;
+    function Get(api: BruceApi.Api, tagId: number, reqParams?: Api.IReqParams): Promise<ITag>;
+    function GetListByIds(api: BruceApi.Api, tagIds: number[], reqParams?: Api.IReqParams): Promise<ITag[]>;
+    function GetList(api: BruceApi.Api, entityTypeId?: string, reqParams?: Api.IReqParams): Promise<ITag[]>;
+    function Delete(api: BruceApi.Api, tagId: number, reqParams?: Api.IReqParams): Promise<void>;
+    function Update(api: BruceApi.Api, data: ITag, reqParams?: Api.IReqParams): Promise<ITag>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { UTC } from "../bruce-models";
 /**
@@ -47,8 +48,8 @@ export declare namespace EntityType {
         Structure = "Structure",
         Geometry = "Geometry"
     }
-    function Get(api: BruceApi.Api, typeId: string): Promise<IEntityType>;
-    function Delete(api: BruceApi.Api, typeId: string): Promise<void>;
-    function GetList(api: BruceApi.Api): Promise<IEntityType[]>;
-    function Update(api: BruceApi.Api, data: IEntityType): Promise<IEntityType>;
+    function Get(api: BruceApi.Api, typeId: string, reqParams?: Api.IReqParams): Promise<IEntityType>;
+    function Delete(api: BruceApi.Api, typeId: string, reqParams?: Api.IReqParams): Promise<void>;
+    function GetList(api: BruceApi.Api, reqParams?: Api.IReqParams): Promise<IEntityType[]>;
+    function Update(api: BruceApi.Api, data: IEntityType, reqParams?: Api.IReqParams): Promise<IEntityType>;
 }

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

@@ -29,11 +29,11 @@ export declare namespace Entity {
         position?: number[][];
         geometry?: Geometry.IGeometry;
     }
-    function Get(api: BruceApi.Api, entityId: string): Promise<IEntity>;
-    function GetListByIds(api: BruceApi.Api, entityIds: string[]): Promise<IEntity[]>;
-    function Delete(api: BruceApi.Api, entityId: string): Promise<void>;
-    function DeleteList(api: BruceApi.Api, entityIds: string[]): Promise<void>;
-    function Update(api: BruceApi.Api, data: IEntity, override: boolean): Promise<IEntity>;
+    function Get(api: BruceApi.Api, entityId: string, reqParams?: Api.IReqParams): Promise<IEntity>;
+    function GetListByIds(api: BruceApi.Api, entityIds: string[], reqParams?: Api.IReqParams): Promise<IEntity[]>;
+    function Delete(api: BruceApi.Api, entityId: string, reqParams?: Api.IReqParams): Promise<void>;
+    function DeleteList(api: BruceApi.Api, entityIds: string[], reqParams?: Api.IReqParams): Promise<void>;
+    function Update(api: BruceApi.Api, data: IEntity, override: boolean, reqParams?: Api.IReqParams): 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;
@@ -62,7 +62,7 @@ export declare namespace Entity {
                 sortOrder?: Api.ESortOrder;
                 entityTypeConditions?: AttrFilter;
             }
-            function GetList(api: BruceApi.Api, filter: IFilter): Promise<IEntity[]>;
+            function GetList(api: BruceApi.Api, filter: IFilter, reqParams?: Api.IReqParams): Promise<IEntity[]>;
         }
     }
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 /**
  * TODO: The analysis result is currently a mix of multiple layers of legacy.
@@ -28,8 +29,8 @@ export declare namespace ImportCad {
     interface IImportRes {
         PendingActionID: number;
     }
-    function Analyze(api: BruceApi.Api, params: IAnalyzeParams): Promise<IAnalyzeRes>;
-    function ImportEntities(api: BruceApi.Api, params: IImportParams): Promise<IImportRes>;
+    function Analyze(api: BruceApi.Api, params: IAnalyzeParams, reqParams?: Api.IReqParams): Promise<IAnalyzeRes>;
+    function ImportEntities(api: BruceApi.Api, params: IImportParams, reqParams?: Api.IReqParams): Promise<IImportRes>;
     /**
      * Parses the completed pending action result from running "ImportEntities".
      * This will return the root entity's id if any is present.

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 export declare namespace ImportCsv {
     interface IImportParams {
@@ -22,5 +23,5 @@ export declare namespace ImportCsv {
     interface IImportRes {
         PendingActionID: number;
     }
-    function ImportEntities(api: BruceApi.Api, params: IImportParams): Promise<IImportRes>;
+    function ImportEntities(api: BruceApi.Api, params: IImportParams, reqParams?: Api.IReqParams): Promise<IImportRes>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { EntityTag } from "../entity/entity-tag";
 export declare namespace ImportJson {
@@ -17,5 +18,5 @@ export declare namespace ImportJson {
     interface IImportRes {
         PendingActionID: number;
     }
-    function ImportEntities(api: BruceApi.Api, params: IImportParams): Promise<IImportRes>;
+    function ImportEntities(api: BruceApi.Api, params: IImportParams, reqParams?: Api.IReqParams): Promise<IImportRes>;
 }

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

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 export declare namespace ImportKml {
     interface IImportParams {
@@ -10,5 +11,5 @@ export declare namespace ImportKml {
     interface IImportRes {
         PendingActionID: number;
     }
-    function ImportEntities(api: BruceApi.Api, params: IImportParams): Promise<IImportRes>;
+    function ImportEntities(api: BruceApi.Api, params: IImportParams, reqParams?: Api.IReqParams): Promise<IImportRes>;
 }

package/dist/types/import/imported-file.d.ts

@@ -1,3 +1,4 @@
+import { Api } from "../api/api";
 import { BruceApi } from "../api/bruce-api";
 import { ClientFile } from "../client-file/client-file";
 export declare namespace ImportedFile {
@@ -20,6 +21,6 @@ export declare namespace ImportedFile {
         CAD = "CAD",
         All = "All"
     }
-    function GetList(api: BruceApi.Api, type?: EFileType, pageIndex?: number): Promise<IFile[]>;
-    function Get(api: BruceApi.Api, fileId: number): Promise<IFile>;
+    function GetList(api: BruceApi.Api, type?: EFileType, pageIndex?: number, reqParams?: Api.IReqParams): Promise<IFile[]>;
+    function Get(api: BruceApi.Api, fileId: number, reqParams?: Api.IReqParams): Promise<IFile>;
 }