From 22de120df167b98eda94af7aab8b6a4056f0a905 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Mon, 11 May 2026 12:16:00 +0000 Subject: [PATCH] Regenerate client from commit e2d2f14 of spec repo --- .generator/schemas/v2/openapi.yaml | 32 +++ .../v2/on-call/SetOnCallTeamRoutingRules.java | 39 ++- .../client/v2/model/RoutingRuleAction.java | 79 ++++- .../RoutingRuleEscalationPolicyAction.java | 270 ++++++++++++++++++ ...RoutingRuleEscalationPolicyActionType.java | 62 ++++ .../datadog/api/client/v2/api/on-call.feature | 2 +- 6 files changed, 476 insertions(+), 8 deletions(-) create mode 100644 src/main/java/com/datadog/api/client/v2/model/RoutingRuleEscalationPolicyAction.java create mode 100644 src/main/java/com/datadog/api/client/v2/model/RoutingRuleEscalationPolicyActionType.java diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index ad1ff827d8d..c37e6363917 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -59535,6 +59535,7 @@ components: - $ref: "#/components/schemas/SendSlackMessageAction" - $ref: "#/components/schemas/SendTeamsMessageAction" - $ref: "#/components/schemas/TriggerWorkflowAutomationAction" + - $ref: "#/components/schemas/RoutingRuleEscalationPolicyAction" RoutingRuleAttributes: description: Defines the configurable attributes of a routing rule, such as actions, query, time restriction, and urgency. properties: @@ -59552,6 +59553,37 @@ components: urgency: $ref: "#/components/schemas/Urgency" type: object + RoutingRuleEscalationPolicyAction: + description: "Routes the page to an escalation policy, optionally restricted to business hours." + properties: + ack_timeout_minutes: + description: "The number of minutes before an unacknowledged page is re-escalated." + example: 10 + format: int64 + type: integer + policy_id: + description: "The ID of the escalation policy to route to." + example: "00000000-0000-0000-0000-000000000000" + type: string + support_hours: + $ref: "#/components/schemas/TimeRestrictions" + type: + $ref: "#/components/schemas/RoutingRuleEscalationPolicyActionType" + urgency: + $ref: "#/components/schemas/Urgency" + required: + - type + - policy_id + type: object + RoutingRuleEscalationPolicyActionType: + default: escalation_policy + description: "Indicates that the action routes to an escalation policy." + enum: + - escalation_policy + example: escalation_policy + type: string + x-enum-varnames: + - ESCALATION_POLICY RoutingRuleRelationships: description: Specifies relationships for a routing rule, linking to associated policy resources. properties: diff --git a/examples/v2/on-call/SetOnCallTeamRoutingRules.java b/examples/v2/on-call/SetOnCallTeamRoutingRules.java index 7d58d6cbb5f..6a776dfe674 100644 --- a/examples/v2/on-call/SetOnCallTeamRoutingRules.java +++ b/examples/v2/on-call/SetOnCallTeamRoutingRules.java @@ -5,6 +5,8 @@ import com.datadog.api.client.v2.api.OnCallApi; import com.datadog.api.client.v2.api.OnCallApi.SetOnCallTeamRoutingRulesOptionalParameters; import com.datadog.api.client.v2.model.RoutingRuleAction; +import com.datadog.api.client.v2.model.RoutingRuleEscalationPolicyAction; +import com.datadog.api.client.v2.model.RoutingRuleEscalationPolicyActionType; import com.datadog.api.client.v2.model.SendSlackMessageAction; import com.datadog.api.client.v2.model.SendSlackMessageActionType; import com.datadog.api.client.v2.model.TeamRoutingRules; @@ -66,9 +68,40 @@ public static void main(String[] args) { .startDay(Weekday.TUESDAY) .startTime("09:00:00")))), new TeamRoutingRulesRequestRule() - .policyId(ESCALATION_POLICY_DATA_ID) - .query("") - .urgency(Urgency.LOW)))) + .actions( + Collections.singletonList( + new RoutingRuleAction( + new RoutingRuleEscalationPolicyAction() + .ackTimeoutMinutes(10L) + .policyId(ESCALATION_POLICY_DATA_ID) + .supportHours( + new TimeRestrictions() + .timeZone("Europe/Paris") + .restrictions( + Collections.singletonList( + new TimeRestriction() + .endDay(Weekday.FRIDAY) + .endTime("17:00:00") + .startDay( + Weekday.MONDAY) + .startTime( + "09:00:00")))) + .type( + RoutingRuleEscalationPolicyActionType + .ESCALATION_POLICY) + .urgency(Urgency.LOW)))) + .query("tags.service:test"), + new TeamRoutingRulesRequestRule() + .actions( + Collections.singletonList( + new RoutingRuleAction( + new RoutingRuleEscalationPolicyAction() + .policyId(ESCALATION_POLICY_DATA_ID) + .type( + RoutingRuleEscalationPolicyActionType + .ESCALATION_POLICY) + .urgency(Urgency.LOW)))) + .query("")))) .id(DD_TEAM_DATA_ID) .type(TeamRoutingRulesRequestDataType.TEAM_ROUTING_RULES)); diff --git a/src/main/java/com/datadog/api/client/v2/model/RoutingRuleAction.java b/src/main/java/com/datadog/api/client/v2/model/RoutingRuleAction.java index 3136393c741..c2892729956 100644 --- a/src/main/java/com/datadog/api/client/v2/model/RoutingRuleAction.java +++ b/src/main/java/com/datadog/api/client/v2/model/RoutingRuleAction.java @@ -213,6 +213,52 @@ public RoutingRuleAction deserialize(JsonParser jp, DeserializationContext ctxt) Level.FINER, "Input data does not match schema 'TriggerWorkflowAutomationAction'", e); } + // deserialize RoutingRuleEscalationPolicyAction + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (RoutingRuleEscalationPolicyAction.class.equals(Integer.class) + || RoutingRuleEscalationPolicyAction.class.equals(Long.class) + || RoutingRuleEscalationPolicyAction.class.equals(Float.class) + || RoutingRuleEscalationPolicyAction.class.equals(Double.class) + || RoutingRuleEscalationPolicyAction.class.equals(Boolean.class) + || RoutingRuleEscalationPolicyAction.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((RoutingRuleEscalationPolicyAction.class.equals(Integer.class) + || RoutingRuleEscalationPolicyAction.class.equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((RoutingRuleEscalationPolicyAction.class.equals(Float.class) + || RoutingRuleEscalationPolicyAction.class.equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (RoutingRuleEscalationPolicyAction.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (RoutingRuleEscalationPolicyAction.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = tree.traverse(jp.getCodec()).readValueAs(RoutingRuleEscalationPolicyAction.class); + // TODO: there is no validation against JSON schema constraints + // (min, max, enum, pattern...), this does not perform a strict JSON + // validation, which means the 'match' count may be higher than it should be. + if (!((RoutingRuleEscalationPolicyAction) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log(Level.FINER, "Input data matches schema 'RoutingRuleEscalationPolicyAction'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, "Input data does not match schema 'RoutingRuleEscalationPolicyAction'", e); + } + RoutingRuleAction ret = new RoutingRuleAction(); if (match == 1) { ret.setActualInstance(deserialized); @@ -256,11 +302,19 @@ public RoutingRuleAction(TriggerWorkflowAutomationAction o) { setActualInstance(o); } + public RoutingRuleAction(RoutingRuleEscalationPolicyAction o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + static { schemas.put("SendSlackMessageAction", new GenericType() {}); schemas.put("SendTeamsMessageAction", new GenericType() {}); schemas.put( "TriggerWorkflowAutomationAction", new GenericType() {}); + schemas.put( + "RoutingRuleEscalationPolicyAction", + new GenericType() {}); JSON.registerDescendants(RoutingRuleAction.class, Collections.unmodifiableMap(schemas)); } @@ -272,7 +326,7 @@ public Map getSchemas() { /** * Set the instance that matches the oneOf child schema, check the instance parameter is valid * against the oneOf child schemas: SendSlackMessageAction, SendTeamsMessageAction, - * TriggerWorkflowAutomationAction + * TriggerWorkflowAutomationAction, RoutingRuleEscalationPolicyAction * *

