@kommerz/ts-client 1.184.1 → 1.187.0

package/dist/apis/MentionsApi.js

@@ -65,7 +65,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MentionsApi = void 0;
 var runtime = require("../runtime");
-var index_1 = require("../models/index");
+var GetAllMentions200Response_1 = require("../models/GetAllMentions200Response");
+var MentionDto_1 = require("../models/MentionDto");
 /**
  *
  */
@@ -74,29 +75,42 @@ var MentionsApi = /** @class */ (function (_super) {
     function MentionsApi() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * Creates request options for deleteMention without sending the request
+     */
+    MentionsApi.prototype.deleteMentionRequestOpts = 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 deleteMention().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/mentions/v1/{id}";
+                urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'DELETE',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * delete single mention
      */
     MentionsApi.prototype.deleteMentionRaw = 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 deleteMention().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/mentions/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.deleteMentionRequestOpts(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)];
                 }
@@ -118,36 +132,49 @@ var MentionsApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for getAllMentions without sending the request
+     */
+    MentionsApi.prototype.getAllMentionsRequestOpts = 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 getAllMentions().');
+                }
+                queryParameters = {};
+                if (requestParameters['pageable'] != null) {
+                    queryParameters['pageable'] = requestParameters['pageable'];
+                }
+                if (requestParameters['filter'] != null) {
+                    queryParameters['filter'] = requestParameters['filter'];
+                }
+                headerParameters = {};
+                urlPath = "/ui/mentions/v1";
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * get all mentions
      */
     MentionsApi.prototype.getAllMentionsRaw = 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 getAllMentions().');
-                        }
-                        queryParameters = {};
-                        if (requestParameters['pageable'] != null) {
-                            queryParameters['pageable'] = requestParameters['pageable'];
-                        }
-                        if (requestParameters['filter'] != null) {
-                            queryParameters['filter'] = requestParameters['filter'];
-                        }
-                        headerParameters = {};
-                        urlPath = "/ui/mentions/v1";
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'GET',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getAllMentionsRequestOpts(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.GetAllMentions200ResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, GetAllMentions200Response_1.GetAllMentions200ResponseFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -169,31 +196,44 @@ var MentionsApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for getMention without sending the request
+     */
+    MentionsApi.prototype.getMentionRequestOpts = 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 getMention().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/mentions/v1/{id}";
+                urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * read one mention
      */
     MentionsApi.prototype.getMentionRaw = 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 getMention().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/mentions/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.getMentionRequestOpts(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.MentionDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, MentionDto_1.MentionDtoFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -215,29 +255,42 @@ var MentionsApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for markMentionRead without sending the request
+     */
+    MentionsApi.prototype.markMentionReadRequestOpts = 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 markMentionRead().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/mentions/v1/{id}/read";
+                urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'PUT',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * mark mention as read
      */
     MentionsApi.prototype.markMentionReadRaw = 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 markMentionRead().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/mentions/v1/{id}/read";
-                        urlPath = urlPath.replace("{".concat("id", "}"), encodeURIComponent(String(requestParameters['id'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'PUT',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.markMentionReadRequestOpts(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)];
                 }

package/dist/apis/NotificationTargetsApi.d.ts

@@ -9,21 +9,38 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { NotificationTargetDto, NotificationTargetOrderDto } from '../models/index';
+import { type NotificationTargetDto } from '../models/NotificationTargetDto';
+import { type NotificationTargetOrderDto } from '../models/NotificationTargetOrderDto';
 export interface GetNotificationTargetRequest {
+    /**
+     * id of entity
+     */
     id: string;
 }
 export interface UpdateNotificationTargetRequest {
+    /**
+     * id of entity
+     */
     id: string;
+    /**
+     *
+     */
     notificationTargetDto: NotificationTargetDto;
 }
 export interface UpdateNotificationTargetOrderRequest {
+    /**
+     *
+     */
     notificationTargetOrderDto: NotificationTargetOrderDto;
 }
 /**
  *
  */
 export declare class NotificationTargetsApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getAllNotificationTargets without sending the request
+     */
+    getAllNotificationTargetsRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * get all notification targets
      */
@@ -32,6 +49,10 @@ export declare class NotificationTargetsApi extends runtime.BaseAPI {
      * get all notification targets
      */
     getAllNotificationTargets(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<NotificationTargetDto>>;
+    /**
+     * Creates request options for getNotificationTarget without sending the request
+     */
+    getNotificationTargetRequestOpts(requestParameters: GetNotificationTargetRequest): Promise<runtime.RequestOpts>;
     /**
      * get one notification target
      */
@@ -40,6 +61,10 @@ export declare class NotificationTargetsApi extends runtime.BaseAPI {
      * get one notification target
      */
     getNotificationTarget(requestParameters: GetNotificationTargetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NotificationTargetDto>;
+    /**
+     * Creates request options for updateNotificationTarget without sending the request
+     */
+    updateNotificationTargetRequestOpts(requestParameters: UpdateNotificationTargetRequest): Promise<runtime.RequestOpts>;
     /**
      * Update a notification target
      */
@@ -48,6 +73,10 @@ export declare class NotificationTargetsApi extends runtime.BaseAPI {
      * Update a notification target
      */
     updateNotificationTarget(requestParameters: UpdateNotificationTargetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NotificationTargetDto>;
+    /**
+     * Creates request options for updateNotificationTargetOrder without sending the request
+     */
+    updateNotificationTargetOrderRequestOpts(requestParameters: UpdateNotificationTargetOrderRequest): Promise<runtime.RequestOpts>;
     /**
      * Update the notification target order for a notifier
      */

package/dist/apis/NotificationTargetsApi.js

@@ -65,7 +65,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationTargetsApi = void 0;
 var runtime = require("../runtime");
-var index_1 = require("../models/index");
+var NotificationTargetDto_1 = require("../models/NotificationTargetDto");
+var NotificationTargetOrderDto_1 = require("../models/NotificationTargetOrderDto");
 /**
  *
  */
@@ -74,27 +75,40 @@ var NotificationTargetsApi = /** @class */ (function (_super) {
     function NotificationTargetsApi() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * Creates request options for getAllNotificationTargets without sending the request
+     */
+    NotificationTargetsApi.prototype.getAllNotificationTargetsRequestOpts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/notifications/v1/targets";
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * get all notification targets
      */
     NotificationTargetsApi.prototype.getAllNotificationTargetsRaw = function (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:
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/notifications/v1/targets";
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'GET',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getAllNotificationTargetsRequestOpts()];
                     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 jsonValue.map(index_1.NotificationTargetDtoFromJSON); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(NotificationTargetDto_1.NotificationTargetDtoFromJSON); })];
                 }
             });
         });
@@ -116,31 +130,44 @@ var NotificationTargetsApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for getNotificationTarget without sending the request
+     */
+    NotificationTargetsApi.prototype.getNotificationTargetRequestOpts = 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 getNotificationTarget().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/notifications/v1/targets/{id}";
+                urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * get one notification target
      */
     NotificationTargetsApi.prototype.getNotificationTargetRaw = 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 getNotificationTarget().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/notifications/v1/targets/{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.getNotificationTargetRequestOpts(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.NotificationTargetDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, NotificationTargetDto_1.NotificationTargetDtoFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -162,36 +189,49 @@ var NotificationTargetsApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for updateNotificationTarget without sending the request
+     */
+    NotificationTargetsApi.prototype.updateNotificationTargetRequestOpts = 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 updateNotificationTarget().');
+                }
+                if (requestParameters['notificationTargetDto'] == null) {
+                    throw new runtime.RequiredError('notificationTargetDto', 'Required parameter "notificationTargetDto" was null or undefined when calling updateNotificationTarget().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/ui/notifications/v1/targets/{id}";
+                urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'PUT',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, NotificationTargetDto_1.NotificationTargetDtoToJSON)(requestParameters['notificationTargetDto']),
+                    }];
+            });
+        });
+    };
     /**
      * Update a notification target
      */
     NotificationTargetsApi.prototype.updateNotificationTargetRaw = 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 updateNotificationTarget().');
