@cirrobio/api-client 0.2.0 → 0.2.1

package/dist/apis/GovernanceApi.js

@@ -102,7 +102,7 @@ var GovernanceApi = /** @class */ (function (_super) {
                         _a.label = 2;
                     case 2: return [4 /*yield*/, this.request({
                             path: "/governance/classifications",
-                            method: 'PUT',
+                            method: 'POST',
                             headers: headerParameters,
                             query: queryParameters,
                             body: (0, index_1.ClassificationInputToJSON)(requestParameters.classificationInput),
@@ -132,6 +132,120 @@ var GovernanceApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates a contact
+     * Create contact
+     */
+    GovernanceApi.prototype.createContactRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters.contactInput === null || requestParameters.contactInput === undefined) {
+                            throw new runtime.RequiredError('contactInput', 'Required parameter requestParameters.contactInput was null or undefined when calling createContact.');
+                        }
+                        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("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/contacts",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ContactInputToJSON)(requestParameters.contactInput),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.GovernanceContactFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Creates a contact
+     * Create contact
+     */
+    GovernanceApi.prototype.createContact = 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.createContactRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates a requirement
+     * Create requirement
+     */
+    GovernanceApi.prototype.createRequirementRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters.requirementInput === null || requestParameters.requirementInput === undefined) {
+                            throw new runtime.RequiredError('requirementInput', 'Required parameter requestParameters.requirementInput was null or undefined when calling createRequirement.');
+                        }
+                        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("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/requirements",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.RequirementInputToJSON)(requestParameters.requirementInput),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.GovernanceRequirementFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Creates a requirement
+     * Create requirement
+     */
+    GovernanceApi.prototype.createRequirement = 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.createRequirementRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Deletes the classification, and removes it from all projects.
      * Delete a classification
@@ -185,6 +299,112 @@ var GovernanceApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Deletes the contact, and removes it from all governance requirements.
+     * Delete a contact
+     */
+    GovernanceApi.prototype.deleteContactRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters.contactId === null || requestParameters.contactId === undefined) {
+                            throw new runtime.RequiredError('contactId', 'Required parameter requestParameters.contactId was null or undefined when calling deleteContact.');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/contacts/{contactId}".replace("{".concat("contactId", "}"), encodeURIComponent(String(requestParameters.contactId))),
+                            method: 'DELETE',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * Deletes the contact, and removes it from all governance requirements.
+     * Delete a contact
+     */
+    GovernanceApi.prototype.deleteContact = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.deleteContactRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Deletes the requirement, and removes it from all governance fulfillments and classifications.
+     * Delete a requirement
+     */
+    GovernanceApi.prototype.deleteRequirementRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters.requirementId === null || requestParameters.requirementId === undefined) {
+                            throw new runtime.RequiredError('requirementId', 'Required parameter requestParameters.requirementId was null or undefined when calling deleteRequirement.');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/requirements/{requirementId}".replace("{".concat("requirementId", "}"), encodeURIComponent(String(requestParameters.requirementId))),
+                            method: 'DELETE',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * Deletes the requirement, and removes it from all governance fulfillments and classifications.
+     * Delete a requirement
+     */
+    GovernanceApi.prototype.deleteRequirement = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.deleteRequirementRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Retrieve a data classification
      * Get a classification
@@ -292,6 +512,220 @@ var GovernanceApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Retrieve a governance contact
+     * Get a contact
+     */
+    GovernanceApi.prototype.getContactRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters.contactId === null || requestParameters.contactId === undefined) {
+                            throw new runtime.RequiredError('contactId', 'Required parameter requestParameters.contactId was null or undefined when calling getContact.');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/contacts/{contactId}".replace("{".concat("contactId", "}"), encodeURIComponent(String(requestParameters.contactId))),
+                            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.GovernanceContactFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Retrieve a governance contact
+     * Get a contact
+     */
+    GovernanceApi.prototype.getContact = 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.getContactRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Retrieve a list of governance contacts
+     * Get contacts
+     */
+    GovernanceApi.prototype.getContactsRaw = function (initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/contacts",
+                            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.GovernanceContactFromJSON); })];
+                }
+            });
+        });
+    };
+    /**
+     * Retrieve a list of governance contacts
+     * Get contacts
+     */
+    GovernanceApi.prototype.getContacts = function (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.getContactsRaw(initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Retrieve a governance requirement
+     * Get a requirement
+     */
+    GovernanceApi.prototype.getRequirementRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters.requirementId === null || requestParameters.requirementId === undefined) {
+                            throw new runtime.RequiredError('requirementId', 'Required parameter requestParameters.requirementId was null or undefined when calling getRequirement.');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/requirements/{requirementId}".replace("{".concat("requirementId", "}"), encodeURIComponent(String(requestParameters.requirementId))),
+                            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.GovernanceRequirementFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Retrieve a governance requirement
+     * Get a requirement
+     */
+    GovernanceApi.prototype.getRequirement = 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.getRequirementRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Retrieve a list of governance requirements
+     * Get requirements
+     */
+    GovernanceApi.prototype.getRequirementsRaw = function (initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/requirements",
+                            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.GovernanceRequirementFromJSON); })];
+                }
+            });
+        });
+    };
+    /**
+     * Retrieve a list of governance requirements
+     * Get requirements
+     */
+    GovernanceApi.prototype.getRequirements = function (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.getRequirementsRaw(initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Updates a classification
      * Update classification
@@ -352,6 +786,126 @@ var GovernanceApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Updates a contact
+     * Update contact
+     */
+    GovernanceApi.prototype.updateContactRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters.contactId === null || requestParameters.contactId === undefined) {
+                            throw new runtime.RequiredError('contactId', 'Required parameter requestParameters.contactId was null or undefined when calling updateContact.');
+                        }
+                        if (requestParameters.contactInput === null || requestParameters.contactInput === undefined) {
+                            throw new runtime.RequiredError('contactInput', 'Required parameter requestParameters.contactInput was null or undefined when calling updateContact.');
+                        }
+                        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("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/contacts/{contactId}".replace("{".concat("contactId", "}"), encodeURIComponent(String(requestParameters.contactId))),
+                            method: 'PUT',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ContactInputToJSON)(requestParameters.contactInput),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.GovernanceContactFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Updates a contact
+     * Update contact
+     */
+    GovernanceApi.prototype.updateContact = 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.updateContactRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Updates a requirement
+     * Update requirement
+     */
+    GovernanceApi.prototype.updateRequirementRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters.requirementId === null || requestParameters.requirementId === undefined) {
+                            throw new runtime.RequiredError('requirementId', 'Required parameter requestParameters.requirementId was null or undefined when calling updateRequirement.');
+                        }
+                        if (requestParameters.requirementInput === null || requestParameters.requirementInput === undefined) {
+                            throw new runtime.RequiredError('requirementInput', 'Required parameter requestParameters.requirementInput was null or undefined when calling updateRequirement.');
+                        }
+                        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("accessToken", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/governance/requirements/{requirementId}".replace("{".concat("requirementId", "}"), encodeURIComponent(String(requestParameters.requirementId))),
+                            method: 'PUT',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.RequirementInputToJSON)(requestParameters.requirementInput),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.GovernanceRequirementFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Updates a requirement
+     * Update requirement
+     */
+    GovernanceApi.prototype.updateRequirement = 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.updateRequirementRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     return GovernanceApi;
 }(runtime.BaseAPI));
 exports.GovernanceApi = GovernanceApi;

