@orchestraworks/cli 0.7.0 → 0.9.0

package/node_modules/@orchestraworks/client/dist/esm/apis/FilesApi.js

@@ -21,10 +21,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime';
+import { ArtifactVersionDocumentFromJSON, } from '../models/ArtifactVersionDocument';
+import { CommentFromJSON, } from '../models/Comment';
 import { CompleteFileUploadRequestToJSON, } from '../models/CompleteFileUploadRequest';
+import { CopyFileRequestToJSON, } from '../models/CopyFileRequest';
+import { CreateCommentRequestToJSON, } from '../models/CreateCommentRequest';
 import { CreateFileRequestToJSON, } from '../models/CreateFileRequest';
+import { CreateReplyRequestToJSON, } from '../models/CreateReplyRequest';
+import { FileMatchFromJSON, } from '../models/FileMatch';
 import { FileWithUploadFromJSON, } from '../models/FileWithUpload';
+import { PageCommentSummaryFromJSON, } from '../models/PageCommentSummary';
 import { PageFileFromJSON, } from '../models/PageFile';
+import { PageFileVersionFromJSON, } from '../models/PageFileVersion';
+import { ReplyFromJSON, } from '../models/Reply';
+import { UpdateCommentRequestToJSON, } from '../models/UpdateCommentRequest';
+import { UpdateFileRequestToJSON, } from '../models/UpdateFileRequest';
+import { UpdateReplyRequestToJSON, } from '../models/UpdateReplyRequest';
+import { WriteFileDataRequestToJSON, } from '../models/WriteFileDataRequest';
 /**
  *
  */