-                        }
-                        if (requestParameters['notificationTargetDto'] == null) {
-                            throw new runtime.RequiredError('notificationTargetDto', 'Required parameter "notificationTargetDto" was null or undefined when calling updateNotificationTarget().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/ui/notifications/v1/targets/{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.NotificationTargetDtoToJSON)(requestParameters['notificationTargetDto']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.updateNotificationTargetRequestOpts(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.NotificationTargetDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, NotificationTargetDto_1.NotificationTargetDtoFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -213,32 +253,45 @@ var NotificationTargetsApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for updateNotificationTargetOrder without sending the request
+     */
+    NotificationTargetsApi.prototype.updateNotificationTargetOrderRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['notificationTargetOrderDto'] == null) {
+                    throw new runtime.RequiredError('notificationTargetOrderDto', 'Required parameter "notificationTargetOrderDto" was null or undefined when calling updateNotificationTargetOrder().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/ui/notifications/v1/targets/order";
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'PUT',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, NotificationTargetOrderDto_1.NotificationTargetOrderDtoToJSON)(requestParameters['notificationTargetOrderDto']),
+                    }];
+            });
+        });
+    };
     /**
      * Update the notification target order for a notifier
      */
     NotificationTargetsApi.prototype.updateNotificationTargetOrderRaw = 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['notificationTargetOrderDto'] == null) {
-                            throw new runtime.RequiredError('notificationTargetOrderDto', 'Required parameter "notificationTargetOrderDto" was null or undefined when calling updateNotificationTargetOrder().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/ui/notifications/v1/targets/order";
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'PUT',
-                                headers: headerParameters,
-                                query: queryParameters,
-                                body: (0, index_1.NotificationTargetOrderDtoToJSON)(requestParameters['notificationTargetOrderDto']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.updateNotificationTargetOrderRequestOpts(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 jsonValue.map(index_1.NotificationTargetDtoFromJSON); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(NotificationTargetDto_1.NotificationTargetDtoFromJSON); })];
                 }
             });
         });

package/dist/apis/NotificationsAcksApi.d.ts

@@ -9,17 +9,27 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { AcknowledgeNotificationsDto } from '../models/index';
+import { type AcknowledgeNotificationsDto } from '../models/AcknowledgeNotificationsDto';
 export interface AcknowledgeManyNotificationsRequest {
+    /**
+     *
+     */
     acknowledgeNotificationsDto: AcknowledgeNotificationsDto;
 }
 export interface AcknowledgeNotificationRequest {
+    /**
+     *
+     */
     id: string;
 }
 /**
  *
  */
 export declare class NotificationsAcksApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for acknowledgeManyNotifications without sending the request
+     */
+    acknowledgeManyNotificationsRequestOpts(requestParameters: AcknowledgeManyNotificationsRequest): Promise<runtime.RequestOpts>;
     /**
      * acknowledges many messages
      */
@@ -28,6 +38,10 @@ export declare class NotificationsAcksApi extends runtime.BaseAPI {
      * acknowledges many messages
      */
     acknowledgeManyNotifications(requestParameters: AcknowledgeManyNotificationsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for acknowledgeNotification without sending the request
+     */
+    acknowledgeNotificationRequestOpts(requestParameters: AcknowledgeNotificationRequest): Promise<runtime.RequestOpts>;
     /**
      * mark one notification as read
      */