bruce-models 1.9.8 → 1.9.9

package/dist/lib/entity/getters/entity-globe.js

@@ -1,212 +1,212 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityGlobe = void 0;
-/**
- * This is a helper for making entity requests based on a grid area.
- * It will return grid cells based on given view-area then will remember when stuff-
- * was fully-fetched for those cells to avoid making duplicate requests.
- */
-var EntityGlobe;
-(function (EntityGlobe) {
-    class Cell {
-        constructor() {
-            this.Fetched = false;
-            this.IsFetched = null;
-            this.FetchPageIndex = 0;
-            this.Boundaries = null;
-        }
-        GetBounds() {
-            // Entity data works in -180 to 180 range.
-            function prepareRangeForBounds(range) {
-                if (range > 180) {
-                    return range - 360;
-                }
-                return range;
-            }
-            // Add minor decimal as API crashes when giving it whole numbers.
-            const maxLon = prepareRangeForBounds(this.Boundaries.maxLongitude) + 0.00001;
-            const minLon = prepareRangeForBounds(this.Boundaries.minLongitude) - 0.00001;
-            const maxLat = prepareRangeForBounds(this.Boundaries.maxLatitude) + 0.00001;
-            const minLat = prepareRangeForBounds(this.Boundaries.minLatitude) - 0.00001;
-            return {
-                east: maxLon,
-                north: maxLat,
-                south: minLat,
-                west: minLon
-            };
-        }
-    }
-    EntityGlobe.Cell = Cell;
-    class Grid {
-        constructor() {
-            this.cells = {};
-            this.patches = [];
-        }
-        GetCellsForView(viewRect) {
-            const MAX_CELLS = 150;
-            const { south: minLat, west: minLon, north: maxLat, east: maxLon } = viewRect;
-            const cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
-            const [curMinLon, curMinLat] = [minLon, minLat].map((v) => floorValueToCellSize(cellDegreeSize, v));
-            const [width, height] = [maxLon - curMinLon, maxLat - curMinLat].map((v) => v / cellDegreeSize);
-            const ids = [];
-            const cells = [];
-            let max = [curMinLon, curMinLat];
-            const intersections = this.intersections(viewRect);
-            const addCell = (x, y) => {
-                const lon1 = x * cellDegreeSize + curMinLon;
-                const lat1 = y * cellDegreeSize + curMinLat;
-                const lon2 = lon1 + cellDegreeSize;
-                const lat2 = lat1 + cellDegreeSize;
-                const [id, cell] = getOrCreateCell(this.cells, cellDegreeSize, lon1, lon2, lat1, lat2);
-                /*
-                {
-                    const cell_bounds = { south: lat1, west: lon1, north: lat2, east: lon2 };
-                    const subcells = [];
-                    for (const id of intersections) {
-                        const c = this.cells[id].GetBounds();
-                        if (contains(c, cell_bounds)) {
-                            cell.Fetched = true;
-                            return;
-                        }
-                        if (intersects(c, cell_bounds)) {
-                            const cropped = crop(c, cell.GetBounds());
-                            subcells.push(cropped);
-                        }
-                    }
-                    let filled = 0;
-                    while (subcells.length > 0) {
-                        const c = subcells.pop();
-                        filled += area(c);
-                        for (const s of subcells) {
-                            filled -= intersection(s, c);
-                        }
-                    }
-                    if (filled + Number.EPSILON * 2 > area(cell.GetBounds())) {
-                        cell.Fetched = true;
-                        return;
-                    }
-
-                    let [x2, y2] = max;
-                    x2 = Math.max(x2, lon2);
-                    y2 = Math.max(y2, lat2);
-                    max = [x2, y2];
-                }
-                */
-                ids.push(id);
-                cells.push(cell);
-                cells[id] = cell;
-            };
-            for (let x = 0; x < width; x++) {
-                for (let y = 0; y < height; y++) {
-                    addCell(x, y);
-                    if (cells.length >= MAX_CELLS) {
-                        break;
-                    }
-                }
-            }
-            const [x2, y2] = max;
-            if (x2 != curMinLon && y2 != curMinLat) {
-                this.patches.push([{ west: curMinLon, east: x2, south: curMinLat, north: y2 }, ids]);
-            }
-            return cells;
-        }
-        intersections(withRect) {
-            return this.patches
-                .filter(([rect, _]) => intersects(rect, withRect))
-                .map(([_, ids]) => ids)
-                .reduce((all, ids) => {
-                all.push(...ids);
-                return all;
-            }, []);
-        }
-    }
-    EntityGlobe.Grid = Grid;
-})(EntityGlobe = exports.EntityGlobe || (exports.EntityGlobe = {}));
-function intersects(l, r) {
-    const { west: w, south: s, north: n, east: e } = l;
-    const { west: wr, south: sr, north: nr, east: er } = r;
-    return !(e <= wr || w >= er || n <= sr || s >= nr);
-}
-function contains(l, r) {
-    const { west: w, south: s, north: n, east: e } = l;
-    const { west: wr, south: sr, north: nr, east: er } = r;
-    return !(er < e || wr > w || nr > n || sr < s);
-}
-function crop(rect, by) {
-    let { west: w, south: s, north: n, east: e } = rect;
-    const { west: wc, south: sc, north: nc, east: ec } = by;
-    w = Math.max(w, ec);
-    e = Math.min(e, wc);
-    s = Math.max(s, nc);
-    n = Math.min(n, sc);
-    return { west: w, south: s, north: n, east: e };
-}
-function intersection(l, r) {
-    const { west: w, south: s, north: n, east: e } = l;
-    const { west: wr, south: sr, north: nr, east: er } = r;
-    const x = Math.min(e, er) - Math.max(w, wr);
-    const y = Math.min(n, nr) - Math.max(s, sr);
-    return (x > 0 && y > 0) ? x * y : 0;
-}
-function area(rect) {
-    let { west: w, south: s, north: n, east: e } = rect;
-    return Math.abs((e - w) * (n - s));
-}
-function floorValueToCellSize(size, value) {
-    return Math.floor(value / size) * size;
-}
-function getCellSizeFromHeight(height) {
-    if (height < 1000) {
-        return 0.01;
-    }
-    if (height < 5000) {
-        return 0.025;
-    }
-    else if (height < 10000) {
-        return 0.05;
-    }
-    else if (height < 30000) {
-        return 0.1;
-    }
-    else if (height < 70000) {
-        return 0.2;
-    }
-    else if (height < 100000) {
-        return 0.3;
-    }
-    else if (height < 150000) {
-        return 0.4;
-    }
-    else if (height < 200000) {
-        return 0.5;
-    }
-    else if (height < 300000) {
-        return 0.6;
-    }
-    else if (height < 500000) {
-        return 1;
-    }
-    return 1.5;
-}
-function isCellFetched(cell) {
-    if (cell.Fetched) {
-        return true;
-    }
-    return false;
-}
-function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
-    const id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
-    let cell = cells[id];
-    if (!cell) {
-        cell = cells[id] = new EntityGlobe.Cell();
-        cell.Boundaries = {
-            minLatitude: lat,
-            maxLatitude: maxLat,
-            minLongitude: lon,
-            maxLongitude: maxLon
-        };
-        cell.IsFetched = () => isCellFetched(cell);
-    }
-    return [id, cell];
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityGlobe = void 0;
+/**
+ * This is a helper for making entity requests based on a grid area.
+ * It will return grid cells based on given view-area then will remember when stuff-
+ * was fully-fetched for those cells to avoid making duplicate requests.
+ */
+var EntityGlobe;
+(function (EntityGlobe) {
+    class Cell {
+        constructor() {
+            this.Fetched = false;
+            this.IsFetched = null;
+            this.FetchPageIndex = 0;
+            this.Boundaries = null;
+        }
+        GetBounds() {
+            // Entity data works in -180 to 180 range.
+            function prepareRangeForBounds(range) {
+                if (range > 180) {
+                    return range - 360;
+                }
+                return range;
+            }
+            // Add minor decimal as API crashes when giving it whole numbers.
+            const maxLon = prepareRangeForBounds(this.Boundaries.maxLongitude) + 0.00001;
+            const minLon = prepareRangeForBounds(this.Boundaries.minLongitude) - 0.00001;
+            const maxLat = prepareRangeForBounds(this.Boundaries.maxLatitude) + 0.00001;
+            const minLat = prepareRangeForBounds(this.Boundaries.minLatitude) - 0.00001;
+            return {
+                east: maxLon,
+                north: maxLat,
+                south: minLat,
+                west: minLon
+            };
+        }
+    }
+    EntityGlobe.Cell = Cell;
+    class Grid {
+        constructor() {
+            this.cells = {};
+            this.patches = [];
+        }
+        GetCellsForView(viewRect) {
+            const MAX_CELLS = 150;
+            const { south: minLat, west: minLon, north: maxLat, east: maxLon } = viewRect;
+            const cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
+            const [curMinLon, curMinLat] = [minLon, minLat].map((v) => floorValueToCellSize(cellDegreeSize, v));
+            const [width, height] = [maxLon - curMinLon, maxLat - curMinLat].map((v) => v / cellDegreeSize);
+            const ids = [];
+            const cells = [];
+            let max = [curMinLon, curMinLat];
+            const intersections = this.intersections(viewRect);
+            const addCell = (x, y) => {
+                const lon1 = x * cellDegreeSize + curMinLon;
+                const lat1 = y * cellDegreeSize + curMinLat;
+                const lon2 = lon1 + cellDegreeSize;
+                const lat2 = lat1 + cellDegreeSize;
+                const [id, cell] = getOrCreateCell(this.cells, cellDegreeSize, lon1, lon2, lat1, lat2);
+                /*
+                {
+                    const cell_bounds = { south: lat1, west: lon1, north: lat2, east: lon2 };
+                    const subcells = [];
+                    for (const id of intersections) {
+                        const c = this.cells[id].GetBounds();
+                        if (contains(c, cell_bounds)) {
+                            cell.Fetched = true;
+                            return;
+                        }
+                        if (intersects(c, cell_bounds)) {
+                            const cropped = crop(c, cell.GetBounds());
+                            subcells.push(cropped);
+                        }
+                    }
+                    let filled = 0;
+                    while (subcells.length > 0) {
+                        const c = subcells.pop();
+                        filled += area(c);
+                        for (const s of subcells) {
+                            filled -= intersection(s, c);
+                        }
+                    }
+                    if (filled + Number.EPSILON * 2 > area(cell.GetBounds())) {
+                        cell.Fetched = true;
+                        return;
+                    }
+
+                    let [x2, y2] = max;
+                    x2 = Math.max(x2, lon2);
+                    y2 = Math.max(y2, lat2);
+                    max = [x2, y2];
+                }
+                */
+                ids.push(id);
+                cells.push(cell);
+                cells[id] = cell;
+            };
+            for (let x = 0; x < width; x++) {
+                for (let y = 0; y < height; y++) {
+                    addCell(x, y);
+                    if (cells.length >= MAX_CELLS) {
+                        break;
+                    }
+                }
+            }
+            const [x2, y2] = max;
+            if (x2 != curMinLon && y2 != curMinLat) {
+                this.patches.push([{ west: curMinLon, east: x2, south: curMinLat, north: y2 }, ids]);
+            }
+            return cells;
+        }
+        intersections(withRect) {
+            return this.patches
+                .filter(([rect, _]) => intersects(rect, withRect))
+                .map(([_, ids]) => ids)
+                .reduce((all, ids) => {
+                all.push(...ids);
+                return all;
+            }, []);
+        }
+    }
+    EntityGlobe.Grid = Grid;
+})(EntityGlobe = exports.EntityGlobe || (exports.EntityGlobe = {}));
+function intersects(l, r) {
+    const { west: w, south: s, north: n, east: e } = l;
+    const { west: wr, south: sr, north: nr, east: er } = r;
+    return !(e <= wr || w >= er || n <= sr || s >= nr);
+}
+function contains(l, r) {
+    const { west: w, south: s, north: n, east: e } = l;
+    const { west: wr, south: sr, north: nr, east: er } = r;
+    return !(er < e || wr > w || nr > n || sr < s);
+}
+function crop(rect, by) {
+    let { west: w, south: s, north: n, east: e } = rect;
+    const { west: wc, south: sc, north: nc, east: ec } = by;
+    w = Math.max(w, ec);
+    e = Math.min(e, wc);
+    s = Math.max(s, nc);
+    n = Math.min(n, sc);
+    return { west: w, south: s, north: n, east: e };
+}
+function intersection(l, r) {
+    const { west: w, south: s, north: n, east: e } = l;
+    const { west: wr, south: sr, north: nr, east: er } = r;
+    const x = Math.min(e, er) - Math.max(w, wr);
+    const y = Math.min(n, nr) - Math.max(s, sr);
+    return (x > 0 && y > 0) ? x * y : 0;
+}
+function area(rect) {
+    let { west: w, south: s, north: n, east: e } = rect;
+    return Math.abs((e - w) * (n - s));
+}
+function floorValueToCellSize(size, value) {
+    return Math.floor(value / size) * size;
+}
+function getCellSizeFromHeight(height) {
+    if (height < 1000) {
+        return 0.01;
+    }
+    if (height < 5000) {
+        return 0.025;
+    }
+    else if (height < 10000) {
+        return 0.05;
+    }
+    else if (height < 30000) {
+        return 0.1;
+    }
+    else if (height < 70000) {
+        return 0.2;
+    }
+    else if (height < 100000) {
+        return 0.3;
+    }
+    else if (height < 150000) {
+        return 0.4;
+    }
+    else if (height < 200000) {
+        return 0.5;
+    }
+    else if (height < 300000) {
+        return 0.6;
+    }
+    else if (height < 500000) {
+        return 1;
+    }
+    return 1.5;
+}
+function isCellFetched(cell) {
+    if (cell.Fetched) {
+        return true;
+    }
+    return false;
+}
+function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
+    const id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
+    let cell = cells[id];
+    if (!cell) {
+        cell = cells[id] = new EntityGlobe.Cell();
+        cell.Boundaries = {
+            minLatitude: lat,
+            maxLatitude: maxLat,
+            minLongitude: lon,
+            maxLongitude: maxLon
+        };
+        cell.IsFetched = () => isCellFetched(cell);
+    }
+    return [id, cell];
+}
 //# sourceMappingURL=entity-globe.js.map

