@kommerz/ts-client 1.184.1 → 1.186.0

package/dist/apis/EditorTypeApi.d.ts

@@ -9,29 +9,59 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { EditorTypeDto, GetAllEditorTypes200Response, KommerzPageable } from '../models/index';
+import { type EditorTypeDto } from '../models/EditorTypeDto';
+import { type GetAllEditorTypes200Response } from '../models/GetAllEditorTypes200Response';
+import { type KommerzPageable } from '../models/KommerzPageable';
 export interface CreateEditorTypeRequest {
+    /**
+     *
+     */
     editorTypeDto: EditorTypeDto;
 }
 export interface DeleteEditorTypeRequest {
+    /**
+     * id of entity
+     */
     id: string;
 }
 export interface GetAllEditorTypesRequest {
+    /**
+     * Pageable query parameters
+     */
     pageable: KommerzPageable;
+    /**
+     * Filter query parameters. Operators: sim, nsim, eq, neq, leq, less, geq, gtr). Values have to be url-encoded.
+     */
     filter?: Array<string>;
 }
 export interface GetEditorTypeRequest {
+    /**
+     * id of entity
+     */
     id: string;
 }
 export interface UpdateEditorTypeRequest {
+    /**
+     * id of entity
+     */
     id: string;
+    /**
+     *
+     */
     editorTypeDto: EditorTypeDto;
+    /**
+     * whether to force update the entity
+     */
     force?: boolean;
 }
 /**
  *
  */
 export declare class EditorTypeApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for createEditorType without sending the request
+     */
+    createEditorTypeRequestOpts(requestParameters: CreateEditorTypeRequest): Promise<runtime.RequestOpts>;
     /**
      * Create a new editorType
      */
