@datadog/datadog-api-client 1.50.0 → 1.52.0

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

@@ -29,6 +29,44 @@ const logger_1 = require("../../../logger");
 const ObjectSerializer_1 = require("../models/ObjectSerializer");
 const exception_1 = require("../../datadog-api-client-common/exception");
 class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
+    createGlobalIncidentHandle(body, include, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createGlobalIncidentHandle'");
+            if (!_config.unstableOperations["v2.createGlobalIncidentHandle"]) {
+                throw new Error("Unstable operation 'createGlobalIncidentHandle' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createGlobalIncidentHandle");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/global/incident-handles";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.createGlobalIncidentHandle")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (include !== undefined) {
+                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "string", ""), "");
+            }
+            // 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, "IncidentHandleRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     createIncident(body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -255,6 +293,78 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    createIncidentPostmortemAttachment(incidentId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createIncidentPostmortemAttachment'");
+            if (!_config.unstableOperations["v2.createIncidentPostmortemAttachment"]) {
+                throw new Error("Unstable operation 'createIncidentPostmortemAttachment' is disabled");
+            }
+            // verify required parameter 'incidentId' is not null or undefined
+            if (incidentId === null || incidentId === undefined) {
+                throw new baseapi_1.RequiredError("incidentId", "createIncidentPostmortemAttachment");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createIncidentPostmortemAttachment");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/{incident_id}/attachments/postmortems".replace("{incident_id}", encodeURIComponent(String(incidentId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.createIncidentPostmortemAttachment")
+                .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, "PostmortemAttachmentRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    createIncidentPostmortemTemplate(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createIncidentPostmortemTemplate'");
+            if (!_config.unstableOperations["v2.createIncidentPostmortemTemplate"]) {
+                throw new Error("Unstable operation 'createIncidentPostmortemTemplate' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createIncidentPostmortemTemplate");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/postmortem-templates";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.createIncidentPostmortemTemplate")
+                .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, "PostmortemTemplateRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     createIncidentTodo(incidentId, body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -329,6 +439,29 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    deleteGlobalIncidentHandle(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'deleteGlobalIncidentHandle'");
+            if (!_config.unstableOperations["v2.deleteGlobalIncidentHandle"]) {
+                throw new Error("Unstable operation 'deleteGlobalIncidentHandle' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/global/incident-handles";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.deleteGlobalIncidentHandle")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     deleteIncident(incidentId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -519,6 +652,33 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    deleteIncidentPostmortemTemplate(templateId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'deleteIncidentPostmortemTemplate'");
+            if (!_config.unstableOperations["v2.deleteIncidentPostmortemTemplate"]) {
+                throw new Error("Unstable operation 'deleteIncidentPostmortemTemplate' is disabled");
+            }
+            // verify required parameter 'templateId' is not null or undefined
+            if (templateId === null || templateId === undefined) {
+                throw new baseapi_1.RequiredError("templateId", "deleteIncidentPostmortemTemplate");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/postmortem-templates/{template_id}".replace("{template_id}", encodeURIComponent(String(templateId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.deleteIncidentPostmortemTemplate")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     deleteIncidentTodo(incidentId, todoId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -581,6 +741,29 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    getGlobalIncidentSettings(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getGlobalIncidentSettings'");
+            if (!_config.unstableOperations["v2.getGlobalIncidentSettings"]) {
+                throw new Error("Unstable operation 'getGlobalIncidentSettings' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/global/settings";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.getGlobalIncidentSettings")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     getIncident(incidentId, include, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -711,6 +894,33 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    getIncidentPostmortemTemplate(templateId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getIncidentPostmortemTemplate'");
+            if (!_config.unstableOperations["v2.getIncidentPostmortemTemplate"]) {
+                throw new Error("Unstable operation 'getIncidentPostmortemTemplate' is disabled");
+            }
+            // verify required parameter 'templateId' is not null or undefined
+            if (templateId === null || templateId === undefined) {
+                throw new baseapi_1.RequiredError("templateId", "getIncidentPostmortemTemplate");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/postmortem-templates/{template_id}".replace("{template_id}", encodeURIComponent(String(templateId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.getIncidentPostmortemTemplate")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     getIncidentTodo(incidentId, todoId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -773,6 +983,33 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    listGlobalIncidentHandles(include, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listGlobalIncidentHandles'");
+            if (!_config.unstableOperations["v2.listGlobalIncidentHandles"]) {
+                throw new Error("Unstable operation 'listGlobalIncidentHandles' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/global/incident-handles";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.listGlobalIncidentHandles")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (include !== undefined) {
+                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "string", ""), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     listIncidentAttachments(incidentId, filterAttachmentType, include, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -922,6 +1159,29 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    listIncidentPostmortemTemplates(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listIncidentPostmortemTemplates'");
+            if (!_config.unstableOperations["v2.listIncidentPostmortemTemplates"]) {
+                throw new Error("Unstable operation 'listIncidentPostmortemTemplates' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/postmortem-templates";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.listIncidentPostmortemTemplates")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     listIncidents(include, pageSize, pageOffset, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -1056,6 +1316,78 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    updateGlobalIncidentHandle(body, include, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'updateGlobalIncidentHandle'");
+            if (!_config.unstableOperations["v2.updateGlobalIncidentHandle"]) {
+                throw new Error("Unstable operation 'updateGlobalIncidentHandle' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateGlobalIncidentHandle");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/global/incident-handles";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.updateGlobalIncidentHandle")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.PUT);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (include !== undefined) {
+                requestContext.setQueryParam("include", ObjectSerializer_1.ObjectSerializer.serialize(include, "string", ""), "");
+            }
+            // 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, "IncidentHandleRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    updateGlobalIncidentSettings(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'updateGlobalIncidentSettings'");
+            if (!_config.unstableOperations["v2.updateGlobalIncidentSettings"]) {
+                throw new Error("Unstable operation 'updateGlobalIncidentSettings' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateGlobalIncidentSettings");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/global/settings";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.updateGlobalIncidentSettings")
+                .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, "GlobalIncidentSettingsRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     updateIncident(incidentId, body, include, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -1279,16 +1611,54 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
-    updateIncidentTodo(incidentId, todoId, body, _options) {
+    updateIncidentPostmortemTemplate(templateId, body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
-            logger_1.logger.warn("Using unstable operation 'updateIncidentTodo'");
-            if (!_config.unstableOperations["v2.updateIncidentTodo"]) {
-                throw new Error("Unstable operation 'updateIncidentTodo' is disabled");
+            logger_1.logger.warn("Using unstable operation 'updateIncidentPostmortemTemplate'");
+            if (!_config.unstableOperations["v2.updateIncidentPostmortemTemplate"]) {
+                throw new Error("Unstable operation 'updateIncidentPostmortemTemplate' is disabled");
             }
-            // verify required parameter 'incidentId' is not null or undefined
-            if (incidentId === null || incidentId === undefined) {
-                throw new baseapi_1.RequiredError("incidentId", "updateIncidentTodo");
+            // verify required parameter 'templateId' is not null or undefined
+            if (templateId === null || templateId === undefined) {
+                throw new baseapi_1.RequiredError("templateId", "updateIncidentPostmortemTemplate");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateIncidentPostmortemTemplate");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/incidents/config/postmortem-templates/{template_id}".replace("{template_id}", encodeURIComponent(String(templateId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.IncidentsApi.updateIncidentPostmortemTemplate")
+                .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, "PostmortemTemplateRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    updateIncidentTodo(incidentId, todoId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'updateIncidentTodo'");
+            if (!_config.unstableOperations["v2.updateIncidentTodo"]) {
+                throw new Error("Unstable operation 'updateIncidentTodo' is disabled");
+            }
+            // verify required parameter 'incidentId' is not null or undefined
+            if (incidentId === null || incidentId === undefined) {
+                throw new baseapi_1.RequiredError("incidentId", "updateIncidentTodo");
             }
             // verify required parameter 'todoId' is not null or undefined
             if (todoId === null || todoId === undefined) {
@@ -1366,6 +1736,53 @@ class IncidentsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
 }
 exports.IncidentsApiRequestFactory = IncidentsApiRequestFactory;
 class IncidentsApiResponseProcessor {
+    /**
+     * 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 createGlobalIncidentHandle
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createGlobalIncidentHandle(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), "IncidentHandleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (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), "IncidentHandleResponse", "");
+                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
@@ -1598,6 +2015,100 @@ 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 createIncidentPostmortemAttachment
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createIncidentPostmortemAttachment(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), "Attachment");
+                return body;
+            }
+            if (response.httpStatusCode === 400) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (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), "Attachment", "");
+                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
+     *
+     * @params response Response returned by the server for a request to createIncidentPostmortemTemplate
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createIncidentPostmortemTemplate(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), "PostmortemTemplateResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 || response.httpStatusCode === 403) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (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), "PostmortemTemplateResponse", "");
+                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
@@ -1676,6 +2187,51 @@ 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 deleteGlobalIncidentHandle
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteGlobalIncidentHandle(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) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (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) {
+                return;
+            }
+            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
@@ -1896,6 +2452,51 @@ 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 deleteIncidentPostmortemTemplate
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteIncidentPostmortemTemplate(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 === 404) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (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) {
+                return;
+            }
+            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
@@ -1970,6 +2571,53 @@ 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 getGlobalIncidentSettings
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getGlobalIncidentSettings(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), "GlobalIncidentSettingsResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (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), "GlobalIncidentSettingsResponse", "");
+                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
@@ -2126,6 +2774,53 @@ 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 getIncidentPostmortemTemplate
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getIncidentPostmortemTemplate(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), "PostmortemTemplateResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 || response.httpStatusCode === 404) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (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), "PostmortemTemplateResponse", "");
+                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
@@ -2204,6 +2899,53 @@ 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 listGlobalIncidentHandles
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listGlobalIncidentHandles(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), "IncidentHandlesResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (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), "IncidentHandlesResponse", "");
+                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
@@ -2246,11 +2988,128 @@ class IncidentsApiResponseProcessor {
      * @params response Response returned by the server for a request to listIncidentImpacts
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listIncidentImpacts(response) {
+    listIncidentImpacts(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), "IncidentImpactsResponse");
+                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), "IncidentImpactsResponse", "");
+                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
+     *
+     * @params response Response returned by the server for a request to listIncidentIntegrations
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listIncidentIntegrations(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), "IncidentIntegrationMetadataListResponse");
+                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), "IncidentIntegrationMetadataListResponse", "");
+                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
+     *
+     * @params response Response returned by the server for a request to listIncidentNotificationRules
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listIncidentNotificationRules(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), "IncidentNotificationRuleArray");
+                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), "IncidentNotificationRuleArray", "");
+                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
+     *
+     * @params response Response returned by the server for a request to listIncidentNotificationTemplates
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listIncidentNotificationTemplates(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), "IncidentImpactsResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentNotificationTemplateArray");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
@@ -2271,7 +3130,7 @@ class IncidentsApiResponseProcessor {
             }
             // 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), "IncidentImpactsResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentNotificationTemplateArray", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2282,21 +3141,29 @@ class IncidentsApiResponseProcessor {
      * 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 listIncidentIntegrations
+     * @params response Response returned by the server for a request to listIncidentPostmortemTemplates
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listIncidentIntegrations(response) {
+    listIncidentPostmortemTemplates(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), "IncidentIntegrationMetadataListResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "PostmortemTemplatesResponse");
                 return body;
             }
-            if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 401 ||
-                response.httpStatusCode === 403 ||
-                response.httpStatusCode === 404 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 400) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -2310,7 +3177,7 @@ class IncidentsApiResponseProcessor {
             }
             // 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), "IncidentIntegrationMetadataListResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "PostmortemTemplatesResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2321,14 +3188,14 @@ class IncidentsApiResponseProcessor {
      * 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 listIncidentNotificationRules
+     * @params response Response returned by the server for a request to listIncidents
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listIncidentNotificationRules(response) {
+    listIncidents(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), "IncidentNotificationRuleArray");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentsResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
@@ -2349,7 +3216,7 @@ class IncidentsApiResponseProcessor {
             }
             // 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), "IncidentNotificationRuleArray", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentsResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2360,14 +3227,14 @@ class IncidentsApiResponseProcessor {
      * 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 listIncidentNotificationTemplates
+     * @params response Response returned by the server for a request to listIncidentTodos
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listIncidentNotificationTemplates(response) {
+    listIncidentTodos(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), "IncidentNotificationTemplateArray");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTodoListResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
@@ -2388,7 +3255,7 @@ class IncidentsApiResponseProcessor {
             }
             // 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), "IncidentNotificationTemplateArray", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTodoListResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2399,20 +3266,19 @@ class IncidentsApiResponseProcessor {
      * 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 listIncidents
+     * @params response Response returned by the server for a request to listIncidentTypes
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listIncidents(response) {
+    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), "IncidentsResponse");
+                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 === 404 ||
                 response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
@@ -2427,7 +3293,7 @@ class IncidentsApiResponseProcessor {
             }
             // 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), "IncidentsResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentTypeListResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2438,14 +3304,14 @@ class IncidentsApiResponseProcessor {
      * 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 listIncidentTodos
+     * @params response Response returned by the server for a request to searchIncidents
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listIncidentTodos(response) {
+    searchIncidents(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), "IncidentTodoListResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentSearchResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
@@ -2466,7 +3332,7 @@ class IncidentsApiResponseProcessor {
             }
             // 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), "IncidentTodoListResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentSearchResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2477,20 +3343,29 @@ class IncidentsApiResponseProcessor {
      * 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
+     * @params response Response returned by the server for a request to updateGlobalIncidentHandle
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listIncidentTypes(response) {
+    updateGlobalIncidentHandle(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");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentHandleResponse");
                 return body;
             }
-            if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 401 ||
-                response.httpStatusCode === 403 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 400) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -2504,7 +3379,7 @@ class IncidentsApiResponseProcessor {
             }
             // 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", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "IncidentHandleResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2515,21 +3390,29 @@ class IncidentsApiResponseProcessor {
      * 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 searchIncidents
+     * @params response Response returned by the server for a request to updateGlobalIncidentSettings
      * @throws ApiException if the response code was not in [200, 299]
      */
-    searchIncidents(response) {
+    updateGlobalIncidentSettings(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), "IncidentSearchResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GlobalIncidentSettingsResponse");
                 return body;
             }
-            if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 401 ||
-                response.httpStatusCode === 403 ||
-                response.httpStatusCode === 404 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 400) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -2543,7 +3426,7 @@ class IncidentsApiResponseProcessor {
             }
             // 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), "IncidentSearchResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GlobalIncidentSettingsResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2744,6 +3627,53 @@ 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 updateIncidentPostmortemTemplate
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateIncidentPostmortemTemplate(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), "PostmortemTemplateResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 || response.httpStatusCode === 404) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (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), "PostmortemTemplateResponse", "");
+                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
@@ -2832,6 +3762,20 @@ class IncidentsApi {
         this.responseProcessor =
             responseProcessor || new IncidentsApiResponseProcessor();
     }
+    /**
+     * Create a new global incident handle.
+     * @param param The request object
+     */
+    createGlobalIncidentHandle(param, options) {
+        const requestContextPromise = this.requestFactory.createGlobalIncidentHandle(param.body, param.include, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createGlobalIncidentHandle(responseContext);
+            });
+        });
+    }
     /**
      * Create an incident.
      * @param param The request object
@@ -2916,6 +3860,38 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Create a postmortem attachment for an incident.
+     *
+     * The endpoint accepts markdown for notebooks created in Confluence or Google Docs.
+     * Postmortems created from notebooks need to be formatted using frontend notebook cells,
+     * in addition to markdown format.
+     * @param param The request object
+     */
+    createIncidentPostmortemAttachment(param, options) {
+        const requestContextPromise = this.requestFactory.createIncidentPostmortemAttachment(param.incidentId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createIncidentPostmortemAttachment(responseContext);
+            });
+        });
+    }
+    /**
+     * Create a new postmortem template for incidents.
+     * @param param The request object
+     */
+    createIncidentPostmortemTemplate(param, options) {
+        const requestContextPromise = this.requestFactory.createIncidentPostmortemTemplate(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createIncidentPostmortemTemplate(responseContext);
+            });
+        });
+    }
     /**
      * Create an incident todo.
      * @param param The request object
@@ -2944,6 +3920,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Delete a global incident handle.
+     * @param param The request object
+     */
+    deleteGlobalIncidentHandle(options) {
+        const requestContextPromise = this.requestFactory.deleteGlobalIncidentHandle(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteGlobalIncidentHandle(responseContext);
+            });
+        });
+    }
     /**
      * Deletes an existing incident from the users organization.
      * @param param The request object
@@ -3027,6 +4017,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Delete a postmortem template.
+     * @param param The request object
+     */
+    deleteIncidentPostmortemTemplate(param, options) {
+        const requestContextPromise = this.requestFactory.deleteIncidentPostmortemTemplate(param.templateId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteIncidentPostmortemTemplate(responseContext);
+            });
+        });
+    }
     /**
      * Delete an incident todo.
      * @param param The request object
@@ -3055,6 +4059,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Retrieve global incident settings for the organization.
+     * @param param The request object
+     */
+    getGlobalIncidentSettings(options) {
+        const requestContextPromise = this.requestFactory.getGlobalIncidentSettings(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getGlobalIncidentSettings(responseContext);
+            });
+        });
+    }
     /**
      * Get the details of an incident by `incident_id`.
      * @param param The request object
@@ -3111,6 +4129,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Retrieve details of a specific postmortem template.
+     * @param param The request object
+     */
+    getIncidentPostmortemTemplate(param, options) {
+        const requestContextPromise = this.requestFactory.getIncidentPostmortemTemplate(param.templateId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getIncidentPostmortemTemplate(responseContext);
+            });
+        });
+    }
     /**
      * Get incident todo details.
      * @param param The request object
@@ -3139,6 +4171,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Retrieve a list of global incident handles.
+     * @param param The request object
+     */
+    listGlobalIncidentHandles(param = {}, options) {
+        const requestContextPromise = this.requestFactory.listGlobalIncidentHandles(param.include, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listGlobalIncidentHandles(responseContext);
+            });
+        });
+    }
     /**
      * List incident attachments.
      * @param param The request object
@@ -3209,6 +4255,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Retrieve a list of all postmortem templates for incidents.
+     * @param param The request object
+     */
+    listIncidentPostmortemTemplates(options) {
+        const requestContextPromise = this.requestFactory.listIncidentPostmortemTemplates(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listIncidentPostmortemTemplates(responseContext);
+            });
+        });
+    }
     /**
      * Get all incidents for the user's organization.
      * @param param The request object
@@ -3341,6 +4401,34 @@ class IncidentsApi {
             }
         });
     }
+    /**
+     * Update an existing global incident handle.
+     * @param param The request object
+     */
+    updateGlobalIncidentHandle(param, options) {
+        const requestContextPromise = this.requestFactory.updateGlobalIncidentHandle(param.body, param.include, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateGlobalIncidentHandle(responseContext);
+            });
+        });
+    }
+    /**
+     * Update global incident settings for the organization.
+     * @param param The request object
+     */
+    updateGlobalIncidentSettings(param, options) {
+        const requestContextPromise = this.requestFactory.updateGlobalIncidentSettings(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateGlobalIncidentSettings(responseContext);
+            });
+        });
+    }
     /**
      * Updates an incident. Provide only the attributes that should be updated as this request is a partial update.
      * @param param The request object
@@ -3410,6 +4498,20 @@ class IncidentsApi {
             });
         });
     }
+    /**
+     * Update an existing postmortem template.
+     * @param param The request object
+     */
+    updateIncidentPostmortemTemplate(param, options) {
+        const requestContextPromise = this.requestFactory.updateIncidentPostmortemTemplate(param.templateId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateIncidentPostmortemTemplate(responseContext);
+            });
+        });
+    }
     /**
      * Update an incident todo.
      * @param param The request object