package/dist/lib/entity/getters/view-monitor.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=view-monitor.js.map

package/dist/lib/import/import-cad.js

@@ -1,54 +1,54 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportCad = void 0;
-const api_1 = require("../api/api");
-/**
- * TODO: The analysis result is currently a mix of multiple layers of legacy.
- * We will first decide what we want it to do and then describe just the needed portions of the existing implementation.
- */
-var ImportCad;
-(function (ImportCad) {
-    function Analyze(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { api, fileAnalyze, req: reqParams } = params;
-            return api.POST("entities/PrepareIFCForImport", fileAnalyze, api_1.Api.PrepReqParams(reqParams));
-        });
-    }
-    ImportCad.Analyze = Analyze;
-    function ImportEntities(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { api, fileImport, req: reqParams } = params;
-            return api.POST("entities/importIFCWithProgress", fileImport, api_1.Api.PrepReqParams(reqParams));
-        });
-    }
-    ImportCad.ImportEntities = ImportEntities;
-    /**
-     * Parses the completed pending action result from running "ImportEntities".
-     * This will return the root entity's id if any is present.
-     * @param paResult
-     */
-    function ParseRootId(paResult) {
-        var _a;
-        try {
-            const obj = typeof paResult == "string" ? JSON.parse(paResult) : paResult;
-            if ((_a = obj === null || obj === void 0 ? void 0 : obj.result) === null || _a === void 0 ? void 0 : _a.length) {
-                return obj.result[0];
-            }
-        }
-        catch (_b) {
-            // Failed to parse json.
-        }
-        return null;
-    }
-    ImportCad.ParseRootId = ParseRootId;
-})(ImportCad = exports.ImportCad || (exports.ImportCad = {}));
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportCad = void 0;
+const api_1 = require("../api/api");
+/**
+ * TODO: The analysis result is currently a mix of multiple layers of legacy.
+ * We will first decide what we want it to do and then describe just the needed portions of the existing implementation.
+ */
+var ImportCad;
+(function (ImportCad) {
+    function Analyze(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { api, fileAnalyze, req: reqParams } = params;
+            return api.POST("entities/PrepareIFCForImport", fileAnalyze, api_1.Api.PrepReqParams(reqParams));
+        });
+    }
+    ImportCad.Analyze = Analyze;
+    function ImportEntities(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { api, fileImport, req: reqParams } = params;
+            return api.POST("entities/importIFCWithProgress", fileImport, api_1.Api.PrepReqParams(reqParams));
+        });
+    }
+    ImportCad.ImportEntities = ImportEntities;
+    /**
+     * Parses the completed pending action result from running "ImportEntities".
+     * This will return the root entity's id if any is present.
+     * @param paResult
+     */
+    function ParseRootId(paResult) {
+        var _a;
+        try {
+            const obj = typeof paResult == "string" ? JSON.parse(paResult) : paResult;
+            if ((_a = obj === null || obj === void 0 ? void 0 : obj.result) === null || _a === void 0 ? void 0 : _a.length) {
+                return obj.result[0];
+            }
+        }
+        catch (_b) {
+            // Failed to parse json.
+        }
+        return null;
+    }
+    ImportCad.ParseRootId = ParseRootId;
+})(ImportCad = exports.ImportCad || (exports.ImportCad = {}));
 //# sourceMappingURL=import-cad.js.map

