@kommerz/ts-client 1.184.0 → 1.186.0

package/dist/apis/IdentifiersApi.d.ts

@@ -9,31 +9,61 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { IdentifierDto, IdentifierType, PatternDto } from '../models/index';
+import { type IdentifierDto } from '../models/IdentifierDto';
+import { type IdentifierType } from '../models/IdentifierType';
+import { type PatternDto } from '../models/PatternDto';
 export interface GetAndSetIdentifierRequest {
+    /**
+     * Identifier Type
+     */
     identifierType: IdentifierType;
 }
 export interface GetIdentifierRequest {
+    /**
+     * Identifier Type
+     */
     identifierType: IdentifierType;
 }
 export interface GetIdentifierPatternRequest {
+    /**
+     * Identifier Type
+     */
     identifierType: IdentifierType;
 }
 export interface ResetIdentifierPatternRequest {
+    /**
+     * Identifier Type
+     */
     identifierType: IdentifierType;
 }
 export interface SetIdentifierPatternRequest {
+    /**
+     * Identifier Type
+     */
     identifierType: IdentifierType;
+    /**
+     *
+     */
     patternDto: PatternDto;
 }
 export interface TestIdentifierPatternRequest {
+    /**
+     * Identifier Type
+     */
     identifierType: IdentifierType;
+    /**
+     *
+     */
     patternDto: PatternDto;
 }
 /**
  *
  */
 export declare class IdentifiersApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getAndSetIdentifier without sending the request
+     */
+    getAndSetIdentifierRequestOpts(requestParameters: GetAndSetIdentifierRequest): Promise<runtime.RequestOpts>;
     /**
      * get and persist next identifier
      */
