@datadog/datadog-api-client 1.28.0 → 1.30.0

package/dist/packages/datadog-api-client-v2/apis/IncidentsApi.js

@@ -142,6 +142,41 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    createIncidentType(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createIncidentType'");
+            if (!_config.unstableOperations["v2.createIncidentType"]) {
+                throw new Error("Unstable operation 'createIncidentType' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createIncidentType");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/types";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.createIncidentType")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "IncidentTypeCreateRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     deleteIncident(incidentId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -238,6 +273,34 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    deleteIncidentType(incidentTypeId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'deleteIncidentType'");
+            if (!_config.unstableOperations["v2.deleteIncidentType"]) {
+                throw new Error("Unstable operation 'deleteIncidentType' is disabled");
+            }
+            // verify required parameter 'incidentTypeId' is not null or undefined
+            if (incidentTypeId === null || incidentTypeId === undefined) {
+                throw new baseapi_1.RequiredError("incidentTypeId", "deleteIncidentType");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/types/{incident_type_id}".replace("{incident_type_id}", encodeURIComponent(String(incidentTypeId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.deleteIncidentType")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     getIncident(incidentId, include, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -259,7 +322,7 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             requestContext.setHttpConfig(_config.httpConfig);
             // Query Params
             if (include !== undefined) {
-                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentRelatedObject>", ""));
+                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentRelatedObject>", ""), "csv");
             }
             // Apply auth methods
             (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
@@ -338,6 +401,34 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    getIncidentType(incidentTypeId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getIncidentType'");
+            if (!_config.unstableOperations["v2.getIncidentType"]) {
+                throw new Error("Unstable operation 'getIncidentType' is disabled");
+            }
+            // verify required parameter 'incidentTypeId' is not null or undefined
+            if (incidentTypeId === null || incidentTypeId === undefined) {
+                throw new baseapi_1.RequiredError("incidentTypeId", "getIncidentType");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/types/{incident_type_id}".replace("{incident_type_id}", encodeURIComponent(String(incidentTypeId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.getIncidentType")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     listIncidentAttachments(incidentId, include, filterAttachmentType, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -359,14 +450,13 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             requestContext.setHttpConfig(_config.httpConfig);
             // Query Params
             if (include !== undefined) {
-                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentAttachmentRelatedObject>", ""));
+                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentAttachmentRelatedObject>", ""), "csv");
             }
             if (filterAttachmentType !== undefined) {
-                requestContext.setQueryParam("filter[attachment_type]", ObjectSerializer_1.ObjectSerializer.serialize(filterAttachmentType, "Array<IncidentAttachmentAttachmentType>", ""));
+                requestContext.setQueryParam("filter[attachment_type]", ObjectSerializer_1.ObjectSerializer.serialize(filterAttachmentType, "Array<IncidentAttachmentAttachmentType>", ""), "csv");
             }
             // Apply auth methods
             (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
-                "AuthZ",
                 "apiKeyAuth",
                 "appKeyAuth",
             ]);
@@ -418,13 +508,13 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             requestContext.setHttpConfig(_config.httpConfig);
             // Query Params
             if (include !== undefined) {
-                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentRelatedObject>", ""));
+                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentRelatedObject>", ""), "csv");
             }
             if (pageSize !== undefined) {
-                requestContext.setQueryParam("page[size]", ObjectSerializer_1.ObjectSerializer.serialize(pageSize, "number", "int64"));
+                requestContext.setQueryParam("page[size]", ObjectSerializer_1.ObjectSerializer.serialize(pageSize, "number", "int64"), "");
             }
             if (pageOffset !== undefined) {
-                requestContext.setQueryParam("page[offset]", ObjectSerializer_1.ObjectSerializer.serialize(pageOffset, "number", "int64"));
+                requestContext.setQueryParam("page[offset]", ObjectSerializer_1.ObjectSerializer.serialize(pageOffset, "number", "int64"), "");
             }
             // Apply auth methods
             (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
@@ -463,6 +553,34 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    listIncidentTypes(includeDeleted, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listIncidentTypes'");
+            if (!_config.unstableOperations["v2.listIncidentTypes"]) {
+                throw new Error("Unstable operation 'listIncidentTypes' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/types";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.listIncidentTypes")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (includeDeleted !== undefined) {
+                requestContext.setQueryParam("include_deleted", ObjectSerializer_1.ObjectSerializer.serialize(includeDeleted, "boolean", ""), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     searchIncidents(query, include, sort, pageSize, pageOffset, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -484,19 +602,19 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             requestContext.setHttpConfig(_config.httpConfig);
             // Query Params
             if (include !== undefined) {
-                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "IncidentRelatedObject", ""));
+                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "IncidentRelatedObject", ""), "");
             }
             if (query !== undefined) {
-                requestContext.setQueryParam("query", ObjectSerializer_1.ObjectSerializer.serialize(query, "string", ""));
+                requestContext.setQueryParam("query", ObjectSerializer_1.ObjectSerializer.serialize(query, "string", ""), "");
             }
             if (sort !== undefined) {
-                requestContext.setQueryParam("sort", ObjectSerializer_1.ObjectSerializer.serialize(sort, "IncidentSearchSortOrder", ""));
+                requestContext.setQueryParam("sort", ObjectSerializer_1.ObjectSerializer.serialize(sort, "IncidentSearchSortOrder", ""), "");
             }
             if (pageSize !== undefined) {
-                requestContext.setQueryParam("page[size]", ObjectSerializer_1.ObjectSerializer.serialize(pageSize, "number", "int64"));
+                requestContext.setQueryParam("page[size]", ObjectSerializer_1.ObjectSerializer.serialize(pageSize, "number", "int64"), "");
             }
             if (pageOffset !== undefined) {
-                requestContext.setQueryParam("page[offset]", ObjectSerializer_1.ObjectSerializer.serialize(pageOffset, "number", "int64"));
+                requestContext.setQueryParam("page[offset]", ObjectSerializer_1.ObjectSerializer.serialize(pageOffset, "number", "int64"), "");
             }
             // Apply auth methods
             (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
@@ -532,7 +650,7 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             requestContext.setHttpConfig(_config.httpConfig);
             // Query Params
             if (include !== undefined) {
-                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentRelatedObject>", ""));
+                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentRelatedObject>", ""), "csv");
             }
             // Body Params
             const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
@@ -575,7 +693,7 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             requestContext.setHttpConfig(_config.httpConfig);
             // Query Params
             if (include !== undefined) {
-                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentAttachmentRelatedObject>", ""));
+                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "Array<IncidentAttachmentRelatedObject>", ""), "csv");
             }
             // Body Params
             const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
@@ -682,6 +800,45 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    updateIncidentType(incidentTypeId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'updateIncidentType'");
+            if (!_config.unstableOperations["v2.updateIncidentType"]) {
+                throw new Error("Unstable operation 'updateIncidentType' is disabled");
+            }
+            // verify required parameter 'incidentTypeId' is not null or undefined
+            if (incidentTypeId === null || incidentTypeId === undefined) {
+                throw new baseapi_1.RequiredError("incidentTypeId", "updateIncidentType");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateIncidentType");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/types/{incident_type_id}".replace("{incident_type_id}", encodeURIComponent(String(incidentTypeId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.updateIncidentType")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.PATCH);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "IncidentTypePatchRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
 }
 exports.IncidentsApiRequestFactory = IncidentsApiRequestFactory;
 class IncidentsApiResponseProcessor {
@@ -802,6 +959,45 @@ class IncidentsApiResponseProcessor {
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
         });
     }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to createIncidentType
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createIncidentType(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 201) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTypeResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTypeResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -916,6 +1112,44 @@ class IncidentsApiResponseProcessor {
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
         });
     }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteIncidentType
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteIncidentType(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 204) {
+                return;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -1033,6 +1267,45 @@ class IncidentsApiResponseProcessor {
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
         });
     }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to getIncidentType
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getIncidentType(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTypeResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTypeResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -1189,6 +1462,44 @@ class IncidentsApiResponseProcessor {
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
         });
     }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to listIncidentTypes
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listIncidentTypes(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTypeListResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTypeListResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -1384,6 +1695,45 @@ class IncidentsApiResponseProcessor {
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
         });
     }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to updateIncidentType
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateIncidentType(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTypeResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTypeResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
 }
 exports.IncidentsApiResponseProcessor = IncidentsApiResponseProcessor;
 class IncidentsApi {
@@ -1436,6 +1786,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Create an incident type.
+     * @param param The request object
+     */
+    createIncidentType(param, options) {
+        const requestContextPromise = this.requestFactory.createIncidentType(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createIncidentType(responseContext);
+            });
+        });
+    }
     /**
      * Deletes an existing incident from the users organization.
      * @param param The request object
@@ -1478,6 +1842,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Delete an incident type.
+     * @param param The request object
+     */
+    deleteIncidentType(param, options) {
+        const requestContextPromise = this.requestFactory.deleteIncidentType(param.incidentTypeId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteIncidentType(responseContext);
+            });
+        });
+    }
     /**
      * Get the details of an incident by `incident_id`.
      * @param param The request object
@@ -1520,6 +1898,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Get incident type details.
+     * @param param The request object
+     */
+    getIncidentType(param, options) {
+        const requestContextPromise = this.requestFactory.getIncidentType(param.incidentTypeId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getIncidentType(responseContext);
+            });
+        });
+    }
     /**
      * Get all attachments for a given incident.
      * @param param The request object
@@ -1610,6 +2002,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Get all incident types.
+     * @param param The request object
+     */
+    listIncidentTypes(param = {}, options) {
+        const requestContextPromise = this.requestFactory.listIncidentTypes(param.includeDeleted, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listIncidentTypes(responseContext);
+            });
+        });
+    }
     /**
      * Search for incidents matching a certain query.
      * @param param The request object
@@ -1722,6 +2128,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Update an incident type.
+     * @param param The request object
+     */
+    updateIncidentType(param, options) {
+        const requestContextPromise = this.requestFactory.updateIncidentType(param.incidentTypeId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateIncidentType(responseContext);
+            });
+        });
+    }
 }
 exports.IncidentsApi = IncidentsApi;
 //# sourceMappingURL=IncidentsApi.js.map