package/dist/lib/import/import-csv.js

@@ -1,24 +1,24 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportCsv = void 0;
-const api_1 = require("../api/api");
-var ImportCsv;
-(function (ImportCsv) {
-    function ImportEntities(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { api, fileImport, req: reqParams } = params;
-            return api.POST("entities/importCSVWithProgress2", fileImport, api_1.Api.PrepReqParams(reqParams));
-        });
-    }
-    ImportCsv.ImportEntities = ImportEntities;
-})(ImportCsv = exports.ImportCsv || (exports.ImportCsv = {}));
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportCsv = void 0;
+const api_1 = require("../api/api");
+var ImportCsv;
+(function (ImportCsv) {
+    function ImportEntities(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { api, fileImport, req: reqParams } = params;
+            return api.POST("entities/importCSVWithProgress2", fileImport, api_1.Api.PrepReqParams(reqParams));
+        });
+    }
+    ImportCsv.ImportEntities = ImportEntities;
+})(ImportCsv = exports.ImportCsv || (exports.ImportCsv = {}));
 //# sourceMappingURL=import-csv.js.map

package/dist/lib/import/import-json.js

@@ -1,24 +1,24 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportJson = void 0;
-const api_1 = require("../api/api");
-var ImportJson;
-(function (ImportJson) {
-    function ImportEntities(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { api, fileImport, req: reqParams } = params;
-            return api.POST("entities/importJsonWithProgress", fileImport, api_1.Api.PrepReqParams(reqParams));
-        });
-    }
-    ImportJson.ImportEntities = ImportEntities;
-})(ImportJson = exports.ImportJson || (exports.ImportJson = {}));
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportJson = void 0;
+const api_1 = require("../api/api");
+var ImportJson;
+(function (ImportJson) {
+    function ImportEntities(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { api, fileImport, req: reqParams } = params;
+            return api.POST("entities/importJsonWithProgress", fileImport, api_1.Api.PrepReqParams(reqParams));
+        });
+    }
+    ImportJson.ImportEntities = ImportEntities;
+})(ImportJson = exports.ImportJson || (exports.ImportJson = {}));
 //# sourceMappingURL=import-json.js.map