bruce-models 1.3.7 → 1.3.8

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

@@ -8,8 +8,29 @@ export declare namespace EntityLodCategory {
         Key: string;
         Name: string;
     }
-    function GetList(api: BruceApi.Api, reqParams?: Api.IReqParams): Promise<ICategory[]>;
-    function Get(api: BruceApi.Api, id: string, reqParams?: Api.IReqParams): Promise<ICategory>;
-    function Delete(api: BruceApi.Api, id: string, reqParams?: Api.IReqParams): Promise<void>;
-    function Update(api: BruceApi.Api, data: ICategory, reqParams?: Api.IReqParams): Promise<ICategory>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        req?: Api.IReqParams;
+    }): Promise<{
+        categories: ICategory[];
+    }>;
+    function Get(params: {
+        api: BruceApi.Api;
+        categoryId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        category: ICategory;
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        categoryId: string;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Update(params: {
+        api: BruceApi.Api;
+        category: ICategory;
+        req?: Api.IReqParams;
+    }): Promise<{
+        category: ICategory;
+    }>;
 }

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

@@ -24,20 +24,60 @@ export declare namespace EntityLod {
         "LODCategory.Key": string;
         Level: number;
     }
-    function GetUrl(api: BruceApi.Api, entityId: string, categoryId: string, level: number, strict?: boolean): string;
-    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[]>;
-    function GetEntityLods(api: BruceApi.Api, entityId: string, reqParams?: Api.IReqParams): Promise<ILod[]>;
+    function GetUrl(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        categoryId: string;
+        level: number;
+        strict?: boolean;
+    }): {
+        url: string;
+    };
+    function GetUrlFileId(params: {
+        api: BruceApi.Api;
+        url: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        clientFileId: string;
+    }>;
+    function GetLods(params: {
+        api: BruceApi.Api;
+        filter: Filter.IListParams;
+        req?: Api.IReqParams;
+    }): Promise<{
+        lods: Filter.IListResItem[];
+    }>;
+    function GetEntityLods(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        lods: ILod[];
+    }>;
     /**
      * Returns lods for a specified entity type.
-     * @param api
-     * @param typeId
-     * @param group default is "DEFAULT".
-     * @param reqParams
+     * @param params
      */
-    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>;
-    function Delete(api: BruceApi.Api, entityId: string, lodCategoryId: string, level: number, reqParams?: Api.IReqParams): Promise<void>;
+    function GetTypeLods(params: {
+        api: BruceApi.Api;
+        entityTypeId: string;
+        group?: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        lods: ILod[];
+    }>;
+    function Update(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        req?: Api.IReqParams;
+    } & IEntityLodUpdate): Promise<void>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        lodCategoryId: string;
+        level: number;
+        req?: Api.IReqParams;
+    }): Promise<void>;
     namespace Filter {
         interface IListParamsItem {
             "entityId": string;

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

@@ -16,8 +16,29 @@ export declare namespace EntityRelationType {
         EntityDisplaySettingID?: string;
         "Relation.EntityType.ID"?: string;
     }
-    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>;
+    function Get(params: {
+        api: BruceApi.Api;
+        relationTypeId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        relationType: IType;
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        relationTypeId: string;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        req?: Api.IReqParams;
+    }): Promise<{
+        relationTypes: IType[];
+    }>;
+    function Update(params: {
+        api: BruceApi.Api;
+        relationType: IType;
+        req?: Api.IReqParams;
+    }): Promise<{
+        relationType: IType;
+    }>;
 }

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

@@ -20,12 +20,35 @@ export declare namespace EntityRelation {
         "Data.Entity.ID"?: string;
     }
     interface IListParams {
-        typeId?: string;
+        relationTypeId?: string;
         oneWayOnly?: boolean;
         loadEntityData?: boolean;
     }
-    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>;
+    function Create(params: {
+        api: BruceApi.Api;
+        relation: IRelation;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Update(params: {
+        api: BruceApi.Api;
+        relation: IRelation;
+        req?: Api.IReqParams;
+    }): Promise<{
+        relation: IRelation;
+    }>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        filter: IListParams;
+        req?: Api.IReqParams;
+    }): Promise<{
+        relations: IRelation[];
+    }>;
+    function GetByDataEntityId(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        relation: IRelation;
+    }>;
 }

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

