keplar-api 0.0.29 → 0.0.31

package/dist/apis/DefaultApi.js

@@ -136,6 +136,67 @@ var DefaultApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Trigger analysis/report generation for a notebook
+     */
+    DefaultApi.prototype.analyzeNotebookRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['notebookId'] == null) {
+                            throw new runtime.RequiredError('notebookId', 'Required parameter "notebookId" was null or undefined when calling analyzeNotebook().');
+                        }
+                        if (requestParameters['analyzeNotebookRequest'] == null) {
+                            throw new runtime.RequiredError('analyzeNotebookRequest', 'Required parameter "analyzeNotebookRequest" was null or undefined when calling analyzeNotebook().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/{notebookId}/analyze";
+                        urlPath = urlPath.replace("{".concat("notebookId", "}"), encodeURIComponent(String(requestParameters['notebookId'])));
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.AnalyzeNotebookRequestToJSON)(requestParameters['analyzeNotebookRequest']),
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.AnalyzeNotebook200ResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Trigger analysis/report generation for a notebook
+     */
+    DefaultApi.prototype.analyzeNotebook = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.analyzeNotebookRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      */
     DefaultApi.prototype.apiAuthGoogleGetRaw = function (initOverrides) {
@@ -3056,6 +3117,63 @@ var DefaultApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Create a new notebook
+     */
+    DefaultApi.prototype.createNotebookRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['createNotebookRequest'] == null) {
+                            throw new runtime.RequiredError('createNotebookRequest', 'Required parameter "createNotebookRequest" was null or undefined when calling createNotebook().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/";
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.CreateNotebookRequestToJSON)(requestParameters['createNotebookRequest']),
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.NotebookFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Create a new notebook
+     */
+    DefaultApi.prototype.createNotebook = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createNotebookRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Create a preview invite for this project based on audienceSettings
      */
@@ -3472,6 +3590,122 @@ var DefaultApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Delete a notebook
+     */
+    DefaultApi.prototype.deleteNotebookRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['notebookId'] == null) {
+                            throw new runtime.RequiredError('notebookId', 'Required parameter "notebookId" was null or undefined when calling deleteNotebook().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/{notebookId}";
+                        urlPath = urlPath.replace("{".concat("notebookId", "}"), encodeURIComponent(String(requestParameters['notebookId'])));
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'DELETE',
+                                headers: headerParameters,
+                                query: queryParameters,
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.DeleteArtifact200ResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Delete a notebook
+     */
+    DefaultApi.prototype.deleteNotebook = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.deleteNotebookRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Delete all artifacts in a version group
+     */
+    DefaultApi.prototype.deleteNotebookArtifactVersionGroupRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['notebookId'] == null) {
+                            throw new runtime.RequiredError('notebookId', 'Required parameter "notebookId" was null or undefined when calling deleteNotebookArtifactVersionGroup().');
+                        }
+                        if (requestParameters['versionGroupId'] == null) {
+                            throw new runtime.RequiredError('versionGroupId', 'Required parameter "versionGroupId" was null or undefined when calling deleteNotebookArtifactVersionGroup().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/{notebookId}/artifacts/{versionGroupId}";
+                        urlPath = urlPath.replace("{".concat("notebookId", "}"), encodeURIComponent(String(requestParameters['notebookId'])));
+                        urlPath = urlPath.replace("{".concat("versionGroupId", "}"), encodeURIComponent(String(requestParameters['versionGroupId'])));
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'DELETE',
+                                headers: headerParameters,
+                                query: queryParameters,
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.DeleteNotebookArtifactVersionGroup200ResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Delete all artifacts in a version group
+     */
+    DefaultApi.prototype.deleteNotebookArtifactVersionGroup = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.deleteNotebookArtifactVersionGroupRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Delete a share entity
      */
@@ -4216,6 +4450,230 @@ var DefaultApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Get a notebook by ID
+     */
+    DefaultApi.prototype.getNotebookRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['notebookId'] == null) {
+                            throw new runtime.RequiredError('notebookId', 'Required parameter "notebookId" was null or undefined when calling getNotebook().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/{notebookId}";
+                        urlPath = urlPath.replace("{".concat("notebookId", "}"), encodeURIComponent(String(requestParameters['notebookId'])));
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'GET',
+                                headers: headerParameters,
+                                query: queryParameters,
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.NotebookFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Get a notebook by ID
+     */
+    DefaultApi.prototype.getNotebook = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getNotebookRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get all artifacts generated from a notebook
+     */
+    DefaultApi.prototype.getNotebookArtifactsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['notebookId'] == null) {
+                            throw new runtime.RequiredError('notebookId', 'Required parameter "notebookId" was null or undefined when calling getNotebookArtifacts().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/{notebookId}/artifacts";
+                        urlPath = urlPath.replace("{".concat("notebookId", "}"), encodeURIComponent(String(requestParameters['notebookId'])));
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'GET',
+                                headers: headerParameters,
+                                query: queryParameters,
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(index_1.ArtifactFromJSON); })];
+                }
+            });
+        });
+    };
+    /**
+     * Get all artifacts generated from a notebook
+     */
+    DefaultApi.prototype.getNotebookArtifacts = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getNotebookArtifactsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get all projects associated with a notebook
+     */
+    DefaultApi.prototype.getNotebookProjectsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['notebookId'] == null) {
+                            throw new runtime.RequiredError('notebookId', 'Required parameter "notebookId" was null or undefined when calling getNotebookProjects().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/{notebookId}/projects";
+                        urlPath = urlPath.replace("{".concat("notebookId", "}"), encodeURIComponent(String(requestParameters['notebookId'])));
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'GET',
+                                headers: headerParameters,
+                                query: queryParameters,
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(index_1.ProjectSummaryWithAnalyticsFromJSON); })];
+                }
+            });
+        });
+    };
+    /**
+     * Get all projects associated with a notebook
+     */
+    DefaultApi.prototype.getNotebookProjects = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getNotebookProjectsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get all notebooks accessible to user
+     */
+    DefaultApi.prototype.getNotebooksRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParameters = {};
+                        if (requestParameters['workspaceId'] != null) {
+                            queryParameters['workspaceId'] = requestParameters['workspaceId'];
+                        }
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/";
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'GET',
+                                headers: headerParameters,
+                                query: queryParameters,
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(index_1.NotebookFromJSON); })];
+                }
+            });
+        });
+    };
+    /**
+     * Get all notebooks accessible to user
+     */
+    DefaultApi.prototype.getNotebooks = function () {
+        return __awaiter(this, arguments, void 0, function (requestParameters, initOverrides) {
+            var response;
+            if (requestParameters === void 0) { requestParameters = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getNotebooksRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Get project
      */
@@ -6537,6 +6995,125 @@ var DefaultApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Update a notebook
+     */
+    DefaultApi.prototype.updateNotebookRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['notebookId'] == null) {
+                            throw new runtime.RequiredError('notebookId', 'Required parameter "notebookId" was null or undefined when calling updateNotebook().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/{notebookId}";
+                        urlPath = urlPath.replace("{".concat("notebookId", "}"), encodeURIComponent(String(requestParameters['notebookId'])));
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'PUT',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.UpdateNotebookRequestToJSON)(requestParameters['updateNotebookRequest']),
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.NotebookFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Update a notebook
+     */
+    DefaultApi.prototype.updateNotebook = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.updateNotebookRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Add or remove project sources from a notebook
+     */
+    DefaultApi.prototype.updateNotebookSourcesRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, urlPath, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['notebookId'] == null) {
+                            throw new runtime.RequiredError('notebookId', 'Required parameter "notebookId" was null or undefined when calling updateNotebookSources().');
+                        }
+                        if (requestParameters['updateNotebookSourcesRequest'] == null) {
+                            throw new runtime.RequiredError('updateNotebookSourcesRequest', 'Required parameter "updateNotebookSourcesRequest" was null or undefined when calling updateNotebookSources().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearerAuth", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        urlPath = "/api/notebooks/{notebookId}/sources";
+                        urlPath = urlPath.replace("{".concat("notebookId", "}"), encodeURIComponent(String(requestParameters['notebookId'])));
+                        return [4 /*yield*/, this.request({
+                                path: urlPath,
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.UpdateNotebookSourcesRequestToJSON)(requestParameters['updateNotebookSourcesRequest']),
+                            }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.NotebookFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Add or remove project sources from a notebook
+     */
+    DefaultApi.prototype.updateNotebookSources = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.updateNotebookSourcesRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Update a share entity
      */

package/dist/models/AnalyzeNotebook200Response.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Fastify Template API
+ * API documentation using Swagger
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { Notebook } from './Notebook';
+/**
+ *
+ * @export
+ * @interface AnalyzeNotebook200Response
+ */
+export interface AnalyzeNotebook200Response {
+    /**
+     *
+     * @type {Notebook}
+     * @memberof AnalyzeNotebook200Response
+     */
+    notebook: Notebook;
+    /**
+     *
+     * @type {string}
+     * @memberof AnalyzeNotebook200Response
+     */
+    artifactId?: string;
+    /**
+     *
+     * @type {string}
+     * @memberof AnalyzeNotebook200Response
+     */
+    message: string;
+}
+/**
+ * Check if a given object implements the AnalyzeNotebook200Response interface.
+ */
+export declare function instanceOfAnalyzeNotebook200Response(value: object): value is AnalyzeNotebook200Response;
+export declare function AnalyzeNotebook200ResponseFromJSON(json: any): AnalyzeNotebook200Response;
+export declare function AnalyzeNotebook200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): AnalyzeNotebook200Response;
+export declare function AnalyzeNotebook200ResponseToJSON(json: any): AnalyzeNotebook200Response;
+export declare function AnalyzeNotebook200ResponseToJSONTyped(value?: AnalyzeNotebook200Response | null, ignoreDiscriminator?: boolean): any;