bruce-models 7.1.32 → 7.1.34

package/dist/bruce-models.umd.js

@@ -9025,6 +9025,88 @@
         EntityTableView.Delete = Delete;
     })(exports.EntityTableView || (exports.EntityTableView = {}));
 
+    (function (DashboardView) {
+        /**
+         * Returns a record matching the given viewId.
+         * @param params
+         */
+        function Get(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { viewId, api, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                req = exports.Api.PrepReqParams(req);
+                const res = yield api.GET(`ui.dashboardview/${viewId}`, req);
+                return {
+                    view: res
+                };
+            });
+        }
+        DashboardView.Get = Get;
+        /**
+         * Returns the list of all available Dashboard Views.
+         * @param params
+         */
+        function GetList(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!params) {
+                    params = {};
+                }
+                let { api, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                req = exports.Api.PrepReqParams(req);
+                const res = yield api.GET("ui.dashboardviews", req);
+                let items = res === null || res === void 0 ? void 0 : res.Items;
+                if (!items) {
+                    items = [];
+                }
+                return {
+                    views: items
+                };
+            });
+        }
+        DashboardView.GetList = GetList;
+        /**
+         * Creates or updates a Dashboard View record.
+         */
+        function Update(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { view, api, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                req = exports.Api.PrepReqParams(req);
+                let viewId = view.ID;
+                if (!viewId) {
+                    viewId = 0;
+                }
+                const res = yield api.POST(`ui.dashboardview/${viewId}`, view, req);
+                return {
+                    view: res
+                };
+            });
+        }
+        DashboardView.Update = Update;
+        /**
+         * Deletes a Dashboard View record.
+         * @param params
+         */
+        function Delete(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { viewId, api, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                req = exports.Api.PrepReqParams(req);
+                return yield api.DELETE(`ui.dashboardview/${viewId}`, req);
+            });
+        }
+        DashboardView.Delete = Delete;
+    })(exports.DashboardView || (exports.DashboardView = {}));
+
     (function (Style) {
         /**
          * Types of styles available.
@@ -15566,6 +15648,108 @@
         DataLab.Run = Run;
     })(exports.DataLab || (exports.DataLab = {}));
 
+    (function (DataTransform) {
+        /**
+         * Supported Logic Flow diagram item types.
+         */
+        let ELogicFlowDiagramItemType;
+        (function (ELogicFlowDiagramItemType) {
+            ELogicFlowDiagramItemType["InputValue"] = "input-value";
+            ELogicFlowDiagramItemType["OutputValue"] = "output-value";
+            ELogicFlowDiagramItemType["If"] = "if";
+            ELogicFlowDiagramItemType["Formula"] = "formula";
+            ELogicFlowDiagramItemType["Switch"] = "switch";
+        })(ELogicFlowDiagramItemType = DataTransform.ELogicFlowDiagramItemType || (DataTransform.ELogicFlowDiagramItemType = {}));
+        /**
+         * Supported Logic Flow connection point types.
+         */
+        let ELogicFlowConnectionPointType;
+        (function (ELogicFlowConnectionPointType) {
+            ELogicFlowConnectionPointType["Input"] = "input";
+            ELogicFlowConnectionPointType["Output"] = "output";
+        })(ELogicFlowConnectionPointType = DataTransform.ELogicFlowConnectionPointType || (DataTransform.ELogicFlowConnectionPointType = {}));
+        /**
+         * Supported Logic Flow connection end roles.
+         */
+        let ELogicFlowConnectionEndRole;
+        (function (ELogicFlowConnectionEndRole) {
+            ELogicFlowConnectionEndRole["From"] = "from";
+            ELogicFlowConnectionEndRole["To"] = "to";
+        })(ELogicFlowConnectionEndRole = DataTransform.ELogicFlowConnectionEndRole || (DataTransform.ELogicFlowConnectionEndRole = {}));
+        /**
+         * Requests a suggested Logic Flow diagram from a natural-language prompt.
+         * Route: POST v1/entityType/{entityType_id}/DataTransform/SuggestLogicFlowDiagram
+         */
+        function SuggestLogicFlowDiagramByPrompt(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, entityTypeId, prompt, model, maxNodes, dataTransformId, dataTransform, dataTransformContext, sourceDataSchema, destinationDataSchema, inputAttributes, outputAttributes, req: reqParams } = params;
+                if (!entityTypeId) {
+                    throw ("Entity Type ID is required.");
+                }
+                prompt = prompt === null || prompt === void 0 ? void 0 : prompt.trim();
+                if (!prompt) {
+                    throw ("Prompt is required.");
+                }
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                const body = {
+                    Prompt: prompt
+                };
+                if (model) {
+                    body.Model = model;
+                }
+                if (typeof maxNodes == "number" && !isNaN(maxNodes)) {
+                    body.MaxNodes = maxNodes;
+                }
+                if (typeof dataTransformId == "number" && dataTransformId > 0) {
+                    body["DataTransform.ID"] = dataTransformId;
+                }
+                if (dataTransform != null) {
+                    body.DataTransform = dataTransform;
+                }
+                if (dataTransformContext != null) {
+                    body.DataTransformContext = dataTransformContext;
+                }
+                if (sourceDataSchema != null) {
+                    body.SourceDataSchema = sourceDataSchema;
+                }
+                if (destinationDataSchema != null) {
+                    body.DestinationDataSchema = destinationDataSchema;
+                }
+                if (inputAttributes === null || inputAttributes === void 0 ? void 0 : inputAttributes.length) {
+                    body.InputAttributes = inputAttributes;
+                }
+                if (outputAttributes === null || outputAttributes === void 0 ? void 0 : outputAttributes.length) {
+                    body.OutputAttributes = outputAttributes;
+                }
+                const route = `v1/entityType/${exports.Api.Encode(entityTypeId)}/DataTransform/SuggestLogicFlowDiagram`;
+                const response = yield api.POST(route, body, exports.Api.PrepReqParams(reqParams));
+                let diagram = (response === null || response === void 0 ? void 0 : response.diagram)
+                    || (response === null || response === void 0 ? void 0 : response.Diagram)
+                    || (response === null || response === void 0 ? void 0 : response.LogicFlowDiagram)
+                    || (response === null || response === void 0 ? void 0 : response.result)
+                    || (response === null || response === void 0 ? void 0 : response.Result)
+                    || response;
+                if (typeof diagram == "string") {
+                    try {
+                        diagram = JSON.parse(diagram);
+                    }
+                    catch (e) {
+                        // Keep original shape if parse fails.
+                    }
+                }
+                if (!diagram || typeof diagram != "object") {
+                    throw ("No Logic Flow Diagram was returned by the suggestion API.");
+                }
+                return {
+                    diagram: diagram
+                };
+            });
+        }
+        DataTransform.SuggestLogicFlowDiagramByPrompt = SuggestLogicFlowDiagramByPrompt;
+    })(exports.DataTransform || (exports.DataTransform = {}));
+
     (function (DataLabGroup) {
         /**
          * Returns the list of all saved query groups.
@@ -17698,7 +17882,7 @@
     })(exports.ChangeSet || (exports.ChangeSet = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.1.32";
+    const VERSION = "7.1.34";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;