@@ -12,7 +12,28 @@ export declare namespace EntitySource {
         "Source.ID": number;
         "SourceRecord.Key": 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>>;
+    function Get(params: {
+        api: BruceApi.Api;
+        sourceId: number;
+        sourceKey: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        source: ISource;
+    }>;
+    function GetListByKeys(params: {
+        api: BruceApi.Api;
+        sourceId: number;
+        sourceKeys: string[];
+        req?: Api.IReqParams;
+    }): Promise<{
+        sources: ISource[];
+    }>;
+    function GetEntityIdsBySourceKeys(params: {
+        api: BruceApi.Api;
+        sourceId: number;
+        sourceKeys: string[];
+        req?: Api.IReqParams;
+    }): Promise<{
+        idMapping: IDictionary<string>;
+    }>;
 }

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

@@ -16,9 +16,37 @@ export declare namespace EntityTag {
         "EntityType.ID"?: string;
         Color?: string;
     }
-    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>;
+    function Get(params: {
+        api: BruceApi.Api;
+        tagId: number;
+        req?: Api.IReqParams;
+    }): Promise<{
+        tag: ITag;
+    }>;
+    function GetListByIds(params: {
+        api: BruceApi.Api;
+        tagIds: number[];
+        req?: Api.IReqParams;
+    }): Promise<{
+        tags: ITag[];
+    }>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        entityTypeId?: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        tags: ITag[];
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        tagId: number;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Update(params: {
+        api: BruceApi.Api;
+        tag: ITag;
+        req?: Api.IReqParams;
+    }): Promise<{
+        tag: ITag;
+    }>;
 }

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

@@ -35,8 +35,29 @@ export declare namespace EntityType {
         "Parent.EntityType.ID"?: string;
         VisualSettings?: EntityTypeVisualSettings.ISettings;
     }