@@ -42,6 +72,10 @@ export declare class IdentifiersApi extends runtime.BaseAPI {
      * get and persist next identifier
      */
     getAndSetIdentifier(requestParameters: GetAndSetIdentifierRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<IdentifierDto>;
+    /**
+     * Creates request options for getIdentifier without sending the request
+     */
+    getIdentifierRequestOpts(requestParameters: GetIdentifierRequest): Promise<runtime.RequestOpts>;
     /**
      * get next identifier
      */
@@ -50,6 +84,10 @@ export declare class IdentifiersApi extends runtime.BaseAPI {
      * get next identifier
      */
     getIdentifier(requestParameters: GetIdentifierRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<IdentifierDto>;
+    /**
+     * Creates request options for getIdentifierPattern without sending the request
+     */
+    getIdentifierPatternRequestOpts(requestParameters: GetIdentifierPatternRequest): Promise<runtime.RequestOpts>;
     /**
      * returns the saved identifier pattern
      */
@@ -58,6 +96,10 @@ export declare class IdentifiersApi extends runtime.BaseAPI {
      * returns the saved identifier pattern
      */
     getIdentifierPattern(requestParameters: GetIdentifierPatternRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PatternDto>;
+    /**
+     * Creates request options for resetIdentifierPattern without sending the request
+     */
+    resetIdentifierPatternRequestOpts(requestParameters: ResetIdentifierPatternRequest): Promise<runtime.RequestOpts>;
     /**
      * resets identifier counters
      */
@@ -66,6 +108,10 @@ export declare class IdentifiersApi extends runtime.BaseAPI {
      * resets identifier counters
      */
     resetIdentifierPattern(requestParameters: ResetIdentifierPatternRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for setIdentifierPattern without sending the request
+     */
+    setIdentifierPatternRequestOpts(requestParameters: SetIdentifierPatternRequest): Promise<runtime.RequestOpts>;
     /**
      * sets / saves an identifier pattern
      */
@@ -74,6 +120,10 @@ export declare class IdentifiersApi extends runtime.BaseAPI {
      * sets / saves an identifier pattern
      */
     setIdentifierPattern(requestParameters: SetIdentifierPatternRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PatternDto>;
+    /**
+     * Creates request options for testIdentifierPattern without sending the request
+     */
+    testIdentifierPatternRequestOpts(requestParameters: TestIdentifierPatternRequest): Promise<runtime.RequestOpts>;
     /**
      * tests whether a identifier pattern is valid and returns an example
      */

package/dist/apis/IdentifiersApi.js

@@ -65,7 +65,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdentifiersApi = void 0;
 var runtime = require("../runtime");
-var index_1 = require("../models/index");
+var IdentifierDto_1 = require("../models/IdentifierDto");
+var PatternDto_1 = require("../models/PatternDto");
 /**
  *
  */
@@ -74,31 +75,44 @@ var IdentifiersApi = /** @class */ (function (_super) {
     function IdentifiersApi() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * Creates request options for getAndSetIdentifier without sending the request
+     */
+    IdentifiersApi.prototype.getAndSetIdentifierRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['identifierType'] == null) {
+                    throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling getAndSetIdentifier().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/identifiers/v1/{identifierType}/id";
+                urlPath = urlPath.replace('{identifierType}', encodeURIComponent(String(requestParameters['identifierType'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'PUT',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * get and persist next identifier
      */
     IdentifiersApi.prototype.getAndSetIdentifierRaw = 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['identifierType'] == null) {
-                            throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling getAndSetIdentifier().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/identifiers/v1/{identifierType}/id";
-                        urlPath = urlPath.replace("{".concat("identifierType", "}"), encodeURIComponent(String(requestParameters['identifierType'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'PUT',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getAndSetIdentifierRequestOpts(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.IdentifierDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, IdentifierDto_1.IdentifierDtoFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -120,31 +134,44 @@ var IdentifiersApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for getIdentifier without sending the request
+     */
+    IdentifiersApi.prototype.getIdentifierRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['identifierType'] == null) {
+                    throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling getIdentifier().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/identifiers/v1/{identifierType}/id";
+                urlPath = urlPath.replace('{identifierType}', encodeURIComponent(String(requestParameters['identifierType'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * get next identifier
      */
     IdentifiersApi.prototype.getIdentifierRaw = 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['identifierType'] == null) {
-                            throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling getIdentifier().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/identifiers/v1/{identifierType}/id";
-                        urlPath = urlPath.replace("{".concat("identifierType", "}"), encodeURIComponent(String(requestParameters['identifierType'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'GET',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getIdentifierRequestOpts(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.IdentifierDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, IdentifierDto_1.IdentifierDtoFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -166,31 +193,44 @@ var IdentifiersApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for getIdentifierPattern without sending the request
+     */
+    IdentifiersApi.prototype.getIdentifierPatternRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['identifierType'] == null) {
+                    throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling getIdentifierPattern().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/identifiers/v1/{identifierType}";
+                urlPath = urlPath.replace('{identifierType}', encodeURIComponent(String(requestParameters['identifierType'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * returns the saved identifier pattern
      */
     IdentifiersApi.prototype.getIdentifierPatternRaw = 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['identifierType'] == null) {
-                            throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling getIdentifierPattern().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/identifiers/v1/{identifierType}";
-                        urlPath = urlPath.replace("{".concat("identifierType", "}"), encodeURIComponent(String(requestParameters['identifierType'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'GET',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getIdentifierPatternRequestOpts(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.PatternDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, PatternDto_1.PatternDtoFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -212,29 +252,42 @@ var IdentifiersApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for resetIdentifierPattern without sending the request
+     */
+    IdentifiersApi.prototype.resetIdentifierPatternRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['identifierType'] == null) {
+                    throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling resetIdentifierPattern().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/ui/identifiers/v1/{identifierType}";
+                urlPath = urlPath.replace('{identifierType}', encodeURIComponent(String(requestParameters['identifierType'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'DELETE',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * resets identifier counters
      */
     IdentifiersApi.prototype.resetIdentifierPatternRaw = 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['identifierType'] == null) {
-                            throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling resetIdentifierPattern().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/ui/identifiers/v1/{identifierType}";
-                        urlPath = urlPath.replace("{".concat("identifierType", "}"), encodeURIComponent(String(requestParameters['identifierType'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'DELETE',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.resetIdentifierPatternRequestOpts(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)];
                 }
@@ -256,36 +309,49 @@ var IdentifiersApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for setIdentifierPattern without sending the request
+     */
+    IdentifiersApi.prototype.setIdentifierPatternRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['identifierType'] == null) {
+                    throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling setIdentifierPattern().');
+                }
+                if (requestParameters['patternDto'] == null) {
+                    throw new runtime.RequiredError('patternDto', 'Required parameter "patternDto" was null or undefined when calling setIdentifierPattern().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/ui/identifiers/v1/{identifierType}";
+                urlPath = urlPath.replace('{identifierType}', encodeURIComponent(String(requestParameters['identifierType'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, PatternDto_1.PatternDtoToJSON)(requestParameters['patternDto']),
+                    }];
+            });
+        });
+    };
     /**
      * sets / saves an identifier pattern
      */
     IdentifiersApi.prototype.setIdentifierPatternRaw = 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['identifierType'] == null) {
-                            throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling setIdentifierPattern().');
-                        }
-                        if (requestParameters['patternDto'] == null) {
-                            throw new runtime.RequiredError('patternDto', 'Required parameter "patternDto" was null or undefined when calling setIdentifierPattern().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/ui/identifiers/v1/{identifierType}";
-                        urlPath = urlPath.replace("{".concat("identifierType", "}"), encodeURIComponent(String(requestParameters['identifierType'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'POST',
-                                headers: headerParameters,
-                                query: queryParameters,
-                                body: (0, index_1.PatternDtoToJSON)(requestParameters['patternDto']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.setIdentifierPatternRequestOpts(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.PatternDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, PatternDto_1.PatternDtoFromJSON)(jsonValue); })];
                 }
             });
         });
@@ -307,36 +373,49 @@ var IdentifiersApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for testIdentifierPattern without sending the request
+     */
+    IdentifiersApi.prototype.testIdentifierPatternRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['identifierType'] == null) {
+                    throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling testIdentifierPattern().');
+                }
+                if (requestParameters['patternDto'] == null) {
+                    throw new runtime.RequiredError('patternDto', 'Required parameter "patternDto" was null or undefined when calling testIdentifierPattern().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/ui/identifiers/v1/{identifierType}";
+                urlPath = urlPath.replace('{identifierType}', encodeURIComponent(String(requestParameters['identifierType'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'PUT',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, PatternDto_1.PatternDtoToJSON)(requestParameters['patternDto']),
+                    }];
+            });
+        });
+    };
     /**
      * tests whether a identifier pattern is valid and returns an example
      */
     IdentifiersApi.prototype.testIdentifierPatternRaw = 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['identifierType'] == null) {
-                            throw new runtime.RequiredError('identifierType', 'Required parameter "identifierType" was null or undefined when calling testIdentifierPattern().');
-                        }
-                        if (requestParameters['patternDto'] == null) {
-                            throw new runtime.RequiredError('patternDto', 'Required parameter "patternDto" was null or undefined when calling testIdentifierPattern().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/ui/identifiers/v1/{identifierType}";
-                        urlPath = urlPath.replace("{".concat("identifierType", "}"), encodeURIComponent(String(requestParameters['identifierType'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'PUT',
-                                headers: headerParameters,
-                                query: queryParameters,
-                                body: (0, index_1.PatternDtoToJSON)(requestParameters['patternDto']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.testIdentifierPatternRequestOpts(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.PatternDtoFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, PatternDto_1.PatternDtoFromJSON)(jsonValue); })];
                 }
             });
         });

package/dist/apis/InboxEmailsApi.d.ts

@@ -9,24 +9,45 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { EmailDto, GetAllInboxEmails200Response, KommerzPageable } from '../models/index';
+import { type EmailDto } from '../models/EmailDto';
+import { type GetAllInboxEmails200Response } from '../models/GetAllInboxEmails200Response';
+import { type KommerzPageable } from '../models/KommerzPageable';
 export interface CreateInboxEmailRequest {
-    emailDto: Omit<EmailDto, 'externalId'>;
+    /**
+     *
+     */
+    emailDto: Omit<EmailDto, 'externalId' | 'events'>;
 }
 export interface DeleteInboxEmailRequest {
+    /**
+     * id of entity
+     */
     id: string;
 }
 export interface GetAllInboxEmailsRequest {
+    /**
+     * 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 GetInboxEmailRequest {
+    /**
+     * id of entity
+     */
     id: string;
 }
 /**
  *
  */
 export declare class InboxEmailsApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for createInboxEmail without sending the request
+     */
+    createInboxEmailRequestOpts(requestParameters: CreateInboxEmailRequest): Promise<runtime.RequestOpts>;
     /**
      * send email
      */
@@ -35,6 +56,10 @@ export declare class InboxEmailsApi extends runtime.BaseAPI {
      * send email
      */
     createInboxEmail(requestParameters: CreateInboxEmailRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmailDto>;
+    /**
+     * Creates request options for deleteInboxEmail without sending the request
+     */
+    deleteInboxEmailRequestOpts(requestParameters: DeleteInboxEmailRequest): Promise<runtime.RequestOpts>;
     /**
      * delete single inboxEmail
      */
@@ -43,6 +68,10 @@ export declare class InboxEmailsApi extends runtime.BaseAPI {
      * delete single inboxEmail
      */
     deleteInboxEmail(requestParameters: DeleteInboxEmailRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for getAllInboxEmails without sending the request
+     */
+    getAllInboxEmailsRequestOpts(requestParameters: GetAllInboxEmailsRequest): Promise<runtime.RequestOpts>;
     /**
      * get all inbox emails
      */
@@ -51,6 +80,10 @@ export declare class InboxEmailsApi extends runtime.BaseAPI {
      * get all inbox emails
      */
     getAllInboxEmails(requestParameters: GetAllInboxEmailsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetAllInboxEmails200Response>;
+    /**
+     * Creates request options for getInboxEmail without sending the request
+     */
+    getInboxEmailRequestOpts(requestParameters: GetInboxEmailRequest): Promise<runtime.RequestOpts>;
     /**
      * read one inboxEmail
      */