@datadog/datadog-api-client 1.34.1 → 1.36.0

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

@@ -17,6 +17,41 @@ const logger_1 = require("../../../logger");
 const ObjectSerializer_1 = require("../models/ObjectSerializer");
 const exception_1 = require("../../datadog-api-client-common/exception");
 class OnCallApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
+    createOnCallEscalationPolicy(body, include, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createOnCallEscalationPolicy");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/on-call/escalation-policies";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.OnCallApi.createOnCallEscalationPolicy")
+                .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, "EscalationPolicyCreateRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     createOnCallSchedule(body, include, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -52,6 +87,30 @@ class OnCallApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    deleteOnCallEscalationPolicy(policyId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'policyId' is not null or undefined
+            if (policyId === null || policyId === undefined) {
+                throw new baseapi_1.RequiredError("policyId", "deleteOnCallEscalationPolicy");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/on-call/escalation-policies/{policy_id}".replace("{policy_id}", encodeURIComponent(String(policyId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.OnCallApi.deleteOnCallEscalationPolicy")
+                .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;
+        });
+    }
     deleteOnCallSchedule(scheduleId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -76,6 +135,34 @@ class OnCallApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    getOnCallEscalationPolicy(policyId, include, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'policyId' is not null or undefined
+            if (policyId === null || policyId === undefined) {
+                throw new baseapi_1.RequiredError("policyId", "getOnCallEscalationPolicy");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/on-call/escalation-policies/{policy_id}".replace("{policy_id}", encodeURIComponent(String(policyId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.OnCallApi.getOnCallEscalationPolicy")
+                .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, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     getOnCallSchedule(scheduleId, include, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -104,6 +191,171 @@ class OnCallApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    getOnCallTeamRoutingRules(teamId, include, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'teamId' is not null or undefined
+            if (teamId === null || teamId === undefined) {
+                throw new baseapi_1.RequiredError("teamId", "getOnCallTeamRoutingRules");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/on-call/teams/{team_id}/routing-rules".replace("{team_id}", encodeURIComponent(String(teamId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.OnCallApi.getOnCallTeamRoutingRules")
+                .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, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getScheduleOnCallUser(scheduleId, include, filterAtTs, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'scheduleId' is not null or undefined
+            if (scheduleId === null || scheduleId === undefined) {
+                throw new baseapi_1.RequiredError("scheduleId", "getScheduleOnCallUser");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/on-call/schedules/{schedule_id}/on-call".replace("{schedule_id}", encodeURIComponent(String(scheduleId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.OnCallApi.getScheduleOnCallUser")
+                .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", ""), "");
+            }
+            if (filterAtTs !== undefined) {
+                requestContext.setQueryParam("filter[at_ts]", ObjectSerializer_1.ObjectSerializer.serialize(filterAtTs, "string", ""), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getTeamOnCallUsers(teamId, include, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'teamId' is not null or undefined
+            if (teamId === null || teamId === undefined) {
+                throw new baseapi_1.RequiredError("teamId", "getTeamOnCallUsers");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/on-call/teams/{team_id}/on-call".replace("{team_id}", encodeURIComponent(String(teamId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.OnCallApi.getTeamOnCallUsers")
+                .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, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    setOnCallTeamRoutingRules(teamId, body, include, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'teamId' is not null or undefined
+            if (teamId === null || teamId === undefined) {
+                throw new baseapi_1.RequiredError("teamId", "setOnCallTeamRoutingRules");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "setOnCallTeamRoutingRules");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/on-call/teams/{team_id}/routing-rules".replace("{team_id}", encodeURIComponent(String(teamId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.OnCallApi.setOnCallTeamRoutingRules")
+                .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, "TeamRoutingRulesRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    updateOnCallEscalationPolicy(policyId, body, include, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'policyId' is not null or undefined
+            if (policyId === null || policyId === undefined) {
+                throw new baseapi_1.RequiredError("policyId", "updateOnCallEscalationPolicy");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateOnCallEscalationPolicy");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/on-call/escalation-policies/{policy_id}".replace("{policy_id}", encodeURIComponent(String(policyId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.OnCallApi.updateOnCallEscalationPolicy")
+                .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, "EscalationPolicyUpdateRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     updateOnCallSchedule(scheduleId, body, include, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -146,6 +398,44 @@ class OnCallApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
 }
 exports.OnCallApiRequestFactory = OnCallApiRequestFactory;
 class OnCallApiResponseProcessor {
+    /**
+     * 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 createOnCallEscalationPolicy
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createOnCallEscalationPolicy(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), "EscalationPolicy");
+                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), "EscalationPolicy", "");
+                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
@@ -188,10 +478,10 @@ class OnCallApiResponseProcessor {
      * 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 deleteOnCallSchedule
+     * @params response Response returned by the server for a request to deleteOnCallEscalationPolicy
      * @throws ApiException if the response code was not in [200, 299]
      */
-    deleteOnCallSchedule(response) {
+    deleteOnCallEscalationPolicy(response) {
         return __awaiter(this, void 0, void 0, function* () {
             const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
             if (response.httpStatusCode === 204) {
@@ -225,15 +515,14 @@ class OnCallApiResponseProcessor {
      * 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 getOnCallSchedule
+     * @params response Response returned by the server for a request to deleteOnCallSchedule
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getOnCallSchedule(response) {
+    deleteOnCallSchedule(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), "Schedule");
-                return body;
+            if (response.httpStatusCode === 204) {
+                return;
             }
             if (response.httpStatusCode === 401 ||
                 response.httpStatusCode === 403 ||
@@ -252,7 +541,7 @@ class OnCallApiResponseProcessor {
             }
             // 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), "Schedule", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -263,14 +552,14 @@ class OnCallApiResponseProcessor {
      * 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 updateOnCallSchedule
+     * @params response Response returned by the server for a request to getOnCallEscalationPolicy
      * @throws ApiException if the response code was not in [200, 299]
      */
-    updateOnCallSchedule(response) {
+    getOnCallEscalationPolicy(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), "Schedule");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "EscalationPolicy");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
@@ -291,17 +580,281 @@ class OnCallApiResponseProcessor {
             }
             // 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), "Schedule", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "EscalationPolicy", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
         });
     }
-}
-exports.OnCallApiResponseProcessor = OnCallApiResponseProcessor;
-class OnCallApi {
-    constructor(configuration, requestFactory, responseProcessor) {
+    /**
+     * 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 getOnCallSchedule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getOnCallSchedule(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), "Schedule");
+                return body;
+            }
+            if (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), "Schedule", "");
+                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 getOnCallTeamRoutingRules
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getOnCallTeamRoutingRules(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), "TeamRoutingRules");
+                return 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), "TeamRoutingRules", "");
+                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 getScheduleOnCallUser
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getScheduleOnCallUser(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), "Shift");
+                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), "Shift", "");
+                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 getTeamOnCallUsers
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getTeamOnCallUsers(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), "TeamOnCallResponders");
+                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), "TeamOnCallResponders", "");
+                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 setOnCallTeamRoutingRules
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    setOnCallTeamRoutingRules(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), "TeamRoutingRules");
+                return 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), "TeamRoutingRules", "");
+                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 updateOnCallEscalationPolicy
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateOnCallEscalationPolicy(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), "EscalationPolicy");
+                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), "EscalationPolicy", "");
+                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 updateOnCallSchedule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateOnCallSchedule(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), "Schedule");
+                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), "Schedule", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+}
+exports.OnCallApiResponseProcessor = OnCallApiResponseProcessor;
+class OnCallApi {
+    constructor(configuration, requestFactory, responseProcessor) {
         this.configuration = configuration;
         this.requestFactory =
             requestFactory || new OnCallApiRequestFactory(configuration);
@@ -309,7 +862,21 @@ class OnCallApi {
             responseProcessor || new OnCallApiResponseProcessor();
     }
     /**
-     * Create a new on-call schedule
+     * Create a new On-Call escalation policy
+     * @param param The request object
+     */
+    createOnCallEscalationPolicy(param, options) {
+        const requestContextPromise = this.requestFactory.createOnCallEscalationPolicy(param.body, param.include, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createOnCallEscalationPolicy(responseContext);
+            });
+        });
+    }
+    /**
+     * Create a new On-Call schedule
      * @param param The request object
      */
     createOnCallSchedule(param, options) {
@@ -323,7 +890,21 @@ class OnCallApi {
         });
     }
     /**
-     * Delete an on-call schedule
+     * Delete an On-Call escalation policy
+     * @param param The request object
+     */
+    deleteOnCallEscalationPolicy(param, options) {
+        const requestContextPromise = this.requestFactory.deleteOnCallEscalationPolicy(param.policyId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteOnCallEscalationPolicy(responseContext);
+            });
+        });
+    }
+    /**
+     * Delete an On-Call schedule
      * @param param The request object
      */
     deleteOnCallSchedule(param, options) {
@@ -337,7 +918,21 @@ class OnCallApi {
         });
     }
     /**
-     * Get an on-call schedule
+     * Get an On-Call escalation policy
+     * @param param The request object
+     */
+    getOnCallEscalationPolicy(param, options) {
+        const requestContextPromise = this.requestFactory.getOnCallEscalationPolicy(param.policyId, param.include, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getOnCallEscalationPolicy(responseContext);
+            });
+        });
+    }
+    /**
+     * Get an On-Call schedule
      * @param param The request object
      */
     getOnCallSchedule(param, options) {
@@ -351,7 +946,77 @@ class OnCallApi {
         });
     }
     /**
-     * Update a new on-call schedule
+     * Get a team's On-Call routing rules
+     * @param param The request object
+     */
+    getOnCallTeamRoutingRules(param, options) {
+        const requestContextPromise = this.requestFactory.getOnCallTeamRoutingRules(param.teamId, param.include, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getOnCallTeamRoutingRules(responseContext);
+            });
+        });
+    }
+    /**
+     * Retrieves the user who is on-call for the specified schedule at a given time.
+     * @param param The request object
+     */
+    getScheduleOnCallUser(param, options) {
+        const requestContextPromise = this.requestFactory.getScheduleOnCallUser(param.scheduleId, param.include, param.filterAtTs, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getScheduleOnCallUser(responseContext);
+            });
+        });
+    }
+    /**
+     * Get a team's on-call users at a given time
+     * @param param The request object
+     */
+    getTeamOnCallUsers(param, options) {
+        const requestContextPromise = this.requestFactory.getTeamOnCallUsers(param.teamId, param.include, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getTeamOnCallUsers(responseContext);
+            });
+        });
+    }
+    /**
+     * Set a team's On-Call routing rules
+     * @param param The request object
+     */
+    setOnCallTeamRoutingRules(param, options) {
+        const requestContextPromise = this.requestFactory.setOnCallTeamRoutingRules(param.teamId, param.body, param.include, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.setOnCallTeamRoutingRules(responseContext);
+            });
+        });
+    }
+    /**
+     * Update an On-Call escalation policy
+     * @param param The request object
+     */
+    updateOnCallEscalationPolicy(param, options) {
+        const requestContextPromise = this.requestFactory.updateOnCallEscalationPolicy(param.policyId, param.body, param.include, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateOnCallEscalationPolicy(responseContext);
+            });
+        });
+    }
+    /**
+     * Update a new On-Call schedule
      * @param param The request object
      */
     updateOnCallSchedule(param, options) {