It could be an instance of the 'oneOf' schemas. The oneOf child schemas may themselves be a * composed schema (allOf, anyOf, oneOf). @@ -292,6 +346,11 @@ public void setActualInstance(Object instance) { super.setActualInstance(instance); return; } + if (JSON.isInstanceOf( + RoutingRuleEscalationPolicyAction.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } if (JSON.isInstanceOf(UnparsedObject.class, instance, new HashSet>())) { super.setActualInstance(instance); @@ -299,15 +358,15 @@ public void setActualInstance(Object instance) { } throw new RuntimeException( "Invalid instance type. Must be SendSlackMessageAction, SendTeamsMessageAction," - + " TriggerWorkflowAutomationAction"); + + " TriggerWorkflowAutomationAction, RoutingRuleEscalationPolicyAction"); } /** * Get the actual instance, which can be the following: SendSlackMessageAction, - * SendTeamsMessageAction, TriggerWorkflowAutomationAction + * SendTeamsMessageAction, TriggerWorkflowAutomationAction, RoutingRuleEscalationPolicyAction * * @return The actual instance (SendSlackMessageAction, SendTeamsMessageAction, - * TriggerWorkflowAutomationAction) + * TriggerWorkflowAutomationAction, RoutingRuleEscalationPolicyAction) */ @Override public Object getActualInstance() { @@ -347,4 +406,16 @@ public TriggerWorkflowAutomationAction getTriggerWorkflowAutomationAction() throws ClassCastException { return (TriggerWorkflowAutomationAction) super.getActualInstance(); } + + /** + * Get the actual instance of `RoutingRuleEscalationPolicyAction`. If the actual instance is not + * `RoutingRuleEscalationPolicyAction`, the ClassCastException will be thrown. + * + * @return The actual instance of `RoutingRuleEscalationPolicyAction` + * @throws ClassCastException if the instance is not `RoutingRuleEscalationPolicyAction` + */ + public RoutingRuleEscalationPolicyAction getRoutingRuleEscalationPolicyAction() + throws ClassCastException { + return (RoutingRuleEscalationPolicyAction) super.getActualInstance(); + } } diff --git a/src/main/java/com/datadog/api/client/v2/model/RoutingRuleEscalationPolicyAction.java b/src/main/java/com/datadog/api/client/v2/model/RoutingRuleEscalationPolicyAction.java new file mode 100644 index 00000000000..1b061bca45d --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/RoutingRuleEscalationPolicyAction.java @@ -0,0 +1,270 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.v2.model; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +/** Routes the page to an escalation policy, optionally restricted to business hours. */ +@JsonPropertyOrder({ + RoutingRuleEscalationPolicyAction.JSON_PROPERTY_ACK_TIMEOUT_MINUTES, + RoutingRuleEscalationPolicyAction.JSON_PROPERTY_POLICY_ID, + RoutingRuleEscalationPolicyAction.JSON_PROPERTY_SUPPORT_HOURS, + RoutingRuleEscalationPolicyAction.JSON_PROPERTY_TYPE, + RoutingRuleEscalationPolicyAction.JSON_PROPERTY_URGENCY +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class RoutingRuleEscalationPolicyAction { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_ACK_TIMEOUT_MINUTES = "ack_timeout_minutes"; + private Long ackTimeoutMinutes; + + public static final String JSON_PROPERTY_POLICY_ID = "policy_id"; + private String policyId; + + public static final String JSON_PROPERTY_SUPPORT_HOURS = "support_hours"; + private TimeRestrictions supportHours; + + public static final String JSON_PROPERTY_TYPE = "type"; + private RoutingRuleEscalationPolicyActionType type = + RoutingRuleEscalationPolicyActionType.ESCALATION_POLICY; + + public static final String JSON_PROPERTY_URGENCY = "urgency"; + private Urgency urgency; + + public RoutingRuleEscalationPolicyAction() {} + + @JsonCreator + public RoutingRuleEscalationPolicyAction( + @JsonProperty(required = true, value = JSON_PROPERTY_POLICY_ID) String policyId, + @JsonProperty(required = true, value = JSON_PROPERTY_TYPE) + RoutingRuleEscalationPolicyActionType type) { + this.policyId = policyId; + this.type = type; + this.unparsed |= !type.isValid(); + } + + public RoutingRuleEscalationPolicyAction ackTimeoutMinutes(Long ackTimeoutMinutes) { + this.ackTimeoutMinutes = ackTimeoutMinutes; + return this; + } + + /** + * The number of minutes before an unacknowledged page is re-escalated. + * + * @return ackTimeoutMinutes + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_ACK_TIMEOUT_MINUTES) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Long getAckTimeoutMinutes() { + return ackTimeoutMinutes; + } + + public void setAckTimeoutMinutes(Long ackTimeoutMinutes) { + this.ackTimeoutMinutes = ackTimeoutMinutes; + } + + public RoutingRuleEscalationPolicyAction policyId(String policyId) { + this.policyId = policyId; + return this; + } + + /** + * The ID of the escalation policy to route to. + * + * @return policyId + */ + @JsonProperty(JSON_PROPERTY_POLICY_ID) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getPolicyId() { + return policyId; + } + + public void setPolicyId(String policyId) { + this.policyId = policyId; + } + + public RoutingRuleEscalationPolicyAction supportHours(TimeRestrictions supportHours) { + this.supportHours = supportHours; + this.unparsed |= supportHours.unparsed; + return this; + } + + /** + * Holds time zone information and a list of time restrictions for a routing rule. + * + * @return supportHours + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_SUPPORT_HOURS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public TimeRestrictions getSupportHours() { + return supportHours; + } + + public void setSupportHours(TimeRestrictions supportHours) { + this.supportHours = supportHours; + } + + public RoutingRuleEscalationPolicyAction type(RoutingRuleEscalationPolicyActionType type) { + this.type = type; + this.unparsed |= !type.isValid(); + return this; + } + + /** + * Indicates that the action routes to an escalation policy. + * + * @return type + */ + @JsonProperty(JSON_PROPERTY_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public RoutingRuleEscalationPolicyActionType getType() { + return type; + } + + public void setType(RoutingRuleEscalationPolicyActionType type) { + if (!type.isValid()) { + this.unparsed = true; + } + this.type = type; + } + + public RoutingRuleEscalationPolicyAction urgency(Urgency urgency) { + this.urgency = urgency; + this.unparsed |= !urgency.isValid(); + return this; + } + + /** + * Specifies the level of urgency for a routing rule (low, high, or dynamic). + * + * @return urgency + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_URGENCY) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Urgency getUrgency() { + return urgency; + } + + public void setUrgency(Urgency urgency) { + if (!urgency.isValid()) { + this.unparsed = true; + } + this.urgency = urgency; + } + + /** + * A container for additional, undeclared properties. This is a holder for any undeclared + * properties as specified with the 'additionalProperties' keyword in the OAS document. + */ + private Map additionalProperties; + + /** + * Set the additional (undeclared) property with the specified name and value. If the property + * does not already exist, create it otherwise replace it. + * + * @param key The arbitrary key to set + * @param value The associated value + * @return RoutingRuleEscalationPolicyAction + */ + @JsonAnySetter + public RoutingRuleEscalationPolicyAction putAdditionalProperty(String key, Object value) { + if (this.additionalProperties == null) { + this.additionalProperties = new HashMap(); + } + this.additionalProperties.put(key, value); + return this; + } + + /** + * Return the additional (undeclared) property. + * + * @return The additional properties + */ + @JsonAnyGetter + public Map getAdditionalProperties() { + return additionalProperties; + } + + /** + * Return the additional (undeclared) property with the specified name. + * + * @param key The arbitrary key to get + * @return The specific additional property for the given key + */ + public Object getAdditionalProperty(String key) { + if (this.additionalProperties == null) { + return null; + } + return this.additionalProperties.get(key); + } + + /** Return true if this RoutingRuleEscalationPolicyAction object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + RoutingRuleEscalationPolicyAction routingRuleEscalationPolicyAction = + (RoutingRuleEscalationPolicyAction) o; + return Objects.equals( + this.ackTimeoutMinutes, routingRuleEscalationPolicyAction.ackTimeoutMinutes) + && Objects.equals(this.policyId, routingRuleEscalationPolicyAction.policyId) + && Objects.equals(this.supportHours, routingRuleEscalationPolicyAction.supportHours) + && Objects.equals(this.type, routingRuleEscalationPolicyAction.type) + && Objects.equals(this.urgency, routingRuleEscalationPolicyAction.urgency) + && Objects.equals( + this.additionalProperties, routingRuleEscalationPolicyAction.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash( + ackTimeoutMinutes, policyId, supportHours, type, urgency, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class RoutingRuleEscalationPolicyAction {\n"); + sb.append(" ackTimeoutMinutes: ").append(toIndentedString(ackTimeoutMinutes)).append("\n"); + sb.append(" policyId: ").append(toIndentedString(policyId)).append("\n"); + sb.append(" supportHours: ").append(toIndentedString(supportHours)).append("\n"); + sb.append(" type: ").append(toIndentedString(type)).append("\n"); + sb.append(" urgency: ").append(toIndentedString(urgency)).append("\n"); + sb.append(" additionalProperties: ") + .append(toIndentedString(additionalProperties)) + .append("\n"); + sb.append('}'); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces (except the first line). + */ + private String toIndentedString(Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/RoutingRuleEscalationPolicyActionType.java b/src/main/java/com/datadog/api/client/v2/model/RoutingRuleEscalationPolicyActionType.java new file mode 100644 index 00000000000..91012e5671e --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/RoutingRuleEscalationPolicyActionType.java @@ -0,0 +1,62 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.v2.model; + +import com.datadog.api.client.ModelEnum; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +/** Indicates that the action routes to an escalation policy. */ +@JsonSerialize( + using = + RoutingRuleEscalationPolicyActionType.RoutingRuleEscalationPolicyActionTypeSerializer.class) +public class RoutingRuleEscalationPolicyActionType extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("escalation_policy")); + + public static final RoutingRuleEscalationPolicyActionType ESCALATION_POLICY = + new RoutingRuleEscalationPolicyActionType("escalation_policy"); + + RoutingRuleEscalationPolicyActionType(String value) { + super(value, allowedValues); + } + + public static class RoutingRuleEscalationPolicyActionTypeSerializer + extends StdSerializer { + public RoutingRuleEscalationPolicyActionTypeSerializer( + Class t) { + super(t); + } + + public RoutingRuleEscalationPolicyActionTypeSerializer() { + this(null); + } + + @Override + public void serialize( + RoutingRuleEscalationPolicyActionType value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static RoutingRuleEscalationPolicyActionType fromValue(String value) { + return new RoutingRuleEscalationPolicyActionType(value); + } +} diff --git a/src/test/resources/com/datadog/api/client/v2/api/on-call.feature b/src/test/resources/com/datadog/api/client/v2/api/on-call.feature index 0f4b2a0e340..421f4c051e7 100644 --- a/src/test/resources/com/datadog/api/client/v2/api/on-call.feature +++ b/src/test/resources/com/datadog/api/client/v2/api/on-call.feature @@ -401,7 +401,7 @@ Feature: On-Call And there is a valid "schedule" in the system And there is a valid "escalation_policy" in the system And request contains "team_id" parameter from "dd_team.data.id" - And body with value {"data": {"attributes": {"rules": [{"actions": [{"channel": "channel", "type": "send_slack_message", "workspace": "workspace"}], "query": "tags.service:test", "time_restriction": {"time_zone": "Europe/Paris", "restrictions": [{"end_day": "monday", "end_time": "17:00:00", "start_day": "monday", "start_time": "09:00:00"}, {"end_day": "tuesday", "end_time": "17:00:00", "start_day": "tuesday", "start_time": "09:00:00"}]}}, {"policy_id": "{{ escalation_policy.data.id }}", "query": "", "urgency": "low"}]}, "id": "{{ dd_team.data.id }}", "type": "team_routing_rules"}} + And body with value {"data": {"attributes": {"rules": [{"actions": [{"channel": "channel", "type": "send_slack_message", "workspace": "workspace"}], "query": "tags.service:test", "time_restriction": {"time_zone": "Europe/Paris", "restrictions": [{"end_day": "monday", "end_time": "17:00:00", "start_day": "monday", "start_time": "09:00:00"}, {"end_day": "tuesday", "end_time": "17:00:00", "start_day": "tuesday", "start_time": "09:00:00"}]}}, {"actions": [{"ack_timeout_minutes": 10, "policy_id": "{{ escalation_policy.data.id }}", "support_hours": {"time_zone": "Europe/Paris", "restrictions": [{"end_day": "friday", "end_time": "17:00:00", "start_day": "monday", "start_time": "09:00:00"}]}, "type": "escalation_policy", "urgency": "low"}], "query": "tags.service:test"}, {"actions": [{"policy_id": "{{ escalation_policy.data.id }}", "type": "escalation_policy", "urgency": "low"}], "query": ""}]}, "id": "{{ dd_team.data.id }}", "type": "team_routing_rules"}} And request contains "include" parameter with value "rules" When the request is sent Then the response status is 200 OK