@@ -40,6 +70,10 @@ export declare class EditorTypeApi extends runtime.BaseAPI {
      * Create a new editorType
      */
     createEditorType(requestParameters: CreateEditorTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EditorTypeDto>;
+    /**
+     * Creates request options for deleteEditorType without sending the request
+     */
+    deleteEditorTypeRequestOpts(requestParameters: DeleteEditorTypeRequest): Promise<runtime.RequestOpts>;
     /**
      * delete single editorType
      */
@@ -48,6 +82,10 @@ export declare class EditorTypeApi extends runtime.BaseAPI {
      * delete single editorType
      */
     deleteEditorType(requestParameters: DeleteEditorTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for getAllEditorTypes without sending the request
+     */
+    getAllEditorTypesRequestOpts(requestParameters: GetAllEditorTypesRequest): Promise<runtime.RequestOpts>;
     /**
      * get all editorTypes
      */
@@ -56,6 +94,10 @@ export declare class EditorTypeApi extends runtime.BaseAPI {
      * get all editorTypes
      */
     getAllEditorTypes(requestParameters: GetAllEditorTypesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetAllEditorTypes200Response>;
+    /**
+     * Creates request options for getEditorType without sending the request
+     */
+    getEditorTypeRequestOpts(requestParameters: GetEditorTypeRequest): Promise<runtime.RequestOpts>;
     /**
      * read one editorType
      */
@@ -64,6 +106,10 @@ export declare class EditorTypeApi extends runtime.BaseAPI {
      * read one editorType
      */
     getEditorType(requestParameters: GetEditorTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EditorTypeDto>;
+    /**
+     * Creates request options for updateEditorType without sending the request
+     */
+    updateEditorTypeRequestOpts(requestParameters: UpdateEditorTypeRequest): Promise<runtime.RequestOpts>;
     /**
      * Update a editorType
      */

package/dist/apis/EditorTypeApi.js

@@ -65,7 +65,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EditorTypeApi = void 0;
 var runtime = require("../runtime");
-var index_1 = require("../models/index");
+var EditorTypeDto_1 = require("../models/EditorTypeDto");
+var GetAllEditorTypes200Response_1 = require("../models/GetAllEditorTypes200Response");
 /**
  *
  */
@@ -74,32 +75,45 @@ var EditorTypeApi = /** @class */ (function (_super) {
     function EditorTypeApi() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * Creates request options for createEditorType without sending the request
+     */
+    EditorTypeApi.prototype.createEditorTypeRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['editorTypeDto'] == null) {
+                    throw new runtime.RequiredError('editorTypeDto', 'Required parameter "editorTypeDto" was null or undefined when calling createEditorType().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/ui/editor-types/v1";
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, EditorTypeDto_1.EditorTypeDtoToJSON)(requestParameters['editorTypeDto']),
+                    }];
+            });
+        });
+    };
     /**
      * Create a new editorType
      */
     EditorTypeApi.prototype.createEditorTypeRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (requestParameters['editorTypeDto'] == null) {
-                            throw new runtime.RequiredError('editorTypeDto', 'Required parameter "editorTypeDto" was null or undefined when calling createEditorType().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/ui/editor-types/v1";
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'POST',
-                                headers: headerParameters,
-                                query: queryParameters,
-                                body: (0, index_1.EditorTypeDtoToJSON)(requestParameters['editorTypeDto']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.createEditorTypeRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.EditorTypeDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, EditorTypeDto_1.EditorTypeDtoFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -121,29 +135,42 @@ var EditorTypeApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for deleteEditorType without sending the request
+     */
+    EditorTypeApi.prototype.deleteEditorTypeRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['id'] == null) {
+                    throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteEditorType().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/editor-types/v1/{id}";
+                urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'DELETE',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * delete single editorType
      */
     EditorTypeApi.prototype.deleteEditorTypeRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (requestParameters['id'] == null) {
-                            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteEditorType().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/editor-types/v1/{id}";
-                        urlPath = urlPath.replace("{".concat("id", "}"), encodeURIComponent(String(requestParameters['id'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'DELETE',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.deleteEditorTypeRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
                         return [2 /*return*/, new runtime.VoidApiResponse(response)];
                 }
@@ -165,36 +192,49 @@ var EditorTypeApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for getAllEditorTypes without sending the request
+     */
+    EditorTypeApi.prototype.getAllEditorTypesRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['pageable'] == null) {
+                    throw new runtime.RequiredError('pageable', 'Required parameter "pageable" was null or undefined when calling getAllEditorTypes().');
+                }
+                queryParameters = {};
+                if (requestParameters['pageable'] != null) {
+                    queryParameters['pageable'] = requestParameters['pageable'];
+                }
+                if (requestParameters['filter'] != null) {
+                    queryParameters['filter'] = requestParameters['filter'];
+                }
+                headerParameters = {};
+                urlPath = "/ui/editor-types/v1";
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * get all editorTypes
      */
     EditorTypeApi.prototype.getAllEditorTypesRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (requestParameters['pageable'] == null) {
-                            throw new runtime.RequiredError('pageable', 'Required parameter "pageable" was null or undefined when calling getAllEditorTypes().');
-                        }
-                        queryParameters = {};
-                        if (requestParameters['pageable'] != null) {
-                            queryParameters['pageable'] = requestParameters['pageable'];
-                        }
-                        if (requestParameters['filter'] != null) {
-                            queryParameters['filter'] = requestParameters['filter'];
-                        }
-                        headerParameters = {};
-                        urlPath = "/ui/editor-types/v1";
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'GET',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getAllEditorTypesRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.GetAllEditorTypes200ResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, GetAllEditorTypes200Response_1.GetAllEditorTypes200ResponseFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -216,31 +256,44 @@ var EditorTypeApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for getEditorType without sending the request
+     */
+    EditorTypeApi.prototype.getEditorTypeRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['id'] == null) {
+                    throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getEditorType().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/editor-types/v1/{id}";
+                urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * read one editorType
      */
     EditorTypeApi.prototype.getEditorTypeRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (requestParameters['id'] == null) {
-                            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getEditorType().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/editor-types/v1/{id}";
-                        urlPath = urlPath.replace("{".concat("id", "}"), encodeURIComponent(String(requestParameters['id'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'GET',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getEditorTypeRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.EditorTypeDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, EditorTypeDto_1.EditorTypeDtoFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -262,39 +315,52 @@ var EditorTypeApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for updateEditorType without sending the request
+     */
+    EditorTypeApi.prototype.updateEditorTypeRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['id'] == null) {
+                    throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateEditorType().');
+                }
+                if (requestParameters['editorTypeDto'] == null) {
+                    throw new runtime.RequiredError('editorTypeDto', 'Required parameter "editorTypeDto" was null or undefined when calling updateEditorType().');
+                }
+                queryParameters = {};
+                if (requestParameters['force'] != null) {
+                    queryParameters['force'] = requestParameters['force'];
+                }
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/ui/editor-types/v1/{id}";
+                urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'PUT',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, EditorTypeDto_1.EditorTypeDtoToJSON)(requestParameters['editorTypeDto']),
+                    }];
+            });
+        });
+    };
     /**
      * Update a editorType
      */
     EditorTypeApi.prototype.updateEditorTypeRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (requestParameters['id'] == null) {
-                            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateEditorType().');
-                        }
-                        if (requestParameters['editorTypeDto'] == null) {
-                            throw new runtime.RequiredError('editorTypeDto', 'Required parameter "editorTypeDto" was null or undefined when calling updateEditorType().');
-                        }
-                        queryParameters = {};
-                        if (requestParameters['force'] != null) {
-                            queryParameters['force'] = requestParameters['force'];
-                        }
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/ui/editor-types/v1/{id}";
-                        urlPath = urlPath.replace("{".concat("id", "}"), encodeURIComponent(String(requestParameters['id'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'PUT',
-                                headers: headerParameters,
-                                query: queryParameters,
-                                body: (0, index_1.EditorTypeDtoToJSON)(requestParameters['editorTypeDto']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.updateEditorTypeRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.EditorTypeDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, EditorTypeDto_1.EditorTypeDtoFromJSON)(jsonValue); })];
                 }
             });
         });

package/dist/apis/FileDirectoriesApi.d.ts

@@ -9,41 +9,101 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { EntityAccessTokenDto, FileDirectoryDto, FileMovementDto, FileSelectionDto, KommerzPageable, ListDirectories200Response } from '../models/index';
+import { type EntityAccessTokenDto } from '../models/EntityAccessTokenDto';
+import { type FileConflictResolution } from '../models/FileConflictResolution';
+import { type FileDirectoryDto } from '../models/FileDirectoryDto';
+import { type FileMovementDto } from '../models/FileMovementDto';
+import { type FileSelectionDto } from '../models/FileSelectionDto';
+import { type KommerzPageable } from '../models/KommerzPageable';
+import { type ListDirectories200Response } from '../models/ListDirectories200Response';
 export interface CreateDirectoryRequest {
-    fileDirectoryDto: FileDirectoryDto;
+    /**
+     *
+     */
+    fileDirectoryDto: Omit<FileDirectoryDto, 'childIds' | 'inferredChildIds' | 'fileIds' | 'modificationDate'>;
+    /**
+     * how to proceed when the parent directory already contains a directory with the same name. REPLACE deletes the existing directory with all its content and creates the new one, MERGE returns the existing directory, so the new content is merged into it. Without it such a directory is rejected.
+     */
+    conflictResolution?: FileConflictResolution;
 }
 export interface CreateDirectoryAccessTokenRequest {
+    /**
+     *
+     */
     fileSelectionDto: FileSelectionDto;
 }
 export interface DeleteMultiplesRequest {
+    /**
+     * id of entity
+     */
     id: string;
+    /**
+     *
+     */
     fileSelectionDto: FileSelectionDto;
+    /**
+     * confirms removing the deleted entries from the file shares that contain them or anything below them. Without it such a deletion is rejected, listing the affected file shares.
+     */
+    removeFromShares?: boolean;
 }
 export interface DownloadFilesRequest {
+    /**
+     * API token
+     */
     apiToken: string;
 }
 export interface GetDirectoryRequest {
+    /**
+     * id of entity
+     */
     id: string;
+    /**
+     *
+     */
     light?: boolean;
 }
 export interface ListDirectoriesRequest {
+    /**
+     * Pageable query parameters
+     */
     pageable: KommerzPageable;
+    /**
+     * Filter query parameters. Operators: sim, nsim, eq, neq, leq, less, geq, gtr). Values have to be url-encoded.
+     */
     filter?: Array<string>;
 }
 export interface MoveMultiplesRequest {
+    /**
+     * id of entity
+     */
     id: string;
+    /**
+     *
+     */
     fileMovementDto: FileMovementDto;
 }
 export interface UpdateDirectoryRequest {
+    /**
+     * id of entity
+     */
     id: string;
-    fileDirectoryDto: FileDirectoryDto;
+    /**
+     *
+     */
+    fileDirectoryDto: Omit<FileDirectoryDto, 'childIds' | 'inferredChildIds' | 'fileIds' | 'modificationDate'>;
+    /**
+     * whether to force update the entity
+     */
     force?: boolean;
 }
 /**
  *
  */
 export declare class FileDirectoriesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for createDirectory without sending the request
+     */
+    createDirectoryRequestOpts(requestParameters: CreateDirectoryRequest): Promise<runtime.RequestOpts>;
     /**
      * Create a new directory
      */
@@ -52,6 +112,10 @@ export declare class FileDirectoriesApi extends runtime.BaseAPI {
      * Create a new directory
      */
     createDirectory(requestParameters: CreateDirectoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileDirectoryDto>;
+    /**
+     * Creates request options for createDirectoryAccessToken without sending the request
+     */
+    createDirectoryAccessTokenRequestOpts(requestParameters: CreateDirectoryAccessTokenRequest): Promise<runtime.RequestOpts>;
     /**
      * Generates a temporary access token for downloading a zip file. The token is valid for a limited time and can be used to access the zip archive directly.
      * create access token for downloading directory
@@ -62,6 +126,10 @@ export declare class FileDirectoriesApi extends runtime.BaseAPI {
      * create access token for downloading directory
      */
     createDirectoryAccessToken(requestParameters: CreateDirectoryAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EntityAccessTokenDto>;
+    /**
+     * Creates request options for deleteMultiples without sending the request
+     */
+    deleteMultiplesRequestOpts(requestParameters: DeleteMultiplesRequest): Promise<runtime.RequestOpts>;
     /**
      * delete multiple files and directories
      */
@@ -70,16 +138,24 @@ export declare class FileDirectoriesApi extends runtime.BaseAPI {
      * delete multiple files and directories
      */
     deleteMultiples(requestParameters: DeleteMultiplesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileDirectoryDto>;
+    /**
+     * Creates request options for downloadFiles without sending the request
+     */
+    downloadFilesRequestOpts(requestParameters: DownloadFilesRequest): Promise<runtime.RequestOpts>;
     /**
      * download files with API token. the api token for a file selection can be done via createDirectoryAccessToken
      * download files with API token
      */
-    downloadFilesRaw(requestParameters: DownloadFilesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>>;
+    downloadFilesRaw(requestParameters: DownloadFilesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<runtime.HttpFile>>;
     /**
      * download files with API token. the api token for a file selection can be done via createDirectoryAccessToken
      * download files with API token
      */
-    downloadFiles(requestParameters: DownloadFilesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob>;
+    downloadFiles(requestParameters: DownloadFilesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.HttpFile>;
+    /**
+     * Creates request options for getDirectory without sending the request
+     */
+    getDirectoryRequestOpts(requestParameters: GetDirectoryRequest): Promise<runtime.RequestOpts>;
     /**
      * get one directory
      */
@@ -88,6 +164,10 @@ export declare class FileDirectoriesApi extends runtime.BaseAPI {
      * get one directory
      */
     getDirectory(requestParameters: GetDirectoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileDirectoryDto>;
+    /**
+     * Creates request options for listDirectories without sending the request
+     */
+    listDirectoriesRequestOpts(requestParameters: ListDirectoriesRequest): Promise<runtime.RequestOpts>;
     /**
      * List directory
      */
@@ -96,6 +176,10 @@ export declare class FileDirectoriesApi extends runtime.BaseAPI {
      * List directory
      */
     listDirectories(requestParameters: ListDirectoriesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListDirectories200Response>;
+    /**
+     * Creates request options for moveMultiples without sending the request
+     */
+    moveMultiplesRequestOpts(requestParameters: MoveMultiplesRequest): Promise<runtime.RequestOpts>;
     /**
      * move multiple files and directories
      */
@@ -104,6 +188,10 @@ export declare class FileDirectoriesApi extends runtime.BaseAPI {
      * move multiple files and directories
      */
     moveMultiples(requestParameters: MoveMultiplesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileDirectoryDto>;
+    /**
+     * Creates request options for updateDirectory without sending the request
+     */
+    updateDirectoryRequestOpts(requestParameters: UpdateDirectoryRequest): Promise<runtime.RequestOpts>;
     /**
      * update one directory
      */