package/dist/apis/SharingApi.d.ts

@@ -10,7 +10,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { CreateResponse, Dataset, Share, ShareDetail, ShareInput } from '../models/index';
+import type { CreateResponse, PaginatedResponseDatasetListDto, Share, ShareDetail, ShareInput } from '../models/index';
 export interface CreateShareRequest {
     projectId: string;
     shareInput: ShareInput;
@@ -29,6 +29,8 @@ export interface GetShareRequest {
 export interface GetSharedDatasetsRequest {
     projectId: string;
     shareId: string;
+    limit?: number;
+    nextToken?: string;
 }
 export interface GetSharesRequest {
     projectId: string;
@@ -90,12 +92,12 @@ export declare class SharingApi extends runtime.BaseAPI {
      * Get dataset listing for a share
      * Get share datasets
      */
-    getSharedDatasetsRaw(requestParameters: GetSharedDatasetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Dataset>>>;
+    getSharedDatasetsRaw(requestParameters: GetSharedDatasetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedResponseDatasetListDto>>;
     /**
      * Get dataset listing for a share
      * Get share datasets
      */
-    getSharedDatasets(requestParameters: GetSharedDatasetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Dataset>>;
+    getSharedDatasets(requestParameters: GetSharedDatasetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedResponseDatasetListDto>;
     /**
      * Get shares for a project (both published and shared with the project)
      * Get shares

package/dist/apis/SharingApi.js

@@ -321,6 +321,12 @@ var SharingApi = /** @class */ (function (_super) {
                             throw new runtime.RequiredError('shareId', 'Required parameter requestParameters.shareId was null or undefined when calling getSharedDatasets.');
                         }
                         queryParameters = {};
+                        if (requestParameters.limit !== undefined) {
+                            queryParameters['limit'] = requestParameters.limit;
+                        }
+                        if (requestParameters.nextToken !== undefined) {
+                            queryParameters['nextToken'] = requestParameters.nextToken;
+                        }
                         headerParameters = {};
                         if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
                         token = this.configuration.accessToken;
@@ -339,7 +345,7 @@ var SharingApi = /** @class */ (function (_super) {
                         }, initOverrides)];
                     case 3:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(index_1.DatasetFromJSON); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.PaginatedResponseDatasetListDtoFromJSON)(jsonValue); })];
                 }
             });
         });

package/dist/models/AccessType.d.ts

@@ -18,7 +18,9 @@ export declare enum AccessType {
     DatasetUpload = "DATASET_UPLOAD",
     SamplesheetUpload = "SAMPLESHEET_UPLOAD",
     ReferenceUpload = "REFERENCE_UPLOAD",
-    ProjectDownload = "PROJECT_DOWNLOAD"
+    ProjectDownload = "PROJECT_DOWNLOAD",
+    GovernanceUpload = "GOVERNANCE_UPLOAD",
+    GovernanceDownload = "GOVERNANCE_DOWNLOAD"
 }
 export declare function AccessTypeFromJSON(json: any): AccessType;
 export declare function AccessTypeFromJSONTyped(json: any, ignoreDiscriminator: boolean): AccessType;

package/dist/models/AccessType.js

@@ -25,6 +25,8 @@ var AccessType;
     AccessType["SamplesheetUpload"] = "SAMPLESHEET_UPLOAD";
     AccessType["ReferenceUpload"] = "REFERENCE_UPLOAD";
     AccessType["ProjectDownload"] = "PROJECT_DOWNLOAD";
+    AccessType["GovernanceUpload"] = "GOVERNANCE_UPLOAD";
+    AccessType["GovernanceDownload"] = "GOVERNANCE_DOWNLOAD";
 })(AccessType = exports.AccessType || (exports.AccessType = {}));
 function AccessTypeFromJSON(json) {
     return AccessTypeFromJSONTyped(json, false);