@@ -86,6 +99,63 @@ export class FilesApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for copyFile without sending the request
+     */
+    copyFileRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling copyFile().');
+            }
+            if (requestParameters['copyFileRequest'] == null) {
+                throw new runtime.RequiredError('copyFileRequest', 'Required parameter "copyFileRequest" was null or undefined when calling copyFile().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/copy`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: CopyFileRequestToJSON(requestParameters['copyFileRequest']),
+            };
+        });
+    }
+    /**
+     */
+    copyFileRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.copyFileRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            if (this.isJsonMime(response.headers.get('content-type'))) {
+                return new runtime.JSONApiResponse(response);
+            }
+            else {
+                return new runtime.TextApiResponse(response);
+            }
+        });
+    }
+    /**
+     */
+    copyFile(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.copyFileRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for createFile without sending the request
      */
@@ -134,6 +204,114 @@ export class FilesApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for createFileComment without sending the request
+     */
+    createFileCommentRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling createFileComment().');
+            }
+            if (requestParameters['createCommentRequest'] == null) {
+                throw new runtime.RequiredError('createCommentRequest', 'Required parameter "createCommentRequest" was null or undefined when calling createFileComment().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/comments`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: CreateCommentRequestToJSON(requestParameters['createCommentRequest']),
+            };
+        });
+    }
+    /**
+     */
+    createFileCommentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.createFileCommentRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    createFileComment(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createFileCommentRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for createFileReply without sending the request
+     */
+    createFileReplyRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling createFileReply().');
+            }
+            if (requestParameters['commentId'] == null) {
+                throw new runtime.RequiredError('commentId', 'Required parameter "commentId" was null or undefined when calling createFileReply().');
+            }
+            if (requestParameters['createReplyRequest'] == null) {
+                throw new runtime.RequiredError('createReplyRequest', 'Required parameter "createReplyRequest" was null or undefined when calling createFileReply().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/comments/{commentId}/replies`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            urlPath = urlPath.replace('{commentId}', encodeURIComponent(String(requestParameters['commentId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: CreateReplyRequestToJSON(requestParameters['createReplyRequest']),
+            };
+        });
+    }
+    /**
+     */
+    createFileReplyRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.createFileReplyRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ReplyFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    createFileReply(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createFileReplyRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for deleteFile without sending the request
      */
@@ -180,6 +358,110 @@ export class FilesApi extends runtime.BaseAPI {
             yield this.deleteFileRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Creates request options for deleteFileComment without sending the request
+     */
+    deleteFileCommentRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteFileComment().');
+            }
+            if (requestParameters['commentId'] == null) {
+                throw new runtime.RequiredError('commentId', 'Required parameter "commentId" was null or undefined when calling deleteFileComment().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/comments/{commentId}`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            urlPath = urlPath.replace('{commentId}', encodeURIComponent(String(requestParameters['commentId'])));
+            return {
+                path: urlPath,
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    deleteFileCommentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.deleteFileCommentRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     */
+    deleteFileComment(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deleteFileCommentRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Creates request options for deleteFileReply without sending the request
+     */
+    deleteFileReplyRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteFileReply().');
+            }
+            if (requestParameters['commentId'] == null) {
+                throw new runtime.RequiredError('commentId', 'Required parameter "commentId" was null or undefined when calling deleteFileReply().');
+            }
+            if (requestParameters['replyId'] == null) {
+                throw new runtime.RequiredError('replyId', 'Required parameter "replyId" was null or undefined when calling deleteFileReply().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/comments/{commentId}/replies/{replyId}`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            urlPath = urlPath.replace('{commentId}', encodeURIComponent(String(requestParameters['commentId'])));
+            urlPath = urlPath.replace('{replyId}', encodeURIComponent(String(requestParameters['replyId'])));
+            return {
+                path: urlPath,
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    deleteFileReplyRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.deleteFileReplyRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     */
+    deleteFileReply(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deleteFileReplyRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Creates request options for getFile without sending the request
      */
@@ -233,12 +515,15 @@ export class FilesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Creates request options for getFileContent without sending the request
+     * Creates request options for getFileComment without sending the request
      */
-    getFileContentRequestOpts(requestParameters) {
+    getFileCommentRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getFileContent().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getFileComment().');
+            }
+            if (requestParameters['commentId'] == null) {
+                throw new runtime.RequiredError('commentId', 'Required parameter "commentId" was null or undefined when calling getFileComment().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -252,8 +537,9 @@ export class FilesApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/files/{id}/content`;
+            let urlPath = `/files/{id}/comments/{commentId}`;
             urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            urlPath = urlPath.replace('{commentId}', encodeURIComponent(String(requestParameters['commentId'])));
             return {
                 path: urlPath,
                 method: 'GET',
@@ -264,35 +550,30 @@ export class FilesApi extends runtime.BaseAPI {
     }
     /**
      */
-    getFileContentRaw(requestParameters, initOverrides) {
+    getFileCommentRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.getFileContentRequestOpts(requestParameters);
+            const requestOptions = yield this.getFileCommentRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
         });
     }
     /**
      */
-    getFileContent(requestParameters, initOverrides) {
+    getFileComment(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.getFileContentRaw(requestParameters, initOverrides);
+            const response = yield this.getFileCommentRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**
-     * Creates request options for listFiles without sending the request
+     * Creates request options for getFileContent without sending the request
      */
-    listFilesRequestOpts(requestParameters) {
+    getFileContentRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            const queryParameters = {};
-            if (requestParameters['page'] != null) {
-                queryParameters['page'] = requestParameters['page'];
-            }
-            if (requestParameters['limit'] != null) {
-                queryParameters['limit'] = requestParameters['limit'];
-            }
-            if (requestParameters['teamId'] != null) {
-                queryParameters['teamId'] = requestParameters['teamId'];
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getFileContent().');
             }
+            const queryParameters = {};
             const headerParameters = {};
             if (requestParameters['xOrganizationId'] != null) {
                 headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
@@ -304,7 +585,8 @@ export class FilesApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/files`;
+            let urlPath = `/files/{id}/content`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
             return {
                 path: urlPath,
                 method: 'GET',
@@ -315,19 +597,695 @@ export class FilesApi extends runtime.BaseAPI {
     }
     /**
      */
-    listFilesRaw(requestParameters, initOverrides) {
+    getFileContentRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.listFilesRequestOpts(requestParameters);
+            const requestOptions = yield this.getFileContentRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => PageFileFromJSON(jsonValue));
+            if (this.isJsonMime(response.headers.get('content-type'))) {
+                return new runtime.JSONApiResponse(response);
+            }
+            else {
+                return new runtime.TextApiResponse(response);
+            }
         });
     }
     /**
      */
-    listFiles() {
-        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
-            const response = yield this.listFilesRaw(requestParameters, initOverrides);
+    getFileContent(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getFileContentRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
-}
+    /**
+     * Creates request options for getFileData without sending the request
+     */
+    getFileDataRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getFileData().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/data`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    getFileDataRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getFileDataRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ArtifactVersionDocumentFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    getFileData(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getFileDataRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getFileVersionContent without sending the request
+     */
+    getFileVersionContentRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getFileVersionContent().');
+            }
+            if (requestParameters['versionNumber'] == null) {
+                throw new runtime.RequiredError('versionNumber', 'Required parameter "versionNumber" was null or undefined when calling getFileVersionContent().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/versions/{versionNumber}/content`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            urlPath = urlPath.replace('{versionNumber}', encodeURIComponent(String(requestParameters['versionNumber'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    getFileVersionContentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getFileVersionContentRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            if (this.isJsonMime(response.headers.get('content-type'))) {
+                return new runtime.JSONApiResponse(response);
+            }
+            else {
+                return new runtime.TextApiResponse(response);
+            }
+        });
+    }
+    /**
+     */
+    getFileVersionContent(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getFileVersionContentRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for listFileComments without sending the request
+     */
+    listFileCommentsRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling listFileComments().');
+            }
+            const queryParameters = {};
+            if (requestParameters['page'] != null) {
+                queryParameters['page'] = requestParameters['page'];
+            }
+            if (requestParameters['limit'] != null) {
+                queryParameters['limit'] = requestParameters['limit'];
+            }
+            if (requestParameters['versionNumber'] != null) {
+                queryParameters['versionNumber'] = requestParameters['versionNumber'];
+            }
+            if (requestParameters['status'] != null) {
+                queryParameters['status'] = requestParameters['status'];
+            }
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/comments`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    listFileCommentsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.listFileCommentsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PageCommentSummaryFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    listFileComments(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.listFileCommentsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for listFileMatches without sending the request
+     */
+    listFileMatchesRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['q'] == null) {
+                throw new runtime.RequiredError('q', 'Required parameter "q" was null or undefined when calling listFileMatches().');
+            }
+            const queryParameters = {};
+            if (requestParameters['q'] != null) {
+                queryParameters['q'] = requestParameters['q'];
+            }
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
+            }
+            if (requestParameters['pathPrefix'] != null) {
+                queryParameters['pathPrefix'] = requestParameters['pathPrefix'];
+            }
+            if (requestParameters['limit'] != null) {
+                queryParameters['limit'] = requestParameters['limit'];
+            }
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/matches`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    listFileMatchesRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.listFileMatchesRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(FileMatchFromJSON));
+        });
+    }
+    /**
+     */
+    listFileMatches(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.listFileMatchesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for listFileVersions without sending the request
+     */
+    listFileVersionsRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling listFileVersions().');
+            }
+            const queryParameters = {};
+            if (requestParameters['page'] != null) {
+                queryParameters['page'] = requestParameters['page'];
+            }
+            if (requestParameters['limit'] != null) {
+                queryParameters['limit'] = requestParameters['limit'];
+            }
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/versions`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    listFileVersionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.listFileVersionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PageFileVersionFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    listFileVersions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.listFileVersionsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for listFiles without sending the request
+     */
+    listFilesRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            if (requestParameters['page'] != null) {
+                queryParameters['page'] = requestParameters['page'];
+            }
+            if (requestParameters['limit'] != null) {
+                queryParameters['limit'] = requestParameters['limit'];
+            }
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
+            }
+            if (requestParameters['path'] != null) {
+                queryParameters['path'] = requestParameters['path'];
+            }
+            if (requestParameters['pathPrefix'] != null) {
+                queryParameters['pathPrefix'] = requestParameters['pathPrefix'];
+            }
+            if (requestParameters['parent'] != null) {
+                queryParameters['parent'] = requestParameters['parent'];
+            }
+            if (requestParameters['folder'] != null) {
+                queryParameters['folder'] = requestParameters['folder'];
+            }
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    listFilesRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.listFilesRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PageFileFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    listFiles() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            const response = yield this.listFilesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for reopenFileComment without sending the request
+     */
+    reopenFileCommentRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling reopenFileComment().');
+            }
+            if (requestParameters['commentId'] == null) {
+                throw new runtime.RequiredError('commentId', 'Required parameter "commentId" was null or undefined when calling reopenFileComment().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/comments/{commentId}/reopen`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            urlPath = urlPath.replace('{commentId}', encodeURIComponent(String(requestParameters['commentId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    reopenFileCommentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.reopenFileCommentRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    reopenFileComment(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.reopenFileCommentRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for resolveFileComment without sending the request
+     */
+    resolveFileCommentRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling resolveFileComment().');
+            }
+            if (requestParameters['commentId'] == null) {
+                throw new runtime.RequiredError('commentId', 'Required parameter "commentId" was null or undefined when calling resolveFileComment().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/comments/{commentId}/resolve`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            urlPath = urlPath.replace('{commentId}', encodeURIComponent(String(requestParameters['commentId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     */
+    resolveFileCommentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.resolveFileCommentRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    resolveFileComment(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.resolveFileCommentRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for updateFile without sending the request
+     */
+    updateFileRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateFile().');
+            }
+            if (requestParameters['updateFileRequest'] == null) {
+                throw new runtime.RequiredError('updateFileRequest', 'Required parameter "updateFileRequest" was null or undefined when calling updateFile().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'PATCH',
+                headers: headerParameters,
+                query: queryParameters,
+                body: UpdateFileRequestToJSON(requestParameters['updateFileRequest']),
+            };
+        });
+    }
+    /**
+     */
+    updateFileRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.updateFileRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            if (this.isJsonMime(response.headers.get('content-type'))) {
+                return new runtime.JSONApiResponse(response);
+            }
+            else {
+                return new runtime.TextApiResponse(response);
+            }
+        });
+    }
+    /**
+     */
+    updateFile(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.updateFileRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for updateFileComment without sending the request
+     */
+    updateFileCommentRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateFileComment().');
+            }
+            if (requestParameters['commentId'] == null) {
+                throw new runtime.RequiredError('commentId', 'Required parameter "commentId" was null or undefined when calling updateFileComment().');
+            }
+            if (requestParameters['updateCommentRequest'] == null) {
+                throw new runtime.RequiredError('updateCommentRequest', 'Required parameter "updateCommentRequest" was null or undefined when calling updateFileComment().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/comments/{commentId}`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            urlPath = urlPath.replace('{commentId}', encodeURIComponent(String(requestParameters['commentId'])));
+            return {
+                path: urlPath,
+                method: 'PATCH',
+                headers: headerParameters,
+                query: queryParameters,
+                body: UpdateCommentRequestToJSON(requestParameters['updateCommentRequest']),
+            };
+        });
+    }
+    /**
+     */
+    updateFileCommentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.updateFileCommentRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CommentFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    updateFileComment(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.updateFileCommentRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for updateFileReply without sending the request
+     */
+    updateFileReplyRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateFileReply().');
+            }
+            if (requestParameters['commentId'] == null) {
+                throw new runtime.RequiredError('commentId', 'Required parameter "commentId" was null or undefined when calling updateFileReply().');
+            }
+            if (requestParameters['replyId'] == null) {
+                throw new runtime.RequiredError('replyId', 'Required parameter "replyId" was null or undefined when calling updateFileReply().');
+            }
+            if (requestParameters['updateReplyRequest'] == null) {
+                throw new runtime.RequiredError('updateReplyRequest', 'Required parameter "updateReplyRequest" was null or undefined when calling updateFileReply().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/comments/{commentId}/replies/{replyId}`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            urlPath = urlPath.replace('{commentId}', encodeURIComponent(String(requestParameters['commentId'])));
+            urlPath = urlPath.replace('{replyId}', encodeURIComponent(String(requestParameters['replyId'])));
+            return {
+                path: urlPath,
+                method: 'PATCH',
+                headers: headerParameters,
+                query: queryParameters,
+                body: UpdateReplyRequestToJSON(requestParameters['updateReplyRequest']),
+            };
+        });
+    }
+    /**
+     */
+    updateFileReplyRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.updateFileReplyRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ReplyFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    updateFileReply(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.updateFileReplyRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for writeFileData without sending the request
+     */
+    writeFileDataRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling writeFileData().');
+            }
+            if (requestParameters['writeFileDataRequest'] == null) {
+                throw new runtime.RequiredError('writeFileDataRequest', 'Required parameter "writeFileDataRequest" was null or undefined when calling writeFileData().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['xOrganizationId'] != null) {
+                headerParameters['X-Organization-Id'] = String(requestParameters['xOrganizationId']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/files/{id}/data`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'PATCH',
+                headers: headerParameters,
+                query: queryParameters,
+                body: WriteFileDataRequestToJSON(requestParameters['writeFileDataRequest']),
+            };
+        });
+    }
+    /**
+     */
+    writeFileDataRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.writeFileDataRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ArtifactVersionDocumentFromJSON(jsonValue));
+        });
+    }
+    /**
+     */
+    writeFileData(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.writeFileDataRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+}
+/**
+ * @export
+ */
+export const ListFileCommentsStatusEnum = {
+    Open: 'OPEN',
+    Resolved: 'RESOLVED'
+};