-    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>;
+    function Get(params: {
+        api: BruceApi.Api;
+        entityTypeId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entityType: IEntityType;
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        entityTypeId: string;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entityTypes: IEntityType[];
+    }>;
+    function Update(params: {
+        api: BruceApi.Api;
+        entityType: IEntityType;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entityType: IEntityType;
+    }>;
 }

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

@@ -29,41 +29,84 @@ export declare namespace Entity {
         position?: number[][];
         geometry?: Geometry.IGeometry;
     }
-    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;
-    function GetValue(data: IEntity, path: string[]): any;
+    function Get(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entity: IEntity;
+    }>;
+    function GetListByIds(params: {
+        api: BruceApi.Api;
+        entityIds: string[];
+        req?: Api.IReqParams;
+    }): Promise<{
+        entities: IEntity[];
+    }>;
+    function Delete(params: {
+        api: BruceApi.Api;
+        entityId: string;
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function DeleteList(params: {
+        api: BruceApi.Api;
+        entityIds: string[];
+        req?: Api.IReqParams;
+    }): Promise<void>;
+    function Update(params: {
+        api: BruceApi.Api;
+        entity: IEntity;
+        override: boolean;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entity: IEntity;
+    }>;
+    function RemoveTag(params: {
+        entity: IEntity;
+        tagId: number;
+    }): void;
+    function AddTag(params: {
+        entity: IEntity;
+        tagId: number;
+    }): void;
+    function SetValue(params: {
+        entity: IEntity;
+        path: string[];
+        value: any;
+    }): void;
+    function GetValue(params: {
+        entity: IEntity;
+        path: string[];
+    }): any;
     /**
      * Calculates an entity's name based on attribute priority set in the type.
-     * @param entity
-     * @param type
-     * @param defaultToId
+     * @param params
      * If true, will return the entity ID if no name can be calculated.
      * Otherwise it returns null.
      * @returns
      */
-    function CalculateName(entity: IEntity, type: EntityType.IEntityType, defaultToId?: boolean): string;
-    namespace Filter {
-        namespace V1 {
-            type AttrFilter = IDictionary<any>;
-            interface IFilter {
-                orderBy?: any;
-                entityTypeId?: string;
-                layerIds?: number[];
-                bounds?: Bounds.IReqBounds;
-                pageSize?: number;
-                pageIndex?: number;
-                lodCategoryId?: string;
-                sortOrder?: Api.ESortOrder;
-                entityTypeConditions?: AttrFilter;
-            }
-            function GetList(api: BruceApi.Api, filter: IFilter, reqParams?: Api.IReqParams): Promise<IEntity[]>;
-        }
+    function CalculateName(params: {
+        entity: IEntity;
+        type: EntityType.IEntityType;
+        defaultToId?: boolean;
+    }): string;
+    interface IFilter {
+        orderBy?: any;
+        entityTypeId?: string;
+        layerIds?: number[];
+        bounds?: Bounds.IReqBounds;
+        pageSize?: number;
+        pageIndex?: number;
+        lodCategoryId?: string;
+        sortOrder?: Api.ESortOrder;
+        entityTypeConditions?: IDictionary<any>;
     }
+    function GetList(params: {
+        api: BruceApi.Api;
+        filter: IFilter;
+        req?: Api.IReqParams;
+    }): Promise<{
+        entities: IEntity[];
+    }>;
 }
 export {};

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

@@ -29,8 +29,16 @@ export declare namespace ImportCad {
     interface IImportRes {
         PendingActionID: number;
     }
-    function Analyze(api: BruceApi.Api, params: IAnalyzeParams, reqParams?: Api.IReqParams): Promise<IAnalyzeRes>;
-    function ImportEntities(api: BruceApi.Api, params: IImportParams, reqParams?: Api.IReqParams): Promise<IImportRes>;
+    function Analyze(params: {
+        api: BruceApi.Api;
+        fileAnalyze: IAnalyzeParams;
+        req?: Api.IReqParams;
+    }): Promise<IAnalyzeRes>;
+    function ImportEntities(params: {
+        api: BruceApi.Api;
+        fileImport: IImportParams;
+        req?: 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

@@ -23,5 +23,9 @@ export declare namespace ImportCsv {
     interface IImportRes {
         PendingActionID: number;
     }
-    function ImportEntities(api: BruceApi.Api, params: IImportParams, reqParams?: Api.IReqParams): Promise<IImportRes>;
+    function ImportEntities(params: {
+        api: BruceApi.Api;
+        fileImport: IImportParams;
+        req?: Api.IReqParams;
+    }): Promise<IImportRes>;
 }

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

@@ -18,5 +18,9 @@ export declare namespace ImportJson {
     interface IImportRes {
         PendingActionID: number;
     }
-    function ImportEntities(api: BruceApi.Api, params: IImportParams, reqParams?: Api.IReqParams): Promise<IImportRes>;
+    function ImportEntities(params: {
+        api: BruceApi.Api;
+        fileImport: IImportParams;
+        req?: Api.IReqParams;
+    }): Promise<IImportRes>;
 }

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

@@ -11,5 +11,9 @@ export declare namespace ImportKml {
     interface IImportRes {
         PendingActionID: number;
     }
-    function ImportEntities(api: BruceApi.Api, params: IImportParams, reqParams?: Api.IReqParams): Promise<IImportRes>;
+    function ImportEntities(params: {
+        api: BruceApi.Api;
+        fileImport: IImportParams;
+        req?: Api.IReqParams;
+    }): Promise<IImportRes>;
 }

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

@@ -21,6 +21,19 @@ export declare namespace ImportedFile {
         CAD = "CAD",
         All = "All"
     }
-    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>;
+    function GetList(params: {
+        api: BruceApi.Api;
+        fileType?: EFileType;
+        pageIndex?: number;
+        req?: Api.IReqParams;
+    }): Promise<{
+        importedFiles: IFile[];
+    }>;
+    function Get(params: {
+        api: BruceApi.Api;
+        importedFileId: number;
+        req?: Api.IReqParams;
+    }): Promise<{
+        importedFile: IFile;
+    }>;
 }